Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset bdca26a in mainline


Ignore:
Timestamp:
2019-05-26T13:21:50Z (20 months ago)
Author:
Jakub Jermář <jakub@…>
Branches:
master
Children:
8aea932
Parents:
967e7a1
git-author:
Matthieu Riolo <matthieu.riolo@…> (2019-05-17 14:27:34)
git-committer:
Jakub Jermář <jakub@…> (2019-05-26 13:21:50)
Message:

Removing printf when failing from lib/rtld

If rtld failed a message was printed with printf.
This has been replaced with DPRINTF which
gives control to the developer over the message

Files:
11 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/include/lib/elf_load.h

    r967e7a1 rbdca26a  
    3838#include <abi/elf.h>
    3939
    40 /**
    41  * ELF error return codes
    42  */
    43 #define EE_OK             0  /* No error */
    44 #define EE_INVALID        1  /* Invalid ELF image */
    45 #define EE_MEMORY         2  /* Cannot allocate address space */
    46 #define EE_INCOMPATIBLE   3  /* ELF image is not compatible with current architecture */
    47 #define EE_UNSUPPORTED    4  /* Non-supported ELF (e.g. dynamic ELFs) */
    48 #define EE_IRRECOVERABLE  5  /* Irrecoverable error. */
    49 
    50 extern unsigned int elf_load(elf_header_t *, as_t *);
    51 extern const char *elf_error(unsigned int rc);
     40extern errno_t elf_load(elf_header_t *, as_t *);
    5241
    5342#endif
  • kernel/generic/include/proc/program.h

    r967e7a1 rbdca26a  
    5050        struct task *task;           /**< Program task */
    5151        struct thread *main_thread;  /**< Program main thread */
    52         unsigned int loader_status;  /**< Binary loader error status */
     52        errno_t loader_status;  /**< Binary loader error status */
    5353} program_t;
    5454
  • kernel/generic/src/lib/elf.c

    r967e7a1 rbdca26a  
    5050#include <lib/elf_load.h>
    5151
    52 static const char *error_codes[] = {
    53         "no error",
    54         "invalid image",
    55         "address space error",
    56         "incompatible image",
    57         "unsupported image type",
    58         "irrecoverable error"
    59 };
    60 
    61 static int load_segment(elf_segment_header_t *, elf_header_t *, as_t *);
     52static errno_t load_segment(elf_segment_header_t *, elf_header_t *, as_t *);
    6253
    6354/** ELF loader
     
    6758 * @param flags  A combination of ELD_F_*
    6859 *
    69  * @return EE_OK on success
     60 * @return EOK on success
    7061 *
    7162 */
    72 unsigned int elf_load(elf_header_t *header, as_t *as)
     63errno_t elf_load(elf_header_t *header, as_t *as)
    7364{
    7465        /* Identify ELF */
     
    7768            (header->e_ident[EI_MAG2] != ELFMAG2) ||
    7869            (header->e_ident[EI_MAG3] != ELFMAG3))
    79                 return EE_INVALID;
     70                return EINVAL;
    8071
    8172        /* Identify ELF compatibility */
     
    8576            (header->e_version != EV_CURRENT) ||
    8677            (header->e_ident[EI_CLASS] != ELF_CLASS))
    87                 return EE_INCOMPATIBLE;
     78                return EINVAL;
    8879
    8980        if (header->e_phentsize != sizeof(elf_segment_header_t))
    90                 return EE_INCOMPATIBLE;
     81                return EINVAL;
    9182
    9283        /* Check if the object type is supported. */
    9384        if (header->e_type != ET_EXEC)
    94                 return EE_UNSUPPORTED;
     85                return ENOTSUP;
    9586
    9687        /* Check if the ELF image starts on a page boundary */
    9788        if (ALIGN_UP((uintptr_t) header, PAGE_SIZE) != (uintptr_t) header)
    98                 return EE_UNSUPPORTED;
     89                return ENOTSUP;
    9990
    10091        /* Walk through all segment headers and process them. */
     
    10899                        continue;
    109100
    110                 int rc = load_segment(seghdr, header, as);
    111                 if (rc != EE_OK)
     101                errno_t rc = load_segment(seghdr, header, as);
     102                if (rc != EOK)
    112103                        return rc;
    113104        }
    114105
    115         return EE_OK;
    116 }
    117 
    118 /** Print error message according to error code.
    119  *
    120  * @param rc Return code returned by elf_load().
    121  *
    122  * @return NULL terminated description of error.
    123  *
    124  */
    125 const char *elf_error(unsigned int rc)
    126 {
    127         assert(rc < sizeof(error_codes) / sizeof(char *));
    128 
    129         return error_codes[rc];
     106        return EOK;
    130107}
    131108
     
    136113 * @param as    Address space into wich the ELF is being loaded.
    137114 *
    138  * @return EE_OK on success, error code otherwise.
     115 * @return EOK on success, error code otherwise.
    139116 *
    140117 */
    141 int load_segment(elf_segment_header_t *entry, elf_header_t *elf, as_t *as)
     118errno_t load_segment(elf_segment_header_t *entry, elf_header_t *elf, as_t *as)
    142119{
    143120        mem_backend_data_t backend_data;
     
    146123                if ((entry->p_offset % entry->p_align) !=
    147124                    (entry->p_vaddr % entry->p_align))
    148                         return EE_INVALID;
     125                        return EINVAL;
    149126        }
    150127
     
    177154            AS_AREA_ATTR_NONE, &elf_backend, &backend_data, &base, 0);
    178155        if (!area)
    179                 return EE_MEMORY;
     156                return ENOMEM;
    180157
    181158        /*
     
    184161         */
    185162
    186         return EE_OK;
     163        return EOK;
    187164}
    188165
  • kernel/generic/src/main/kinit.c

    r967e7a1 rbdca26a  
    291291                        log(LF_OTHER, LVL_ERROR,
    292292                            "init[%zu]: Init binary load failed "
    293                             "(error %s, loader status %u)", i,
    294                             str_error_name(rc), programs[i].loader_status);
     293                            "(error %s, loader status %s)", i,
     294                            str_error_name(rc), str_error_name(programs[i].loader_status));
    295295                }
    296296        }
  • kernel/generic/src/proc/program.c

    r967e7a1 rbdca26a  
    4848#include <security/perm.h>
    4949#include <lib/elf_load.h>
    50 #include <errno.h>
     50#include <str.h>
    5151#include <log.h>
    5252#include <syscall/copy.h>
     
    7676                return ENOMEM;
    7777
    78         prg->loader_status = EE_OK;
     78        prg->loader_status = EOK;
    7979        prg->task = task_create(as, name);
    8080        if (!prg->task) {
     
    149149
    150150        prg->loader_status = elf_load((elf_header_t *) image_addr, as);
    151         if (prg->loader_status != EE_OK) {
     151        if (prg->loader_status != EOK) {
    152152                as_release(as);
    153153                prg->task = NULL;
     
    183183
    184184        prg->loader_status = elf_load((elf_header_t *) program_loader, as);
    185         if (prg->loader_status != EE_OK) {
     185        if (prg->loader_status != EOK) {
    186186                as_release(as);
    187187                log(LF_OTHER, LVL_ERROR, "Cannot spawn loader (%s)",
    188                     elf_error(prg->loader_status));
     188                    str_error(prg->loader_status));
    189189                return ENOENT;
    190190        }
  • uspace/lib/c/generic/elf/elf_load.c

    r967e7a1 rbdca26a  
    5353 * @param file File handle
    5454 * @param info Place to store ELF program information
    55  * @return EE_OK on success or an EE_x error code
     55 * @return EOK on success or an error code
    5656 */
    57 int elf_load(int file, elf_info_t *info)
     57errno_t elf_load(int file, elf_info_t *info)
    5858{
    5959#ifdef CONFIG_RTLD
    6060        rtld_t *env;
    6161#endif
    62         int rc;
     62        errno_t rc;
    6363
    6464        rc = elf_load_file(file, 0, &info->finfo);
    65         if (rc != EE_OK) {
     65        if (rc != EOK) {
    6666                DPRINTF("Failed to load executable '%s'.\n", file_name);
    6767                return rc;
     
    7272                DPRINTF("Binary is statically linked.\n");
    7373                info->env = NULL;
    74                 return EE_OK;
     74                return EOK;
    7575        }
    7676
     
    7979        DPRINTF("- prog dynamic: %p\n", info->finfo.dynamic);
    8080
    81         errno_t rc2 = rtld_prog_process(&info->finfo, &env);
    82         switch (rc2) {
    83         case EOK:
    84                 rc = EE_OK;
    85                 break;
    86         case ENOMEM:
    87                 rc = EE_MEMORY;
    88                 break;
    89         default:
    90                 DPRINTF("Unexpected error code from rtld_prog_process(): %s\n", str_error_name(rc2));
    91                 rc = EE_INVALID;
    92         }
    93 
     81        rc = rtld_prog_process(&info->finfo, &env);
    9482        info->env = env;
    9583#else
    96         rc = EE_UNSUPPORTED;
     84        rc = ENOTSUP;
    9785#endif
    9886        return rc;
  • uspace/lib/c/generic/elf/elf_mod.c

    r967e7a1 rbdca26a  
    6464#define DPRINTF(...)
    6565
    66 static const char *error_codes[] = {
    67         "no error",
    68         "invalid image",
    69         "address space error",
    70         "incompatible image",
    71         "unsupported image type",
    72         "irrecoverable error",
    73         "file io error"
    74 };
    75 
    76 static unsigned int elf_load_module(elf_ld_t *elf);
    77 static int segment_header(elf_ld_t *elf, elf_segment_header_t *entry);
    78 static int load_segment(elf_ld_t *elf, elf_segment_header_t *entry);
     66static errno_t elf_load_module(elf_ld_t *elf);
     67static errno_t segment_header(elf_ld_t *elf, elf_segment_header_t *entry);
     68static errno_t load_segment(elf_ld_t *elf, elf_segment_header_t *entry);
    7969
    8070/** Load ELF binary from a file.
     
    9080 *                  extracted from the binary.
    9181 *
    92  * @return EE_OK on success or EE_xx error code.
    93  *
    94  */
    95 int elf_load_file(int file, eld_flags_t flags, elf_finfo_t *info)
     82 * @return EOK on success or an error code.
     83 *
     84 */
     85errno_t elf_load_file(int file, eld_flags_t flags, elf_finfo_t *info)
    9686{
    9787        elf_ld_t elf;
     
    10393        }
    10494        if (rc != EOK) {
    105                 return EE_IO;
     95                return rc;
    10696        }
    10797
     
    110100        elf.flags = flags;
    111101
    112         int ret = elf_load_module(&elf);
     102        rc = elf_load_module(&elf);
    113103
    114104        vfs_put(ofile);
    115         return ret;
    116 }
    117 
    118 int elf_load_file_name(const char *path, eld_flags_t flags, elf_finfo_t *info)
     105        return rc;
     106}
     107
     108errno_t elf_load_file_name(const char *path, eld_flags_t flags, elf_finfo_t *info)
    119109{
    120110        int file;
    121111        errno_t rc = vfs_lookup(path, 0, &file);
    122112        if (rc == EOK) {
    123                 int ret = elf_load_file(file, flags, info);
     113                rc = elf_load_file(file, flags, info);
    124114                vfs_put(file);
    125                 return ret;
     115                return rc;
    126116        } else {
    127                 return EE_IO;
     117                return EIO;
    128118        }
    129119}
     
    136126 *
    137127 * @param elf           Pointer to loader state buffer.
    138  * @return EE_OK on success or EE_xx error code.
    139  */
    140 static unsigned int elf_load_module(elf_ld_t *elf)
     128 * @return EOK on success or an error code.
     129 */
     130static errno_t elf_load_module(elf_ld_t *elf)
    141131{
    142132        elf_header_t header_buf;
     
    144134        aoff64_t pos = 0;
    145135        size_t nr;
    146         int i, ret;
     136        int i;
    147137        errno_t rc;
    148138
     
    150140        if (rc != EOK || nr != sizeof(elf_header_t)) {
    151141                DPRINTF("Read error.\n");
    152                 return EE_IO;
     142                return EIO;
    153143        }
    154144
     
    159149            header->e_ident[EI_MAG3] != ELFMAG3) {
    160150                DPRINTF("Invalid header.\n");
    161                 return EE_INVALID;
     151                return EINVAL;
    162152        }
    163153
     
    169159            header->e_ident[EI_CLASS] != ELF_CLASS) {
    170160                DPRINTF("Incompatible data/version/class.\n");
    171                 return EE_INCOMPATIBLE;
     161                return EINVAL;
    172162        }
    173163
     
    175165                DPRINTF("e_phentsize: %u != %zu\n", header->e_phentsize,
    176166                    sizeof(elf_segment_header_t));
    177                 return EE_INCOMPATIBLE;
     167                return EINVAL;
    178168        }
    179169
     
    181171        if (header->e_type != ET_EXEC && header->e_type != ET_DYN) {
    182172                DPRINTF("Object type %d is not supported\n", header->e_type);
    183                 return EE_UNSUPPORTED;
     173                return ENOTSUP;
    184174        }
    185175
    186176        if (header->e_phoff == 0) {
    187177                DPRINTF("Program header table is not present!\n");
    188                 return EE_UNSUPPORTED;
     178                return ENOTSUP;
    189179        }
    190180
     
    203193        if (phdr_len > sizeof(phdr)) {
    204194                DPRINTF("more than %d program headers\n", phdr_cap);
    205                 return EE_UNSUPPORTED;
     195                return ENOTSUP;
    206196        }
    207197
     
    210200        if (rc != EOK || nr != phdr_len) {
    211201                DPRINTF("Read error.\n");
    212                 return EE_IO;
     202                return EIO;
    213203        }
    214204
     
    231221        if (base_offset != 0) {
    232222                DPRINTF("ELF headers not present in the text segment.\n");
    233                 return EE_INVALID;
     223                return EINVAL;
    234224        }
    235225
     
    240230                if (module_base != 0) {
    241231                        DPRINTF("Unexpected shared object format.\n");
    242                         return EE_INVALID;
     232                        return EINVAL;
    243233                }
    244234
     
    258248                if (area == AS_MAP_FAILED) {
    259249                        DPRINTF("Can't find suitable memory area.\n");
    260                         return EE_MEMORY;
     250                        return ENOMEM;
    261251                }
    262252
     
    270260                        continue;
    271261
    272                 ret = load_segment(elf, &phdr[i]);
    273                 if (ret != EE_OK)
    274                         return ret;
     262                rc = load_segment(elf, &phdr[i]);
     263                if (rc != EOK)
     264                        return rc;
    275265        }
    276266
     
    292282                        continue;
    293283
    294                 ret = segment_header(elf, &phdr[i]);
    295                 if (ret != EE_OK)
    296                         return ret;
     284                rc = segment_header(elf, &phdr[i]);
     285                if (rc != EOK)
     286                        return rc;
    297287        }
    298288
     
    302292        DPRINTF("Done.\n");
    303293
    304         return EE_OK;
    305 }
    306 
    307 /** Print error message according to error code.
    308  *
    309  * @param rc Return code returned by elf_load().
    310  *
    311  * @return NULL terminated description of error.
    312  */
    313 const char *elf_error(unsigned int rc)
    314 {
    315         assert(rc < sizeof(error_codes) / sizeof(char *));
    316 
    317         return error_codes[rc];
     294        return EOK;
    318295}
    319296
     
    338315 * @param entry Segment header.
    339316 *
    340  * @return EE_OK on success, error code otherwise.
    341  */
    342 static int segment_header(elf_ld_t *elf, elf_segment_header_t *entry)
     317 * @return EOK on success, error code otherwise.
     318 */
     319static errno_t segment_header(elf_ld_t *elf, elf_segment_header_t *entry)
    343320{
    344321        switch (entry->p_type) {
     
    358335                if (entry->p_filesz == 0) {
    359336                        DPRINTF("Zero-sized ELF interp string.\n");
    360                         return EE_INVALID;
     337                        return EINVAL;
    361338                }
    362339                if (elf->info->interp[entry->p_filesz - 1] != '\0') {
    363340                        DPRINTF("Unterminated ELF interp string.\n");
    364                         return EE_INVALID;
     341                        return EINVAL;
    365342                }
    366343                DPRINTF("interpreter: \"%s\"\n", elf->info->interp);
     
    389366        default:
    390367                DPRINTF("Segment p_type %d unknown.\n", entry->p_type);
    391                 return EE_UNSUPPORTED;
    392                 break;
    393         }
    394         return EE_OK;
     368                return ENOTSUP;
     369                break;
     370        }
     371        return EOK;
    395372}
    396373
     
    400377 * @param entry Program header entry describing segment to be loaded.
    401378 *
    402  * @return EE_OK on success, error code otherwise.
    403  */
    404 int load_segment(elf_ld_t *elf, elf_segment_header_t *entry)
     379 * @return EOK on success, error code otherwise.
     380 */
     381errno_t load_segment(elf_ld_t *elf, elf_segment_header_t *entry)
    405382{
    406383        void *a;
     
    435412                            entry->p_offset % entry->p_align,
    436413                            seg_addr % entry->p_align, entry->p_align);
    437                         return EE_INVALID;
     414                        return EINVAL;
    438415                }
    439416        }
     
    466443                DPRINTF("memory mapping failed (%p, %zu)\n",
    467444                    (void *) (base + bias), mem_sz);
    468                 return EE_MEMORY;
     445                return ENOMEM;
    469446        }
    470447
     
    479456        if (rc != EOK || nr != entry->p_filesz) {
    480457                DPRINTF("read error\n");
    481                 return EE_IO;
     458                return EIO;
    482459        }
    483460
     
    487464         */
    488465        if ((elf->flags & ELDF_RW) != 0)
    489                 return EE_OK;
     466                return EOK;
    490467
    491468        DPRINTF("as_area_change_flags(%p, %x)\n",
     
    494471        if (rc != EOK) {
    495472                DPRINTF("Failed to set memory area flags.\n");
    496                 return EE_MEMORY;
     473                return ENOMEM;
    497474        }
    498475
     
    500477                /* Enforce SMC coherence for the segment */
    501478                if (smc_coherence(seg_ptr, entry->p_filesz))
    502                         return EE_MEMORY;
    503         }
    504 
    505         return EE_OK;
     479                        return ENOMEM;
     480        }
     481
     482        return EOK;
    506483}
    507484
  • uspace/lib/c/generic/rtld/module.c

    r967e7a1 rbdca26a  
    6565
    6666        module = calloc(1, sizeof(module_t));
    67         if (module == NULL)
     67        if (module == NULL) {
     68                DPRINTF("malloc failed\n");
    6869                return ENOMEM;
     70        }
    6971
    7072        module->id = rtld_get_next_id(rtld);
     
    182184        char name_buf[NAME_BUF_SIZE];
    183185        module_t *m;
    184         int rc;
     186        errno_t rc;
    185187
    186188        m = calloc(1, sizeof(module_t));
    187189        if (m == NULL) {
    188                 printf("malloc failed\n");
     190                DPRINTF("malloc failed\n");
    189191                goto error;
    190192        }
     
    197199
    198200        if (str_size(name) > NAME_BUF_SIZE - 2) {
    199                 printf("soname too long. increase NAME_BUF_SIZE\n");
     201                DPRINTF("soname too long. increase NAME_BUF_SIZE\n");
    200202                goto error;
    201203        }
     
    208210
    209211        rc = elf_load_file_name(name_buf, RTLD_MODULE_LDF, &info);
    210         if (rc != EE_OK) {
    211                 printf("Failed to load '%s'\n", name_buf);
     212        if (rc != EOK) {
     213                DPRINTF("Failed to load '%s'\n", name_buf);
    212214                goto error;
    213215        }
     
    218220
    219221        if (info.dynamic == NULL) {
    220                 printf("Error: '%s' is not a dynamically-linked object.\n",
     222                DPRINTF("Error: '%s' is not a dynamically-linked object.\n",
    221223                    name_buf);
    222224                goto error;
     
    285287        m->deps = malloc(n * sizeof(module_t *));
    286288        if (!m->deps) {
    287                 printf("malloc failed\n");
     289                DPRINTF("malloc failed\n");
    288290                return ENOMEM;
    289291        }
  • uspace/lib/c/include/elf/elf_load.h

    r967e7a1 rbdca26a  
    4545} elf_info_t;
    4646
    47 extern int elf_load(int, elf_info_t *);
     47extern errno_t elf_load(int, elf_info_t *);
    4848extern void elf_set_pcb(elf_info_t *, pcb_t *);
    4949
  • uspace/lib/c/include/elf/elf_mod.h

    r967e7a1 rbdca26a  
    4242#include <stdint.h>
    4343#include <loader/pcb.h>
    44 
    45 /**
    46  * ELF error return codes
    47  */
    48 #define EE_OK                   0       /* No error */
    49 #define EE_INVALID              1       /* Invalid ELF image */
    50 #define EE_MEMORY               2       /* Cannot allocate address space */
    51 #define EE_INCOMPATIBLE         3       /* ELF image is not compatible with current architecture */
    52 #define EE_UNSUPPORTED          4       /* Non-supported ELF (e.g. dynamic ELFs) */
    53 #define EE_IRRECOVERABLE        5
    54 #define EE_IO                   6       /* Could not read file. */
    5544
    5645typedef enum {
     
    11099} elf_ld_t;
    111100
    112 extern const char *elf_error(unsigned int);
    113 extern int elf_load_file(int, eld_flags_t, elf_finfo_t *);
    114 extern int elf_load_file_name(const char *, eld_flags_t, elf_finfo_t *);
     101extern errno_t elf_load_file(int, eld_flags_t, elf_finfo_t *);
     102extern errno_t elf_load_file_name(const char *, eld_flags_t, elf_finfo_t *);
    115103
    116104#endif
  • uspace/srv/loader/main.c

    r967e7a1 rbdca26a  
    290290        DPRINTF("LOADER_LOAD()\n");
    291291
    292         int rc = elf_load(program_fd, &prog_info);
    293         if (rc != EE_OK) {
     292        errno_t rc = elf_load(program_fd, &prog_info);
     293        if (rc != EOK) {
    294294                DPRINTF("Failed to load executable for '%s'.\n", progname);
    295295                async_answer_0(req, EINVAL);
Note: See TracChangeset for help on using the changeset viewer.