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

Timestamp:

2018-05-01T19:03:38Z (7 years ago)

Author:

GitHub <noreply@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

6e33c2f, 924786bf

Parents:

009c485

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2018-05-01 19:03:38)

git-committer:

GitHub <noreply@…> (2018-05-01 19:03:38)

Message:

Make some effort to allocate the memory area for shared objects. (#33)

File:

• uspace/lib/c/generic/elf/elf_mod.c (modified) (12 diffs)

uspace/lib/c/generic/elf/elf_mod.c

@@ -58 +58 @@
 #include <str_error.h>
 #include <stdlib.h>
+#include <macros.h>
 
 #include <elf/elf_load.h>
@@ -73 +74 @@
 };
 
-static unsigned int elf_load_module(elf_ld_t *elf, size_t so_bias);
+static unsigned int elf_load_module(elf_ld_t *elf);
 static int segment_header(elf_ld_t *elf, elf_segment_header_t *entry);
 static int load_segment(elf_ld_t *elf, elf_segment_header_t *entry);
@@ -86 +87 @@
  *
  * @param file      ELF file.
- * @param so_bias   Bias to use if the file is a shared object.
  * @param info      Pointer to a structure for storing information
  *                  extracted from the binary.
@@ -93 +93 @@
  *
  */
-int elf_load_file(int file, size_t so_bias, eld_flags_t flags, elf_finfo_t *info)
+int elf_load_file(int file, eld_flags_t flags, elf_finfo_t *info)
 {
         elf_ld_t elf;
@@ -110 +110 @@
         elf.flags = flags;
 
-        int ret = elf_load_module(&elf, so_bias);
+        int ret = elf_load_module(&elf);
 
         vfs_put(ofile);
@@ -116 +116 @@
 }
 
-int elf_load_file_name(const char *path, size_t so_bias, eld_flags_t flags,
-    elf_finfo_t *info)
+int elf_load_file_name(const char *path, eld_flags_t flags, elf_finfo_t *info)
 {
         int file;
         errno_t rc = vfs_lookup(path, 0, &file);
         if (rc == EOK) {
-                int ret = elf_load_file(file, so_bias, flags, info);
+                int ret = elf_load_file(file, flags, info);
                 vfs_put(file);
                 return ret;
@@ -137 +136 @@
  *
  * @param elf           Pointer to loader state buffer.
- * @param so_bias       Bias to use if the file is a shared object.
  * @return EE_OK on success or EE_xx error code.
  */
-static unsigned int elf_load_module(elf_ld_t *elf, size_t so_bias)
+static unsigned int elf_load_module(elf_ld_t *elf)
 {
         elf_header_t header_buf;
@@ -154 +152 @@
                 return EE_IO;
         }
-
-        elf->header = header;
 
         /* Identify ELF */
@@ -188 +184 @@
         }
 
+        if (header->e_phoff == 0) {
+                DPRINTF("Program header table is not present!\n");
+                return EE_UNSUPPORTED;
+        }
+
+        /* Read program header table.
+         * Normally, there are very few program headers, so don't bother
+         * with allocating memory dynamically.
+         */
+        const int phdr_cap = 16;
+        elf_segment_header_t phdr[phdr_cap];
+        size_t phdr_len = header->e_phnum * header->e_phentsize;
+
+        if (phdr_len > sizeof(phdr)) {
+                DPRINTF("more than %d program headers\n", phdr_cap);
+                return EE_UNSUPPORTED;
+        }
+
+        pos = header->e_phoff;
+        rc = vfs_read(elf->fd, &pos, phdr, phdr_len, &nr);
+        if (rc != EOK || nr != phdr_len) {
+                DPRINTF("Read error.\n");
+                return EE_IO;
+        }
+
+        uintptr_t module_base = UINTPTR_MAX;
+        uintptr_t module_top = 0;
+        uintptr_t base_offset = UINTPTR_MAX;
+
+        /* Walk through PT_LOAD headers, to find out the size of the module. */
+        for (i = 0; i < header->e_phnum; i++) {
+                if (phdr[i].p_type != PT_LOAD)
+                        continue;
+
+                if (module_base > phdr[i].p_vaddr) {
+                        module_base = phdr[i].p_vaddr;
+                        base_offset = phdr[i].p_offset;
+                }
+                module_top = max(module_top, phdr[i].p_vaddr + phdr[i].p_memsz);
+        }
+
+        if (base_offset != 0) {
+                DPRINTF("ELF headers not present in the text segment.\n");
+                return EE_INVALID;
+        }
+
         /* Shared objects can be loaded with a bias */
-        if (header->e_type == ET_DYN)
-                elf->bias = so_bias;
-        else
+        if (header->e_type != ET_DYN) {
                 elf->bias = 0;
+        } else {
+                if (module_base != 0) {
+                        DPRINTF("Unexpected shared object format.\n");
+                        return EE_INVALID;
+                }
+
+                /* Attempt to allocate a span of memory large enough for the
+                 * shared object.
+                 */
+                // FIXME: This is not reliable when we're running
+                //        multi-threaded. Even if this part succeeds, later
+                //        allocation can fail because another thread took the
+                //        space in the meantime. This is only relevant for
+                //        dlopen() though.
+                void *area = as_area_create(AS_AREA_ANY, module_top,
+                    AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE |
+                    AS_AREA_LATE_RESERVE, AS_AREA_UNPAGED);
+
+                if (area == AS_MAP_FAILED) {
+                        DPRINTF("Can't find suitable memory area.\n");
+                        return EE_MEMORY;
+                }
+
+                elf->bias = (uintptr_t) area;
+                as_area_destroy(area);
+        }
+
+        /* Load all loadable segments. */
+        for (i = 0; i < header->e_phnum; i++) {
+                if (phdr[i].p_type != PT_LOAD)
+                        continue;
+
+                ret = load_segment(elf, &phdr[i]);
+                if (ret != EE_OK)
+                        return ret;
+        }
+
+        void *base = (void *) module_base + elf->bias;
+        elf->info->base = base;
 
         /* Ensure valid TLS info even if there is no TLS header. */
@@ -205 +284 @@
         /* Walk through all segment headers and process them. */
         for (i = 0; i < header->e_phnum; i++) {
-                elf_segment_header_t segment_hdr;
-
-                pos = header->e_phoff + i * sizeof(elf_segment_header_t);
-                rc = vfs_read(elf->fd, &pos, &segment_hdr,
-                    sizeof(elf_segment_header_t), &nr);
-                if (rc != EOK || nr != sizeof(elf_segment_header_t)) {
-                        DPRINTF("Read error.\n");
-                        return EE_IO;
-                }
-
-                ret = segment_header(elf, &segment_hdr);
+                if (phdr[i].p_type == PT_LOAD)
+                        continue;
+
+                ret = segment_header(elf, &phdr[i]);
                 if (ret != EE_OK)
                         return ret;
@@ -270 +342 @@
         case PT_NOTE:
                 break;
-        case PT_LOAD:
-                return load_segment(elf, entry);
-                break;
         case PT_INTERP:
                 elf->info->interp =
                     (void *)((uint8_t *)entry->p_vaddr + elf->bias);
 
-                // FIXME: This actually won't work, because the text segment is
-                // not loaded yet.
-#if 0
                 if (elf->info->interp[entry->p_filesz - 1] != '\0') {
                         DPRINTF("Unterminated ELF interp string.\n");
@@ -285 +351 @@
                 }
                 DPRINTF("interpreter: \"%s\"\n", elf->info->interp);
-#endif
                 break;
         case PT_DYNAMIC: