Changes in / [0803134:1facf8e] in mainline


Ignore:
Location:
uspace
Files:
14 added
5 deleted
15 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/bdsh/exec.c

    r0803134 r1facf8e  
    5252static int try_access(const char *);
    5353
    54 const char *search_dir[] = { "app", "srv", NULL };
     54const char *search_dir[] = { "/app", "/srv", NULL };
    5555
    5656/* work-around for access() */

  • uspace/app/taskdump/elf_core.c

    r0803134 r1facf8e  
    11/*
    2  * Copyright (c) 2010 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3838 * Looking at core files produced by Linux, these don't have section headers,
    3939 * only program headers, although objdump shows them as having sections.
    40  * Basically at the beginning there should be a note segment (which we
    41  * do not write) and one loadable segment per memory area (which we do write).
    42  *
    43  * The note segment probably contains register state, etc. -- we don't
    44  * deal with these yet. Nevertheless you can use these core files with
    45  * objdump or gdb.
    46  */
    47 
     40 * Basically at the beginning there should be a note segment followed
     41 * by one loadable segment per memory area.
     42 *
     43 * The note segment contains a series of records with register state,
     44 * process info etc. We only write one record NT_PRSTATUS which contains
     45 * process/register state (anything which is not register state we fill
     46 * with zeroes).
     47 */
     48
     49#include <align.h>
     50#include <elf/elf.h>
     51#include <elf/elf_linux.h>
    4852#include <stdio.h>
    4953#include <stdlib.h>
    … …  
    5862#include <udebug.h>
    5963#include <macros.h>
    60 
    61 #include <elf.h>
    62 #include "include/elf_core.h"
     64#include <libarch/istate.h>
     65
     66#include "elf_core.h"
    6367
    6468static off64_t align_foff_up(off64_t, uintptr_t, size_t);
    65 static int write_all(int, void *, size_t);
     69static int write_all(int, const void *, size_t);
     70static int align_pos(int, size_t);
    6671static int write_mem_area(int, as_area_info_t *, async_sess_t *);
    6772
    … …  
    8388 */
    8489int elf_core_save(const char *file_name, as_area_info_t *ainfo, unsigned int n,
    85     async_sess_t *sess)
     90    async_sess_t *sess, istate_t *istate)
    8691{
    8792        elf_header_t elf_hdr;
    … …  
    9095        elf_word flags;
    9196        elf_segment_header_t *p_hdr;
     97        elf_prstatus_t pr_status;
     98        elf_note_t note;
     99        size_t word_size;
    92100
    93101        int fd;
    … …  
    95103        unsigned int i;
    96104
    97         n_ph = n;
    98 
    99         p_hdr = malloc(sizeof(elf_segment_header_t) * n);
     105#ifdef __32_BITS__
     106        word_size = 4;
     107#endif
     108#ifdef __64_BITS__
     109        word_size = 8;
     110#endif
     111        memset(&pr_status, 0, sizeof(pr_status));
     112        istate_to_elf_regs(istate, &pr_status.regs);
     113
     114        n_ph = n + 1;
     115
     116        p_hdr = malloc(sizeof(elf_segment_header_t) * n_ph);
    100117        if (p_hdr == NULL) {
    101118                printf("Failed allocating memory.\n");
    … …  
    115132         *      ELF header
    116133         *      program headers
     134         *      note segment
    117135         * repeat:
    118136         *      (pad for alignment)
    119          *      segment data
     137         *      core segment
    120138         * end repeat
    121139         */
    … …  
    147165        foff = elf_hdr.e_phoff + n_ph * sizeof(elf_segment_header_t);
    148166
    149         for (i = 1; i <= n; ++i) {
    150                 foff = align_foff_up(foff, ainfo[i - 1].start_addr, PAGE_SIZE);
     167        memset(&p_hdr[0], 0, sizeof(p_hdr[0]));
     168        p_hdr[0].p_type = PT_NOTE;
     169        p_hdr[0].p_offset = foff;
     170        p_hdr[0].p_vaddr = 0;
     171        p_hdr[0].p_paddr = 0;
     172        p_hdr[0].p_filesz = sizeof(elf_note_t)
     173            + ALIGN_UP((str_size("CORE") + 1), word_size)
     174            + ALIGN_UP(sizeof(elf_prstatus_t), word_size);
     175        p_hdr[0].p_memsz = 0;
     176        p_hdr[0].p_flags = 0;
     177        p_hdr[0].p_align = 1;
     178
     179        foff += p_hdr[0].p_filesz;
     180
     181        for (i = 0; i < n; ++i) {
     182                foff = align_foff_up(foff, ainfo[i].start_addr, PAGE_SIZE);
    151183
    152184                flags = 0;
    153                 if (ainfo[i - 1].flags & AS_AREA_READ)
     185                if (ainfo[i].flags & AS_AREA_READ)
    154186                        flags |= PF_R;
    155                 if (ainfo[i - 1].flags & AS_AREA_WRITE)
     187                if (ainfo[i].flags & AS_AREA_WRITE)
    156188                        flags |= PF_W;
    157                 if (ainfo[i - 1].flags & AS_AREA_EXEC)
     189                if (ainfo[i].flags & AS_AREA_EXEC)
    158190                        flags |= PF_X;
    159191
    160                 memset(&p_hdr[i - 1], 0, sizeof(p_hdr[i - 1]));
    161                 p_hdr[i - 1].p_type = PT_LOAD;
    162                 p_hdr[i - 1].p_offset = foff;
    163                 p_hdr[i - 1].p_vaddr = ainfo[i - 1].start_addr;
    164                 p_hdr[i - 1].p_paddr = 0;
    165                 p_hdr[i - 1].p_filesz = ainfo[i - 1].size;
    166                 p_hdr[i - 1].p_memsz = ainfo[i - 1].size;
    167                 p_hdr[i - 1].p_flags = flags;
    168                 p_hdr[i - 1].p_align = PAGE_SIZE;
    169 
    170                 foff += ainfo[i - 1].size;
     192                memset(&p_hdr[i + 1], 0, sizeof(p_hdr[i + 1]));
     193                p_hdr[i + 1].p_type = PT_LOAD;
     194                p_hdr[i + 1].p_offset = foff;
     195                p_hdr[i + 1].p_vaddr = ainfo[i].start_addr;
     196                p_hdr[i + 1].p_paddr = 0;
     197                p_hdr[i + 1].p_filesz = ainfo[i].size;
     198                p_hdr[i + 1].p_memsz = ainfo[i].size;
     199                p_hdr[i + 1].p_flags = flags;
     200                p_hdr[i + 1].p_align = PAGE_SIZE;
     201
     202                foff += ainfo[i].size;
    171203        }
    172204
    … …  
    187219        }
    188220
    189         for (i = 0; i < n_ph; ++i) {
     221        if (lseek(fd, p_hdr[0].p_offset, SEEK_SET) == (off64_t) -1) {
     222                printf("Failed writing memory data.\n");
     223                free(p_hdr);
     224                return EIO;
     225        }
     226
     227        /*
     228         * Write note header
     229         */
     230        note.namesz = str_size("CORE") + 1;
     231        note.descsz = sizeof(elf_prstatus_t);
     232        note.type = NT_PRSTATUS;
     233
     234        rc = write_all(fd, &note, sizeof(elf_note_t));
     235        if (rc != EOK) {
     236                printf("Failed writing note header.\n");
     237                free(p_hdr);
     238                return EIO;
     239        }
     240
     241        rc = write_all(fd, "CORE", note.namesz);
     242        if (rc != EOK) {
     243                printf("Failed writing note header.\n");
     244                free(p_hdr);
     245                return EIO;
     246        }
     247
     248        rc = align_pos(fd, word_size);
     249        if (rc != EOK) {
     250                printf("Failed writing note header.\n");
     251                free(p_hdr);
     252                return EIO;
     253        }
     254
     255        rc = write_all(fd, &pr_status, sizeof(elf_prstatus_t));
     256        if (rc != EOK) {
     257                printf("Failed writing register data.\n");
     258                free(p_hdr);
     259                return EIO;
     260        }
     261
     262        for (i = 1; i < n_ph; ++i) {
    190263                if (lseek(fd, p_hdr[i].p_offset, SEEK_SET) == (off64_t) -1) {
    191264                        printf("Failed writing memory data.\n");
    … …  
    193266                        return EIO;
    194267                }
    195                 if (write_mem_area(fd, &ainfo[i], sess) != EOK) {
     268                if (write_mem_area(fd, &ainfo[i - 1], sess) != EOK) {
    196269                        printf("Failed writing memory data.\n");
    197270                        free(p_hdr);
    … …  
    210283        off64_t rva = vaddr % page_size;
    211284        off64_t rfo = foff % page_size;
    212        
     285
    213286        if (rva >= rfo)
    214287                return (foff + (rva - rfo));
    215        
     288
    216289        return (foff + (page_size + (rva - rfo)));
    217290}
    … …  
    268341 *                      failed.
    269342 */
    270 static int write_all(int fd, void *data, size_t len)
     343static int write_all(int fd, const void *data, size_t len)
    271344{
    272345        int cnt = 0;
    … …  
    287360}
    288361
     362static int align_pos(int fd, size_t align)
     363{
     364        off64_t cur_pos;
     365        size_t rem, adv;
     366
     367        cur_pos = lseek(fd, 0, SEEK_CUR);
     368        if (cur_pos < 0)
     369                return -1;
     370
     371        rem = cur_pos % align;
     372        adv = align - rem;
     373
     374        cur_pos = lseek(fd, adv, SEEK_CUR);
     375        if (cur_pos < 0)
     376                return -1;
     377
     378        return EOK;
     379}
    289380
    290381/** @}

  • uspace/app/taskdump/include/elf_core.h

    r0803134 r1facf8e  
    3737
    3838#include <async.h>
     39#include <elf/elf_linux.h>
     40#include <libarch/istate.h>
    3941
    4042extern int elf_core_save(const char *, as_area_info_t *, unsigned int,
    41     async_sess_t *);
     43    async_sess_t *, istate_t *);
    4244
    4345#endif

  • uspace/app/taskdump/include/symtab.h

    r0803134 r1facf8e  
    3636#define SYMTAB_H_
    3737
     38#include <elf/elf.h>
    3839#include <sys/types.h>
    39 #include <elf.h>
    4040
    4141typedef struct {

  • uspace/app/taskdump/symtab.c

    r0803134 r1facf8e  
    3636 */
    3737
     38#include <elf/elf.h>
    3839#include <stdio.h>
    3940#include <stdlib.h>
    … …  
    4344#include <fcntl.h>
    4445
    45 #include <elf.h>
    4646#include "include/symtab.h"
    4747

  • uspace/app/taskdump/taskdump.c

    r0803134 r1facf8e  
    3434
    3535#include <async.h>
     36#include <elf/elf_linux.h>
    3637#include <stdio.h>
    3738#include <stdlib.h>
    … …  
    7273static char *get_app_task_name(void);
    7374static char *fmt_sym_address(uintptr_t addr);
     75
     76static istate_t reg_state;
    7477
    7578int main(int argc, char *argv[])
    … …  
    293296        if (write_core_file) {
    294297                printf("Writing core file '%s'\n", core_file_name);
    295                 rc = elf_core_save(core_file_name, ainfo_buf, n_areas, sess);
     298
     299                rc = elf_core_save(core_file_name, ainfo_buf, n_areas, sess,
     300                    &reg_state);
     301
    296302                if (rc != EOK) {
    297303                        printf("Failed writing core file.\n");
    … …  
    321327        pc = istate_get_pc(&istate);
    322328        fp = istate_get_fp(&istate);
     329
     330        /* Save register state for dumping to core file later. */
     331        reg_state = istate;
    323332
    324333        sym_pc = fmt_sym_address(pc);

  • uspace/lib/c/Makefile

    r0803134 r1facf8e  
    5959-include arch/$(UARCH)/Makefile.inc
    6060
    61 EXTRA_CFLAGS += -I../../srv/loader/include
    62 
    6361GENERIC_SOURCES = \
    6462        generic/libc.c \
    … …  
    7169        generic/device/hw_res.c \
    7270        generic/device/char_dev.c \
     71        generic/elf/elf_load.c \
    7372        generic/event.c \
    7473        generic/errno.c \
    … …  
    134133                generic/dlfcn.c \
    135134                generic/rtld/rtld.c \
    136                 generic/rtld/elf_load.c \
    137135                generic/rtld/dynamic.c \
    138136                generic/rtld/module.c \

  • uspace/lib/c/generic/rtld/module.c

    r0803134 r1facf8e  
    3535 */
    3636
     37#include <adt/list.h>
     38#include <elf/elf_load.h>
     39#include <fcntl.h>
     40#include <loader/pcb.h>
    3741#include <stdio.h>
    3842#include <stdlib.h>
    3943#include <unistd.h>
    40 #include <fcntl.h>
    41 #include <adt/list.h>
    42 #include <loader/pcb.h>
    4344
    4445#include <rtld/rtld.h>
    … …  
    4748#include <rtld/rtld_arch.h>
    4849#include <rtld/module.h>
    49 #include <elf_load.h>
    5050
    5151/** (Eagerly) process all relocation tables in a module.
    … …  
    9393module_t *module_find(const char *name)
    9494{
    95         link_t *head = &runtime_env->modules_head;
    96 
    97         link_t *cur;
    9895        module_t *m;
    9996        const char *p, *soname;
    … …  
    110107
    111108        /* Traverse list of all modules. Not extremely fast, but simple */
    112         DPRINTF("head = %p\n", head);
    113         for (cur = head->next; cur != head; cur = cur->next) {
     109        list_foreach(runtime_env->modules, cur) {
    114110                DPRINTF("cur = %p\n", cur);
    115111                m = list_get_instance(cur, module_t, modules_link);
    … …  
    177173
    178174        /* Insert into the list of loaded modules */
    179         list_append(&m->modules_link, &runtime_env->modules_head);
     175        list_append(&m->modules_link, &runtime_env->modules);
    180176
    181177        return m;
    … …  
    249245void modules_process_relocs(module_t *start)
    250246{
    251         link_t *head = &runtime_env->modules_head;
    252 
    253         link_t *cur;
    254         module_t *m;
    255 
    256         for (cur = head->next; cur != head; cur = cur->next) {
     247        module_t *m;
     248
     249        list_foreach(runtime_env->modules, cur) {
    257250                m = list_get_instance(cur, module_t, modules_link);
    258251
    … …  
    268261void modules_untag(void)
    269262{
    270         link_t *head = &runtime_env->modules_head;
    271 
    272         link_t *cur;
    273         module_t *m;
    274 
    275         for (cur = head->next; cur != head; cur = cur->next) {
     263        module_t *m;
     264
     265        list_foreach(runtime_env->modules, cur) {
    276266                m = list_get_instance(cur, module_t, modules_link);
    277267                m->bfs_tag = false;

  • uspace/lib/c/generic/rtld/rtld.c

    r0803134 r1facf8e  
    4444{
    4545        runtime_env = &rt_env_static;
    46         list_initialize(&runtime_env->modules_head);
     46        list_initialize(&runtime_env->modules);
    4747        runtime_env->next_bias = 0x2000000;
    4848        runtime_env->program = NULL;

  • uspace/lib/c/generic/rtld/symbol.c

    r0803134 r1facf8e  
    3838#include <stdlib.h>
    3939
     40#include <elf/elf.h>
    4041#include <rtld/rtld.h>
    4142#include <rtld/rtld_debug.h>
    4243#include <rtld/symbol.h>
    43 #include <elf.h>
    4444
    4545/*
    … …  
    118118        module_t *m, *dm;
    119119        elf_symbol_t *sym, *s;
    120         link_t queue_head;
     120        list_t queue;
    121121        size_t i;
    122122
    … …  
    132132
    133133        /* Insert root (the program) into the queue and tag it */
    134         list_initialize(&queue_head);
     134        list_initialize(&queue);
    135135        start->bfs_tag = true;
    136         list_append(&start->queue_link, &queue_head);
     136        list_append(&start->queue_link, &queue);
    137137
    138138        /* If the symbol is found, it will be stored in 'sym' */
    … …  
    140140
    141141        /* While queue is not empty */
    142         while (!list_empty(&queue_head)) {
     142        while (!list_empty(&queue)) {
    143143                /* Pop first element from the queue */
    144                 m = list_get_instance(queue_head.next, module_t, queue_link);
     144                m = list_get_instance(list_first(&queue), module_t, queue_link);
    145145                list_remove(&m->queue_link);
    146146
    … …  
    162162                        if (dm->bfs_tag == false) {
    163163                                dm->bfs_tag = true;
    164                                 list_append(&dm->queue_link, &queue_head);
     164                                list_append(&dm->queue_link, &queue);
    165165                        }
    166166                }
    … …  
    168168
    169169        /* Empty the queue so that we leave it in a clean state */
    170         while (!list_empty(&queue_head))
    171                 list_remove(queue_head.next);
     170        while (!list_empty(&queue))
     171                list_remove(list_first(&queue));
    172172
    173173        if (!sym) {

  • uspace/lib/c/include/rtld/elf_dyn.h

    r0803134 r1facf8e  
    3939#include <sys/types.h>
    4040
    41 #include <elf.h>
     41#include <elf/elf.h>
    4242#include <libarch/rtld/elf_dyn.h>
    4343

  • uspace/lib/c/include/rtld/rtld.h

    r0803134 r1facf8e  
    4949
    5050        /** List of all loaded modules including rtld and the program */
    51         link_t modules_head;
     51        list_t modules;
    5252
    5353        /** Temporary hack to place each module at different address. */

  • uspace/lib/c/include/rtld/symbol.h

    r0803134 r1facf8e  
    3636#define LIBC_RTLD_SYMBOL_H_
    3737
     38#include <elf/elf.h>
    3839#include <rtld/rtld.h>
    39 #include <elf.h>
    4040
    4141elf_symbol_t *symbol_bfs_find(const char *name, module_t *start, module_t **mod);

  • uspace/srv/loader/Makefile

    r0803134 r1facf8e  
    3939LINKER_SCRIPT = $(LIBC_PREFIX)/arch/$(UARCH)/_link-loader.ld
    4040
    41 EXTRA_CFLAGS = -Iinclude
    42 
    4341BINARY = loader
    4442STATIC_ONLY = y
    … …  
    4644GENERIC_SOURCES = \
    4745        main.c \
    48         elf_load.c \
    4946        interp.s
    5047

  • uspace/srv/loader/main.c

    r0803134 r1facf8e  
    5959#include <str.h>
    6060#include <as.h>
    61 #include <elf.h>
    62 #include <elf_load.h>
     61#include <elf/elf.h>
     62#include <elf/elf_load.h>
    6363
    6464#ifdef CONFIG_RTLD
    … …  
    348348
    349349        /* Initialize list of loaded modules */
    350         list_initialize(&runtime_env->modules_head);
    351         list_append(&prog_mod.modules_link, &runtime_env->modules_head);
     350        list_initialize(&runtime_env->modules);
     351        list_append(&prog_mod.modules_link, &runtime_env->modules);
    352352
    353353        /* Pointer to program module. Used as root of the module graph. */
Note: See TracChangeset for help on using the changeset viewer.