Changeset bdca26a in mainline for uspace/lib/c/generic/elf/elf_mod.c


Ignore:
Timestamp:
2019-05-26T13:21:50Z (5 years ago)
Author:
Jakub Jermář <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
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

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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
Note: See TracChangeset for help on using the changeset viewer.