Changeset acb14ce in mainline


Ignore:
Timestamp:
2025-02-02T22:06:07Z (4 weeks ago)
Author:
Matěj Volf <git@…>
Children:
c095552
Parents:
bdcf71e
git-author:
Matěj Volf <git@…> (2025-02-02 21:59:42)
git-committer:
Matěj Volf <git@…> (2025-02-02 22:06:07)
Message:

unify rtld loading implementation of static/dynamic executables

Location:
uspace/lib/c
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/elf/elf_load.c

    rbdcf71e racb14ce  
    6969        }
    7070
     71#ifdef CONFIG_RTLD
     72        DPRINTF("- prog dynamic: %p\n", finfo->dynamic);
     73        rc = rtld_prog_process(finfo, &env);
     74        if (rc != EOK) {
     75                DPRINTF("Failed to process executable '%s'.\n", file_name);
     76                return rc;
     77        }
     78        info->env = env;
     79        return EOK;
     80#else
    7181        if (info->finfo.dynamic == NULL) {
    72                 /* Statically linked program */
    73                 DPRINTF("Binary is statically linked.\n");
    7482                info->env = NULL;
    75 #ifdef CONFIG_RTLD
    76                 rc = rtld_init_static(finfo, &env);
    77                 info->env = env;
    78 #endif
    7983                return EOK;
    8084        }
    8185
    82         DPRINTF("Binary is dynamically linked.\n");
    83 #ifdef CONFIG_RTLD
    84         DPRINTF("- prog dynamic: %p\n", finfo->dynamic);
    85         rc = rtld_prog_process(finfo, &env);
    86         info->env = env;
    87 #else
    88         rc = ENOTSUP;
     86        DPRINTF("Error: trying to run a dynamically-linked executable with CONFIG_RTLD disabled.\n");
     87        return ENOTSUP;
    8988#endif
    90         return rc;
    9189}
    9290

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

    rbdcf71e racb14ce  
    5555#include "../private/libc.h"
    5656
    57 /** Create module for static executable.
    58  *
     57/** Create the "entrypoint" module, of the program executable
     58 *
     59 * @param p_info Program ELF file info
    5960 * @param rtld Run-time dynamic linker
    6061 * @param rmodule Place to store pointer to new module or @c NULL
    6162 * @return EOK on success, ENOMEM if out of memory
    6263 */
    63 errno_t module_create_static_exec(const void *elf, rtld_t *rtld)
     64errno_t module_create_entrypoint(elf_finfo_t *p_info, rtld_t *rtld, module_t **rmodule)
    6465{
    6566        module_t *module;
     67        bool is_dynamic = p_info->dynamic != NULL;
     68        DPRINTF("module_create_entrypoint\n");
    6669
    6770        module = calloc(1, sizeof(module_t));
    68         if (module == NULL) {
    69                 DPRINTF("malloc failed\n");
     71        if (module == NULL)
    7072                return ENOMEM;
    71         }
    72 
     73
     74        uintptr_t bias = elf_get_bias(p_info->base);
     75
     76        /*
     77         * First we need to process dynamic sections of the executable
     78         * program and insert it into the module graph.
     79         */
     80        if (is_dynamic) {
     81                DPRINTF("Parse program .dynamic section at %p\n", p_info->dynamic);
     82                dynamic_parse(p_info->dynamic, bias, &module->dyn);
     83        } else {
     84                DPRINTF("Executable is not dynamically linked\n");
     85        }
     86
     87        module->bias = bias;
    7388        module->id = rtld_get_next_id(rtld);
    7489        module->dyn.soname = "[program]";
    … …  
    7691        module->rtld = rtld;
    7792        module->exec = true;
    78         module->local = true;
    79 
    80         const elf_segment_header_t *tls =
    81             elf_get_phdr(elf, PT_TLS);
    82 
    83         if (tls) {
    84                 uintptr_t bias = elf_get_bias(elf);
    85                 module->tdata = (void *) (tls->p_vaddr + bias);
    86                 module->tdata_size = tls->p_filesz;
    87                 module->tbss_size = tls->p_memsz - tls->p_filesz;
    88                 module->tls_align = tls->p_align;
    89         } else {
    90                 module->tdata = NULL;
    91                 module->tdata_size = 0;
    92                 module->tbss_size = 0;
    93                 module->tls_align = 1;
    94         }
     93        module->local = !is_dynamic;
     94
     95        module->tdata = p_info->tls.tdata;
     96        module->tdata_size = p_info->tls.tdata_size;
     97        module->tbss_size = p_info->tls.tbss_size;
     98        module->tls_align = p_info->tls.tls_align;
     99
     100        DPRINTF("prog tdata at %p size %zu, tbss size %zu\n",
     101        module->tdata, module->tdata_size, module->tbss_size);
    95102
    96103        list_append(&module->modules_link, &rtld->modules);
     104
     105        if (rmodule != NULL)
     106                *rmodule = module;
    97107        return EOK;
    98108}

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

    rbdcf71e racb14ce  
    4444rtld_t *runtime_env;
    4545
    46 /** Initialize the runtime linker for use in a statically-linked executable. */
    47 errno_t rtld_init_static(elf_finfo_t *finfo, rtld_t **rre)
    48 {
    49         rtld_t *env;
    50         errno_t rc;
    51 
    52         env = calloc(1, sizeof(rtld_t));
    53         if (env == NULL)
    54                 return ENOMEM;
    55 
    56         list_initialize(&env->modules);
    57         list_initialize(&env->imodules);
    58         env->program = NULL;
    59         env->next_id = 1;
    60 
    61         rc = module_create_static_exec(finfo->base, env);
    62         if (rc != EOK)
    63                 return rc;
    64 
    65         modules_process_tls(env);
    66 
    67         *rre = env;
    68         return EOK;
    69 }
    70 
    71 /** Initialize and process a dynamically linked executable.
     46/** Initialize and process an executable.
    7247 *
    7348 * @param p_info Program info
    … …  
    7752{
    7853        rtld_t *env;
    79         module_t *prog;
    80 
    81         DPRINTF("Load dynamically linked program.\n");
     54        bool is_dynamic = p_info->dynamic != NULL;
     55        DPRINTF("rtld_prog_process\n");
    8256
    8357        /* Allocate new RTLD environment to pass to the loaded program */
    … …  
    8660                return ENOMEM;
    8761
    88         env->next_id = 1;
    89 
    90         prog = calloc(1, sizeof(module_t));
    91         if (prog == NULL) {
    92                 free(env);
    93                 return ENOMEM;
    94         }
    95 
    96         /*
    97          * First we need to process dynamic sections of the executable
    98          * program and insert it into the module graph.
    99          */
    100 
    101         DPRINTF("Parse program .dynamic section at %p\n", p_info->dynamic);
    102         dynamic_parse(p_info->dynamic, 0, &prog->dyn);
    103         prog->bias = 0;
    104         prog->dyn.soname = "[program]";
    105         prog->rtld = env;
    106         prog->id = rtld_get_next_id(env);
    107         prog->exec = true;
    108         prog->local = false;
    109 
    110         prog->tdata = p_info->tls.tdata;
    111         prog->tdata_size = p_info->tls.tdata_size;
    112         prog->tbss_size = p_info->tls.tbss_size;
    113         prog->tls_align = p_info->tls.tls_align;
    114 
    115         DPRINTF("prog tdata at %p size %zu, tbss size %zu\n",
    116             prog->tdata, prog->tdata_size, prog->tbss_size);
    117 
    118         /* Initialize list of loaded modules */
    11962        list_initialize(&env->modules);
    12063        list_initialize(&env->imodules);
    121         list_append(&prog->modules_link, &env->modules);
    122 
    123         /* Pointer to program module. Used as root of the module graph. */
    124         env->program = prog;
    125 
    126         /*
    127          * Now we can continue with loading all other modules.
    128          */
    129 
    130         DPRINTF("Load all program dependencies\n");
    131         errno_t rc = module_load_deps(prog, 0);
     64        env->next_id = 1;
     65
     66        module_t *module;
     67        errno_t rc = module_create_entrypoint(p_info, env, &module);
    13268        if (rc != EOK) {
    133                 free(prog);
    13469                free(env);
    13570                return rc;
    13671        }
    13772
     73        /* Pointer to program module. Used as root of the module graph. */
     74        env->program = module;
     75
     76        /*
     77         * Now we can continue with loading all other modules.
     78         */
     79
     80        if (is_dynamic) {
     81                DPRINTF("Load all program dependencies\n");
     82                rc = module_load_deps(module, 0);
     83                if (rc != EOK) {
     84                        free(module);
     85                        free(env);
     86                        return rc;
     87                }
     88        }
     89
    13890        /* Compute static TLS size */
    13991        modules_process_tls(env);
    … …  
    14395         */
    14496
    145         /* Process relocations in all modules */
    146         DPRINTF("Relocate all modules\n");
    147         modules_process_relocs(env, prog);
    148 
    149         *rre = env;
     97        if (is_dynamic) {
     98                /* Process relocations in all modules */
     99                DPRINTF("Relocate all modules\n");
     100                modules_process_relocs(env, module);
     101        }
     102
     103        if (rre != NULL)
     104                *rre = env;
    150105        return EOK;
    151106}

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

    rbdcf71e racb14ce  
    4141#include <types/rtld/rtld.h>
    4242
    43 extern errno_t module_create_static_exec(const void *, rtld_t *);
     43extern errno_t module_create_entrypoint(elf_finfo_t *, rtld_t *, module_t **);
    4444extern void module_process_relocs(module_t *);
    4545extern module_t *module_find(rtld_t *, const char *);

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

    rbdcf71e racb14ce  
    4545extern rtld_t *runtime_env;
    4646
    47 extern errno_t rtld_init_static(elf_finfo_t *, rtld_t **);
    4847extern errno_t rtld_prog_process(elf_finfo_t *, rtld_t **);
    4948extern tcb_t *rtld_tls_make(rtld_t *);
Note: See TracChangeset for help on using the changeset viewer.