usr/src/lib/libc/sparc/crt/_rtld.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*
  28  * Redirection ld.so.  Based on the 4.x binary compatibility ld.so, used
  29  * to redirect aliases for ld.so to the real one.
  30  */
  31
  32 /*
  33  * Import data structures
  34  */
  35 #include "lint.h"
  36 #include <sys/types.h>
  37 #include <sys/mman.h>
  38 #include <sys/fcntl.h>
  39 #include <sys/stat.h>
  40 #include <sys/sysconfig.h>
  41 #include <sys/auxv.h>
  42 #include <elf.h>
  43 #include <link.h>
  44 #include <string.h>
  45 #include "alias_boot.h"
  46
  47 /*
  48  * Local manifest constants and macros.
  49  */
  50 #define ALIGN(x, a)             ((uintptr_t)(x) & ~((a) - 1))
  51 #define ROUND(x, a)             (((uintptr_t)(x) + ((a) - 1)) &  ~((a) - 1))
  52
  53 #define EMPTY   strings[EMPTY_S]
  54 #define LDSO    strings[LDSO_S]
  55 #define ZERO    strings[ZERO_S]
  56 #define CLOSE   (*(funcs[CLOSE_F]))
  57 #define FSTATAT (*(funcs[FSTATAT_F]))
  58 #define MMAP    (*(funcs[MMAP_F]))
  59 #define MUNMAP  (*(funcs[MUNMAP_F]))
  60 #define OPENAT  (*(funcs[OPENAT_F]))
  61 #define PANIC   (*(funcs[PANIC_F]))
  62 #define SYSCONFIG (*(funcs[SYSCONFIG_F]))
  63
  64 /*
  65  * Alias ld.so entry point -- receives a bootstrap structure and a vector
  66  * of strings.  The vector is "well-known" to us, and consists of pointers
  67  * to string constants.  This aliasing bootstrap requires no relocation in
  68  * order to run, save for the pointers of constant strings.  This second
  69  * parameter provides this.  Note that this program is carefully coded in
  70  * order to maintain the "no bootstrapping" requirement -- it calls only
  71  * local functions, uses no intrinsics, etc.
  72  */
  73 void *
  74 __rtld(Elf32_Boot *ebp, const char *strings[], int (*funcs[])())
  75 {
  76         int i, p;                       /* working */
  77         long j;                         /* working */
  78         long page_size = 0;             /* size of a page */
  79         const char *program_name = EMPTY; /* our name */
  80         int ldfd;                       /* fd assigned to ld.so */
  81         int dzfd = 0;                   /* fd assigned to /dev/zero */
  82         Elf32_Ehdr *ehdr;               /* ELF header of ld.so */
  83         Elf32_Phdr *phdr;               /* first Phdr in file */
  84         Elf32_Phdr *pptr;               /* working Phdr */
  85         Elf32_Phdr *lph = NULL;         /* last loadable Phdr */
  86         Elf32_Phdr *fph = NULL;         /* first loadable Phdr */
  87         caddr_t maddr;                  /* pointer to mapping claim */
  88         Elf32_Off mlen;                 /* total mapping claim */
  89         caddr_t faddr;                  /* first program mapping of ld.so */
  90         Elf32_Off foff;                 /* file offset for segment mapping */
  91         Elf32_Off flen;                 /* file length for segment mapping */
  92         caddr_t addr;                   /* working mapping address */
  93         caddr_t zaddr;                  /* /dev/zero working mapping addr */
  94         struct stat sb;                 /* stat buffer for sizing */
  95         auxv_t *ap;                     /* working aux pointer */
  96
  97         /*
  98          * Discover things about our environment: auxiliary vector (if
  99          * any), arguments, program name, and the like.
 100          */
 101         while (ebp->eb_tag != NULL) {
 102                 switch (ebp->eb_tag) {
 103                 case EB_ARGV:
 104                         program_name = *((char **)ebp->eb_un.eb_ptr);
 105                         break;
 106                 case EB_AUXV:
 107                         for (ap = (auxv_t *)ebp->eb_un.eb_ptr;
 108                             ap->a_type != AT_NULL; ap++)
 109                                 if (ap->a_type == AT_PAGESZ) {
 110                                         page_size = ap->a_un.a_val;
 111                                         break;
 112                                 }
 113                         break;
 114                 }
 115                 ebp++;
 116         }
 117
 118         /*
 119          * If we didn't get a page size from looking in the auxiliary
 120          * vector, we need to get one now.
 121          */
 122         if (page_size == 0) {
 123                 page_size = SYSCONFIG(_CONFIG_PAGESIZE);
 124                 ebp->eb_tag = EB_PAGESIZE, (ebp++)->eb_un.eb_val =
 125                     (Elf32_Word)page_size;
 126         }
 127
 128         /*
 129          * Map in the real ld.so.  Note that we're mapping it as
 130          * an ELF database, not as a program -- we just want to walk it's
 131          * data structures.  Further mappings will actually establish the
 132          * program in the address space.
 133          */
 134         if ((ldfd = OPENAT(AT_FDCWD, LDSO, O_RDONLY)) == -1)
 135                 PANIC(program_name);
 136         if (FSTATAT(ldfd, NULL, &sb, 0) == -1)
 137                 PANIC(program_name);
 138         ehdr = (Elf32_Ehdr *)MMAP(0, sb.st_size, PROT_READ | PROT_EXEC,
 139             MAP_SHARED, ldfd, 0);
 140         if (ehdr == (Elf32_Ehdr *)-1)
 141                 PANIC(program_name);
 142
 143         /*
 144          * Validate the file we're looking at, ensure it has the correct
 145          * ELF structures, such as: ELF magic numbers, coded for SPARC,
 146          * is a ".so", etc.
 147          */
 148         if (ehdr->e_ident[EI_MAG0] != ELFMAG0 ||
 149             ehdr->e_ident[EI_MAG1] != ELFMAG1 ||
 150             ehdr->e_ident[EI_MAG2] != ELFMAG2 ||
 151             ehdr->e_ident[EI_MAG3] != ELFMAG3)
 152                 PANIC(program_name);
 153         if (ehdr->e_ident[EI_CLASS] != ELFCLASS32 ||
 154             ehdr->e_ident[EI_DATA] != ELFDATA2MSB)
 155                 PANIC(program_name);
 156         if (ehdr->e_type != ET_DYN)
 157                 PANIC(program_name);
 158         if ((ehdr->e_machine != EM_SPARC) &&
 159             (ehdr->e_machine != EM_SPARC32PLUS))
 160                 PANIC(program_name);
 161         if (ehdr->e_version > EV_CURRENT)
 162                 PANIC(program_name);
 163
 164         /*
 165          * Point at program headers and start figuring out what to load.
 166          */
 167         phdr = (Elf32_Phdr *)((caddr_t)ehdr + ehdr->e_phoff);
 168         for (p = 0, pptr = phdr; p < (int)ehdr->e_phnum; p++,
 169             pptr = (Elf32_Phdr *)((caddr_t)pptr + ehdr->e_phentsize))
 170                 if (pptr->p_type == PT_LOAD) {
 171                         if (fph == 0) {
 172                                 fph = pptr;
 173                         } else if (pptr->p_vaddr <= lph->p_vaddr)
 174                                 PANIC(program_name);
 175                         lph = pptr;
 176                 }
 177
 178         /*
 179          * We'd better have at least one loadable segment.
 180          */
 181         if (fph == 0)
 182                 PANIC(program_name);
 183
 184         /*
 185          * Map enough address space to hold the program (as opposed to the
 186          * file) represented by ld.so.  The amount to be assigned is the
 187          * range between the end of the last loadable segment and the
 188          * beginning of the first PLUS the alignment of the first segment.
 189          * mmap() can assign us any page-aligned address, but the relocations
 190          * assume the alignments included in the program header.  As an
 191          * optimization, however, let's assume that mmap() will actually
 192          * give us an aligned address -- since if it does, we can save
 193          * an munmap() later on.  If it doesn't -- then go try it again.
 194          */
 195         mlen = ROUND((lph->p_vaddr + lph->p_memsz) -
 196             ALIGN(fph->p_vaddr, page_size), page_size);
 197         maddr = (caddr_t)MMAP(0, mlen, PROT_READ | PROT_EXEC,
 198             MAP_SHARED, ldfd, 0);
 199         if (maddr == (caddr_t)-1)
 200                 PANIC(program_name);
 201         faddr = (caddr_t)ROUND(maddr, fph->p_align);
 202
 203         /*
 204          * Check to see whether alignment skew was really needed.
 205          */
 206         if (faddr != maddr) {
 207                 (void) MUNMAP(maddr, mlen);
 208                 mlen = ROUND((lph->p_vaddr + lph->p_memsz) -
 209                     ALIGN(fph->p_vaddr, fph->p_align) + fph->p_align,
 210                     page_size);
 211                 maddr = (caddr_t)MMAP(0, mlen, PROT_READ | PROT_EXEC,
 212                     MAP_SHARED, ldfd, 0);
 213                 if (maddr == (caddr_t)-1)
 214                         PANIC(program_name);
 215                 faddr = (caddr_t)ROUND(maddr, fph->p_align);
 216         }
 217
 218         /*
 219          * We have the address space reserved, so map each loadable segment.
 220          */
 221         for (p = 0, pptr = phdr; p < (int)ehdr->e_phnum; p++,
 222             pptr = (Elf32_Phdr *)((caddr_t)pptr + ehdr->e_phentsize)) {
 223
 224                 /*
 225                  * Skip non-loadable segments or segments that don't occupy
 226                  * any memory.
 227                  */
 228                 if ((pptr->p_type != PT_LOAD) || (pptr->p_memsz == 0))
 229                         continue;
 230
 231                 /*
 232                  * Determine the file offset to which the mapping will
 233                  * directed (must be aligned) and how much to map (might
 234                  * be more than the file in the case of .bss.)
 235                  */
 236                 foff = ALIGN(pptr->p_offset, page_size);
 237                 flen = pptr->p_memsz + (pptr->p_offset - foff);
 238
 239                 /*
 240                  * Set address of this segment relative to our base.
 241                  */
 242                 addr = (caddr_t)ALIGN(faddr + pptr->p_vaddr, page_size);
 243
 244                 /*
 245                  * If this is the first program header, record our base
 246                  * address for later use.
 247                  */
 248                 if (pptr == phdr) {
 249                         ebp->eb_tag = EB_LDSO_BASE;
 250                         (ebp++)->eb_un.eb_ptr = (Elf32_Addr)addr;
 251                 }
 252
 253                 /*
 254                  * Unmap anything from the last mapping address to this
 255                  * one.
 256                  */
 257                 if (addr - maddr) {
 258                         (void) MUNMAP(maddr, addr - maddr);
 259                         mlen -= addr - maddr;
 260                 }
 261
 262                 /*
 263                  * Determine the mapping protection from the section
 264                  * attributes.
 265                  */
 266                 i = 0;
 267                 if (pptr->p_flags & PF_R)
 268                         i |= PROT_READ;
 269                 if (pptr->p_flags & PF_W)
 270                         i |= PROT_WRITE;
 271                 if (pptr->p_flags & PF_X)
 272                         i |= PROT_EXEC;
 273                 if ((caddr_t)MMAP((caddr_t)addr, flen, i,
 274                     MAP_FIXED | MAP_PRIVATE, ldfd, foff) == (caddr_t)-1)
 275                         PANIC(program_name);
 276
 277                 /*
 278                  * If the memory occupancy of the segment overflows the
 279                  * definition in the file, we need to "zero out" the
 280                  * end of the mapping we've established, and if necessary,
 281                  * map some more space from /dev/zero.
 282                  */
 283                 if (pptr->p_memsz > pptr->p_filesz) {
 284                         foff = (uintptr_t)faddr + pptr->p_vaddr +
 285                             pptr->p_filesz;
 286                         zaddr = (caddr_t)ROUND(foff, page_size);
 287                         for (j = 0; j < (int)(zaddr - foff); j++)
 288                                 *((char *)foff + j) = 0;
 289                         j = (faddr + pptr->p_vaddr + pptr->p_memsz) - zaddr;
 290                         if (j > 0) {
 291                                 if (dzfd == 0) {
 292                                         dzfd = OPENAT(AT_FDCWD, ZERO, O_RDWR);
 293                                         if (dzfd == -1)
 294                                                 PANIC(program_name);
 295                                 }
 296                                 if ((caddr_t)MMAP((caddr_t)zaddr, j, i,
 297                                     MAP_FIXED | MAP_PRIVATE, dzfd,
 298                                     0) == (caddr_t)-1)
 299                                         PANIC(program_name);
 300                         }
 301                 }
 302
 303                 /*
 304                  * Update the mapping claim pointer.
 305                  */
 306                 maddr = addr + ROUND(flen, page_size);
 307                 mlen -= maddr - addr;
 308         }
 309
 310         /*
 311          * Unmap any final reservation.
 312          */
 313         if (mlen != 0)
 314                 (void) MUNMAP(maddr, mlen);
 315
 316         /*
 317          * Clean up file descriptor space we've consumed.  Pass along
 318          * the /dev/zero file descriptor we got -- every cycle counts.
 319          */
 320         (void) CLOSE(ldfd);
 321         if (dzfd != 0)
 322                 ebp->eb_tag = EB_DEVZERO, (ebp++)->eb_un.eb_val = dzfd;
 323
 324         /*
 325          * The call itself.  Note that we start 1 instruction word in.
 326          * The ELF ld.so contains an "entry vector" of branch instructions,
 327          * which, for our interest are:
 328          *      +0:     ba, a   <normal startup>
 329          *      +4:     ba, a   <compatibility startup>
 330          *      +8:     ba, a   <alias startup>
 331          * By starting at the alias startup, the ELF ld.so knows
 332          * that a pointer to "eb" is available to it and further knows
 333          * how to calculate the offset to the program's arguments and
 334          * other structures.  We do the "call" by returning to our
 335          * bootstrap and then jumping to the address that we return.
 336          */
 337         ebp->eb_tag = EB_NULL, ebp->eb_un.eb_val = 0;
 338         return ((void *)(ehdr->e_entry + faddr + 8));
 339 }