| /* Map in a shared object's segments from the file. |
| Copyright (C) 1995-2018 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| The GNU C Library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with the GNU C Library; if not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #ifndef _DL_LOAD_H |
| #define _DL_LOAD_H 1 |
| |
| #include <link.h> |
| #include <sys/mman.h> |
| |
| |
| /* On some systems, no flag bits are given to specify file mapping. */ |
| #ifndef MAP_FILE |
| # define MAP_FILE 0 |
| #endif |
| |
| /* The right way to map in the shared library files is MAP_COPY, which |
| makes a virtual copy of the data at the time of the mmap call; this |
| guarantees the mapped pages will be consistent even if the file is |
| overwritten. Some losing VM systems like Linux's lack MAP_COPY. All we |
| get is MAP_PRIVATE, which copies each page when it is modified; this |
| means if the file is overwritten, we may at some point get some pages |
| from the new version after starting with pages from the old version. |
| |
| To make up for the lack and avoid the overwriting problem, |
| what Linux does have is MAP_DENYWRITE. This prevents anyone |
| from modifying the file while we have it mapped. */ |
| #ifndef MAP_COPY |
| # ifdef MAP_DENYWRITE |
| # define MAP_COPY (MAP_PRIVATE | MAP_DENYWRITE) |
| # else |
| # define MAP_COPY MAP_PRIVATE |
| # endif |
| #endif |
| |
| /* Some systems link their relocatable objects for another base address |
| than 0. We want to know the base address for these such that we can |
| subtract this address from the segment addresses during mapping. |
| This results in a more efficient address space usage. Defaults to |
| zero for almost all systems. */ |
| #ifndef MAP_BASE_ADDR |
| # define MAP_BASE_ADDR(l) 0 |
| #endif |
| |
| |
| /* Handle situations where we have a preferred location in memory for |
| the shared objects. */ |
| #ifdef ELF_PREFERRED_ADDRESS_DATA |
| ELF_PREFERRED_ADDRESS_DATA; |
| #endif |
| #ifndef ELF_PREFERRED_ADDRESS |
| # define ELF_PREFERRED_ADDRESS(loader, maplength, mapstartpref) (mapstartpref) |
| #endif |
| #ifndef ELF_FIXED_ADDRESS |
| # define ELF_FIXED_ADDRESS(loader, mapstart) ((void) 0) |
| #endif |
| |
| |
| /* This structure describes one PT_LOAD command. |
| Its details have been expanded out and converted. */ |
| struct loadcmd |
| { |
| ElfW(Addr) mapstart, mapend, dataend, allocend; |
| ElfW(Off) mapoff; |
| int prot; /* PROT_* bits. */ |
| }; |
| |
| |
| /* This is a subroutine of _dl_map_segments. It should be called for each |
| load command, some time after L->l_addr has been set correctly. It is |
| responsible for setting up the l_text_end and l_phdr fields. */ |
| static void __always_inline |
| _dl_postprocess_loadcmd (struct link_map *l, const ElfW(Ehdr) *header, |
| const struct loadcmd *c) |
| { |
| if (c->prot & PROT_EXEC) |
| l->l_text_end = l->l_addr + c->mapend; |
| |
| if (l->l_phdr == 0 |
| && c->mapoff <= header->e_phoff |
| && ((size_t) (c->mapend - c->mapstart + c->mapoff) |
| >= header->e_phoff + header->e_phnum * sizeof (ElfW(Phdr)))) |
| /* Found the program header in this segment. */ |
| l->l_phdr = (void *) (uintptr_t) (c->mapstart + header->e_phoff |
| - c->mapoff); |
| } |
| |
| |
| /* This is a subroutine of _dl_map_object_from_fd. It is responsible |
| for filling in several fields in *L: l_map_start, l_map_end, l_addr, |
| l_contiguous, l_text_end, l_phdr. On successful return, all the |
| segments are mapped (or copied, or whatever) from the file into their |
| final places in the address space, with the correct page permissions, |
| and any bss-like regions already zeroed. It returns a null pointer |
| on success, or an error message string (to be translated) on error |
| (having also set errno). |
| |
| The file <dl-map-segments.h> defines this function. The canonical |
| implementation in elf/dl-map-segments.h might be replaced by a sysdeps |
| version. */ |
| static const char *_dl_map_segments (struct link_map *l, int fd, |
| const ElfW(Ehdr) *header, int type, |
| const struct loadcmd loadcmds[], |
| size_t nloadcmds, |
| const size_t maplength, |
| bool has_holes, |
| struct link_map *loader); |
| |
| /* All the error message strings _dl_map_segments might return are |
| listed here so that different implementations in different sysdeps |
| dl-map-segments.h files all use consistent strings that are |
| guaranteed to have translations. */ |
| #define DL_MAP_SEGMENTS_ERROR_MAP_SEGMENT \ |
| N_("failed to map segment from shared object") |
| #define DL_MAP_SEGMENTS_ERROR_MPROTECT \ |
| N_("cannot change memory protections") |
| #define DL_MAP_SEGMENTS_ERROR_MAP_ZERO_FILL \ |
| N_("cannot map zero-fill pages") |
| |
| |
| #endif /* dl-load.h */ |
