loader/preloader.c

   1 /*
   2  * Preloader for ld.so
   3  *
   4  * Copyright (C) 1995,96,97,98,99,2000,2001,2002 Free Software Foundation, Inc.
   5  * Copyright (C) 2004 Mike McCormack for CodeWeavers
   6  * Copyright (C) 2004 Alexandre Julliard
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 /*
  24  * Design notes
  25  *
  26  * The goal of this program is to be a workaround for exec-shield, as used
  27  *  by the Linux kernel distributed with Fedora Core and other distros.
  28  *
  29  * To do this, we implement our own shared object loader that reserves memory
  30  * that is important to Wine, and then loads the main binary and its ELF
  31  * interpreter.
  32  *
  33  * We will try to set up the stack and memory area so that the program that
  34  * loads after us (eg. the wine binary) never knows we were here, except that
  35  * areas of memory it needs are already magically reserved.
  36  *
  37  * The following memory areas are important to Wine:
  38  *  0x00000000 - 0x00110000  the DOS area
  39  *  0x80000000 - 0x81000000  the shared heap
  40  *  ???        - ???         the PE binary load address (usually starting at 0x00400000)
  41  *
  42  * If this program is used as the shared object loader, the only difference
  43  * that the loaded programs should see is that this loader will be mapped
  44  * into memory when it starts.
  45  */
  46
  47 /*
  48  * References (things I consulted to understand how ELF loading works):
  49  *
  50  * glibc 2.3.2   elf/dl-load.c
  51  *  http://www.gnu.org/directory/glibc.html
  52  *
  53  * Linux 2.6.4   fs/binfmt_elf.c
  54  *  ftp://ftp.kernel.org/pub/linux/kernel/v2.6/linux-2.6.4.tar.bz2
  55  *
  56  * Userland exec, by <grugq@hcunix.net>
  57  *  http://cert.uni-stuttgart.de/archive/bugtraq/2004/01/msg00002.html
  58  *
  59  * The ELF specification:
  60  *  http://www.linuxbase.org/spec/booksets/LSB-Embedded/LSB-Embedded/book387.html
  61  */
  62
  63 #include "config.h"
  64 #include "wine/port.h"
  65
  66 #include <stdarg.h>
  67 #include <stdio.h>
  68 #include <stdlib.h>
  69 #include <string.h>
  70 #include <sys/types.h>
  71 #ifdef HAVE_SYS_STAT_H
  72 # include <sys/stat.h>
  73 #endif
  74 #include <fcntl.h>
  75 #ifdef HAVE_SYS_MMAN_H
  76 # include <sys/mman.h>
  77 #endif
  78 #ifdef HAVE_SYS_SYSCALL_H
  79 # include <sys/syscall.h>
  80 #endif
  81 #ifdef HAVE_UNISTD_H
  82 # include <unistd.h>
  83 #endif
  84 #ifdef HAVE_ELF_H
  85 # include <elf.h>
  86 #endif
  87 #ifdef HAVE_LINK_H
  88 # include <link.h>
  89 #endif
  90 #ifdef HAVE_SYS_LINK_H
  91 # include <sys/link.h>
  92 #endif
  93
  94 #include "main.h"
  95
  96 /* ELF definitions */
  97 #define ELF_PREFERRED_ADDRESS(loader, maplength, mapstartpref) (mapstartpref)
  98 #define ELF_FIXED_ADDRESS(loader, mapstart) ((void) 0)
  99
 100 #define MAP_BASE_ADDR(l)     0
 101
 102 #ifndef MAP_COPY
 103 #define MAP_COPY MAP_PRIVATE
 104 #endif
 105 #ifndef MAP_NORESERVE
 106 #define MAP_NORESERVE 0
 107 #endif
 108
 109 static struct wine_preload_info preload_info[] =
 110 {
 111     { (void *)0x00000000, 0x00110000 },  /* DOS area */
 112     { (void *)0x7ffe0000, 0x01020000 },  /* shared user data + shared heap */
 113     { (void *)0x00110000, 0x1fef0000 },  /* PE exe range (may be set with WINEPRELOADRESERVE), defaults to 512mb */
 114     { 0, 0 }                             /* end of list */
 115 };
 116
 117 /* debugging */
 118 #undef DUMP_SEGMENTS
 119 #undef DUMP_AUX_INFO
 120 #undef DUMP_SYMS
 121
 122 /* older systems may not define these */
 123 #ifndef PT_TLS
 124 #define PT_TLS 7
 125 #endif
 126
 127 #ifndef AT_SYSINFO
 128 #define AT_SYSINFO 32
 129 #endif
 130 #ifndef AT_SYSINFO_EHDR
 131 #define AT_SYSINFO_EHDR 33
 132 #endif
 133
 134 static unsigned int page_size, page_mask;
 135 static char *preloader_start, *preloader_end;
 136
 137 struct wld_link_map {
 138     ElfW(Addr) l_addr;
 139     ElfW(Dyn) *l_ld;
 140     ElfW(Phdr)*l_phdr;
 141     ElfW(Addr) l_entry;
 142     ElfW(Half) l_ldnum;
 143     ElfW(Half) l_phnum;
 144     ElfW(Addr) l_map_start, l_map_end;
 145     ElfW(Addr) l_interp;
 146 };
 147
 148
 149 /*
 150  * The __bb_init_func is an empty function only called when file is
 151  * compiled with gcc flags "-fprofile-arcs -ftest-coverage".  This
 152  * function is normally provided by libc's startup files, but since we
 153  * build the preloader with "-nostartfiles -nodefaultlibs", we have to
 154  * provide our own (empty) version, otherwise linker fails.
 155  */
 156 void __bb_init_func(void) { return; }
 157
 158 /* similar to the above but for -fstack-protector */
 159 void *__stack_chk_guard = 0;
 160 void __stack_chk_fail(void) { return; }
 161
 162 /*
 163  * The _start function is the entry and exit point of this program
 164  *
 165  *  It calls wld_start, passing a pointer to the args it receives
 166  *  then jumps to the address wld_start returns.
 167  */
 168 void _start();
 169 extern char _end[];
 170 __ASM_GLOBAL_FUNC(_start,
 171                   "\tmovl %esp,%eax\n"
 172                   "\tleal -136(%esp),%esp\n"  /* allocate some space for extra aux values */
 173                   "\tpushl %eax\n"            /* orig stack pointer */
 174                   "\tpushl %esp\n"            /* ptr to orig stack pointer */
 175                   "\tcall wld_start\n"
 176                   "\tpopl %ecx\n"             /* remove ptr to stack pointer */
 177                   "\tpopl %esp\n"             /* new stack pointer */
 178                   "\tpush %eax\n"             /* ELF interpreter entry point */
 179                   "\txor %eax,%eax\n"
 180                   "\txor %ecx,%ecx\n"
 181                   "\txor %edx,%edx\n"
 182                   "\tret\n")
 183
 184 /* wrappers for Linux system calls */
 185
 186 #define SYSCALL_RET(ret) (((ret) < 0 && (ret) > -4096) ? -1 : (ret))
 187
 188 static inline __attribute__((noreturn)) void wld_exit( int code )
 189 {
 190     for (;;)  /* avoid warning */
 191         __asm__ __volatile__( "pushl %%ebx; movl %1,%%ebx; int $0x80; popl %%ebx"
 192                               : : "a" (SYS_exit), "r" (code) );
 193 }
 194
 195 static inline int wld_open( const char *name, int flags )
 196 {
 197     int ret;
 198     __asm__ __volatile__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
 199                           : "=a" (ret) : "0" (SYS_open), "r" (name), "c" (flags) );
 200     return SYSCALL_RET(ret);
 201 }
 202
 203 static inline int wld_close( int fd )
 204 {
 205     int ret;
 206     __asm__ __volatile__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
 207                           : "=a" (ret) : "0" (SYS_close), "r" (fd) );
 208     return SYSCALL_RET(ret);
 209 }
 210
 211 static inline ssize_t wld_read( int fd, void *buffer, size_t len )
 212 {
 213     int ret;
 214     __asm__ __volatile__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
 215                           : "=a" (ret)
 216                           : "0" (SYS_read), "r" (fd), "c" (buffer), "d" (len)
 217                           : "memory" );
 218     return SYSCALL_RET(ret);
 219 }
 220
 221 static inline ssize_t wld_write( int fd, const void *buffer, size_t len )
 222 {
 223     int ret;
 224     __asm__ __volatile__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
 225                           : "=a" (ret) : "0" (SYS_write), "r" (fd), "c" (buffer), "d" (len) );
 226     return SYSCALL_RET(ret);
 227 }
 228
 229 static inline int wld_mprotect( const void *addr, size_t len, int prot )
 230 {
 231     int ret;
 232     __asm__ __volatile__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
 233                           : "=a" (ret) : "0" (SYS_mprotect), "r" (addr), "c" (len), "d" (prot) );
 234     return SYSCALL_RET(ret);
 235 }
 236
 237 static void *wld_mmap( void *start, size_t len, int prot, int flags, int fd, off_t offset )
 238 {
 239     int ret;
 240
 241     struct
 242     {
 243         void        *addr;
 244         unsigned int length;
 245         unsigned int prot;
 246         unsigned int flags;
 247         unsigned int fd;
 248         unsigned int offset;
 249     } args;
 250
 251     args.addr   = start;
 252     args.length = len;
 253     args.prot   = prot;
 254     args.flags  = flags;
 255     args.fd     = fd;
 256     args.offset = offset;
 257     __asm__ __volatile__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
 258                           : "=a" (ret) : "0" (SYS_mmap), "q" (&args) : "memory" );
 259     return (void *)SYSCALL_RET(ret);
 260 }
 261
 262 static inline uid_t wld_getuid(void)
 263 {
 264     uid_t ret;
 265     __asm__( "int $0x80" : "=a" (ret) : "0" (SYS_getuid) );
 266     return ret;
 267 }
 268
 269 static inline uid_t wld_geteuid(void)
 270 {
 271     uid_t ret;
 272     __asm__( "int $0x80" : "=a" (ret) : "0" (SYS_geteuid) );
 273     return ret;
 274 }
 275
 276 static inline gid_t wld_getgid(void)
 277 {
 278     gid_t ret;
 279     __asm__( "int $0x80" : "=a" (ret) : "0" (SYS_getgid) );
 280     return ret;
 281 }
 282
 283 static inline gid_t wld_getegid(void)
 284 {
 285     gid_t ret;
 286     __asm__( "int $0x80" : "=a" (ret) : "0" (SYS_getegid) );
 287     return ret;
 288 }
 289
 290
 291 /* replacement for libc functions */
 292
 293 static int wld_strcmp( const char *str1, const char *str2 )
 294 {
 295     while (*str1 && (*str1 == *str2)) { str1++; str2++; }
 296     return *str1 - *str2;
 297 }
 298
 299 static int wld_strncmp( const char *str1, const char *str2, size_t len )
 300 {
 301     if (len <= 0) return 0;
 302     while ((--len > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
 303     return *str1 - *str2;
 304 }
 305
 306 static inline void *wld_memset( void *dest, int val, size_t len )
 307 {
 308     char *dst = dest;
 309     while (len--) *dst++ = val;
 310     return dest;
 311 }
 312
 313 /*
 314  * wld_printf - just the basics
 315  *
 316  *  %x prints a hex number
 317  *  %s prints a string
 318  */
 319 static int wld_vsprintf(char *buffer, const char *fmt, va_list args )
 320 {
 321     static const char hex_chars[16] = "0123456789abcdef";
 322     const char *p = fmt;
 323     char *str = buffer;
 324
 325     while( *p )
 326     {
 327         if( *p == '%' )
 328         {
 329             p++;
 330             if( *p == 'x' )
 331             {
 332                 int i;
 333                 unsigned int x = va_arg( args, unsigned int );
 334                 for(i=7; i>=0; i--)
 335                     *str++ = hex_chars[(x>>(i*4))&0xf];
 336             }
 337             else if( *p == 's' )
 338             {
 339                 char *s = va_arg( args, char * );
 340                 while(*s)
 341                     *str++ = *s++;
 342             }
 343             else if( *p == 0 )
 344                 break;
 345             p++;
 346         }
 347         *str++ = *p++;
 348     }
 349     *str = 0;
 350     return str - buffer;
 351 }
 352
 353 static void wld_printf(const char *fmt, ... )
 354 {
 355     va_list args;
 356     char buffer[256];
 357     int len;
 358
 359     va_start( args, fmt );
 360     len = wld_vsprintf(buffer, fmt, args );
 361     va_end( args );
 362     wld_write(2, buffer, len);
 363 }
 364
 365 static __attribute__((noreturn)) void fatal_error(const char *fmt, ... )
 366 {
 367     va_list args;
 368     char buffer[256];
 369     int len;
 370
 371     va_start( args, fmt );
 372     len = wld_vsprintf(buffer, fmt, args );
 373     va_end( args );
 374     wld_write(2, buffer, len);
 375     wld_exit(1);
 376 }
 377
 378 #ifdef DUMP_AUX_INFO
 379 /*
 380  *  Dump interesting bits of the ELF auxv_t structure that is passed
 381  *   as the 4th parameter to the _start function
 382  */
 383 static void dump_auxiliary( ElfW(auxv_t) *av )
 384 {
 385 #define NAME(at) { at, #at }
 386     static const struct { int val; const char *name; } names[] =
 387     {
 388         NAME(AT_BASE),
 389         NAME(AT_CLKTCK),
 390         NAME(AT_EGID),
 391         NAME(AT_ENTRY),
 392         NAME(AT_EUID),
 393         NAME(AT_FLAGS),
 394         NAME(AT_GID),
 395         NAME(AT_HWCAP),
 396         NAME(AT_PAGESZ),
 397         NAME(AT_PHDR),
 398         NAME(AT_PHENT),
 399         NAME(AT_PHNUM),
 400         NAME(AT_PLATFORM),
 401         NAME(AT_SYSINFO),
 402         NAME(AT_SYSINFO_EHDR),
 403         NAME(AT_UID),
 404         { 0, NULL }
 405     };
 406 #undef NAME
 407
 408     int i;
 409
 410     for (  ; av->a_type != AT_NULL; av++)
 411     {
 412         for (i = 0; names[i].name; i++) if (names[i].val == av->a_type) break;
 413         if (names[i].name) wld_printf("%s = %x\n", names[i].name, av->a_un.a_val);
 414         else wld_printf( "%x = %x\n", av->a_type, av->a_un.a_val );
 415     }
 416 }
 417 #endif
 418
 419 /*
 420  * set_auxiliary_values
 421  *
 422  * Set the new auxiliary values
 423  */
 424 static void set_auxiliary_values( ElfW(auxv_t) *av, const ElfW(auxv_t) *new_av,
 425                                   const ElfW(auxv_t) *delete_av, void **stack )
 426 {
 427     int i, j, av_count = 0, new_count = 0, delete_count = 0;
 428     char *src, *dst;
 429
 430     /* count how many aux values we have already */
 431     while (av[av_count].a_type != AT_NULL) av_count++;
 432
 433     /* delete unwanted values */
 434     for (j = 0; delete_av[j].a_type != AT_NULL; j++)
 435     {
 436         for (i = 0; i < av_count; i++) if (av[i].a_type == delete_av[j].a_type)
 437         {
 438             av[i].a_type = av[av_count-1].a_type;
 439             av[i].a_un.a_val = av[av_count-1].a_un.a_val;
 440             av[--av_count].a_type = AT_NULL;
 441             delete_count++;
 442             break;
 443         }
 444     }
 445
 446     /* count how many values we have in new_av that aren't in av */
 447     for (j = 0; new_av[j].a_type != AT_NULL; j++)
 448     {
 449         for (i = 0; i < av_count; i++) if (av[i].a_type == new_av[j].a_type) break;
 450         if (i == av_count) new_count++;
 451     }
 452
 453     src = (char *)*stack;
 454     dst = src - (new_count - delete_count) * sizeof(*av);
 455     if (new_count > delete_count)   /* need to make room for the extra values */
 456     {
 457         int len = (char *)(av + av_count + 1) - src;
 458         for (i = 0; i < len; i++) dst[i] = src[i];
 459     }
 460     else if (new_count < delete_count)  /* get rid of unused values */
 461     {
 462         int len = (char *)(av + av_count + 1) - dst;
 463         for (i = len - 1; i >= 0; i--) dst[i] = src[i];
 464     }
 465     *stack = dst;
 466     av -= (new_count - delete_count);
 467
 468     /* now set the values */
 469     for (j = 0; new_av[j].a_type != AT_NULL; j++)
 470     {
 471         for (i = 0; i < av_count; i++) if (av[i].a_type == new_av[j].a_type) break;
 472         if (i < av_count) av[i].a_un.a_val = new_av[j].a_un.a_val;
 473         else
 474         {
 475             av[av_count].a_type     = new_av[j].a_type;
 476             av[av_count].a_un.a_val = new_av[j].a_un.a_val;
 477             av_count++;
 478         }
 479     }
 480
 481 #ifdef DUMP_AUX_INFO
 482     wld_printf("New auxiliary info:\n");
 483     dump_auxiliary( av );
 484 #endif
 485 }
 486
 487 /*
 488  * get_auxiliary
 489  *
 490  * Get a field of the auxiliary structure
 491  */
 492 static int get_auxiliary( ElfW(auxv_t) *av, int type, int def_val )
 493 {
 494   for ( ; av->a_type != AT_NULL; av++)
 495       if( av->a_type == type ) return av->a_un.a_val;
 496   return def_val;
 497 }
 498
 499 /*
 500  * map_so_lib
 501  *
 502  * modelled after _dl_map_object_from_fd() from glibc-2.3.1/elf/dl-load.c
 503  *
 504  * This function maps the segments from an ELF object, and optionally
 505  *  stores information about the mapping into the auxv_t structure.
 506  */
 507 static void map_so_lib( const char *name, struct wld_link_map *l)
 508 {
 509     int fd;
 510     unsigned char buf[0x800];
 511     ElfW(Ehdr) *header = (ElfW(Ehdr)*)buf;
 512     ElfW(Phdr) *phdr, *ph;
 513     /* Scan the program header table, collecting its load commands.  */
 514     struct loadcmd
 515       {
 516         ElfW(Addr) mapstart, mapend, dataend, allocend;
 517         off_t mapoff;
 518         int prot;
 519       } loadcmds[16], *c;
 520     size_t nloadcmds = 0, maplength;
 521
 522     fd = wld_open( name, O_RDONLY );
 523     if (fd == -1) fatal_error("%s: could not open\n", name );
 524
 525     if (wld_read( fd, buf, sizeof(buf) ) != sizeof(buf))
 526         fatal_error("%s: failed to read ELF header\n", name);
 527
 528     phdr = (void*) (((unsigned char*)buf) + header->e_phoff);
 529
 530     if( ( header->e_ident[0] != 0x7f ) ||
 531         ( header->e_ident[1] != 'E' ) ||
 532         ( header->e_ident[2] != 'L' ) ||
 533         ( header->e_ident[3] != 'F' ) )
 534         fatal_error( "%s: not an ELF binary... don't know how to load it\n", name );
 535
 536     if( header->e_machine != EM_386 )
 537         fatal_error("%s: not an i386 ELF binary... don't know how to load it\n", name );
 538
 539     if (header->e_phnum > sizeof(loadcmds)/sizeof(loadcmds[0]))
 540         fatal_error( "%s: oops... not enough space for load commands\n", name );
 541
 542     maplength = header->e_phnum * sizeof (ElfW(Phdr));
 543     if (header->e_phoff + maplength > sizeof(buf))
 544         fatal_error( "%s: oops... not enough space for ELF headers\n", name );
 545
 546     l->l_ld = 0;
 547     l->l_addr = 0;
 548     l->l_phdr = 0;
 549     l->l_phnum = header->e_phnum;
 550     l->l_entry = header->e_entry;
 551     l->l_interp = 0;
 552
 553     for (ph = phdr; ph < &phdr[l->l_phnum]; ++ph)
 554     {
 555
 556 #ifdef DUMP_SEGMENTS
 557       wld_printf( "ph = %x\n", ph );
 558       wld_printf( " p_type   = %x\n", ph->p_type );
 559       wld_printf( " p_flags  = %x\n", ph->p_flags );
 560       wld_printf( " p_offset = %x\n", ph->p_offset );
 561       wld_printf( " p_vaddr  = %x\n", ph->p_vaddr );
 562       wld_printf( " p_paddr  = %x\n", ph->p_paddr );
 563       wld_printf( " p_filesz = %x\n", ph->p_filesz );
 564       wld_printf( " p_memsz  = %x\n", ph->p_memsz );
 565       wld_printf( " p_align  = %x\n", ph->p_align );
 566 #endif
 567
 568       switch (ph->p_type)
 569         {
 570           /* These entries tell us where to find things once the file's
 571              segments are mapped in.  We record the addresses it says
 572              verbatim, and later correct for the run-time load address.  */
 573         case PT_DYNAMIC:
 574           l->l_ld = (void *) ph->p_vaddr;
 575           l->l_ldnum = ph->p_memsz / sizeof (Elf32_Dyn);
 576           break;
 577
 578         case PT_PHDR:
 579           l->l_phdr = (void *) ph->p_vaddr;
 580           break;
 581
 582         case PT_LOAD:
 583           {
 584             if ((ph->p_align & page_mask) != 0)
 585               fatal_error( "%s: ELF load command alignment not page-aligned\n", name );
 586
 587             if (((ph->p_vaddr - ph->p_offset) & (ph->p_align - 1)) != 0)
 588               fatal_error( "%s: ELF load command address/offset not properly aligned\n", name );
 589
 590             c = &loadcmds[nloadcmds++];
 591             c->mapstart = ph->p_vaddr & ~(ph->p_align - 1);
 592             c->mapend = ((ph->p_vaddr + ph->p_filesz + page_mask) & ~page_mask);
 593             c->dataend = ph->p_vaddr + ph->p_filesz;
 594             c->allocend = ph->p_vaddr + ph->p_memsz;
 595             c->mapoff = ph->p_offset & ~(ph->p_align - 1);
 596
 597             c->prot = 0;
 598             if (ph->p_flags & PF_R)
 599               c->prot |= PROT_READ;
 600             if (ph->p_flags & PF_W)
 601               c->prot |= PROT_WRITE;
 602             if (ph->p_flags & PF_X)
 603               c->prot |= PROT_EXEC;
 604           }
 605           break;
 606
 607         case PT_INTERP:
 608           l->l_interp = ph->p_vaddr;
 609           break;
 610
 611         case PT_TLS:
 612           /*
 613            * We don't need to set anything up because we're
 614            * emulating the kernel, not ld-linux.so.2
 615            * The ELF loader will set up the TLS data itself.
 616            */
 617         case PT_SHLIB:
 618         case PT_NOTE:
 619         default:
 620           break;
 621         }
 622     }
 623
 624     /* Now process the load commands and map segments into memory.  */
 625     c = loadcmds;
 626
 627     /* Length of the sections to be loaded.  */
 628     maplength = loadcmds[nloadcmds - 1].allocend - c->mapstart;
 629
 630     if( header->e_type == ET_DYN )
 631     {
 632         ElfW(Addr) mappref;
 633         mappref = (ELF_PREFERRED_ADDRESS (loader, maplength, c->mapstart)
 634                    - MAP_BASE_ADDR (l));
 635
 636         /* Remember which part of the address space this object uses.  */
 637         l->l_map_start = (ElfW(Addr)) wld_mmap ((void *) mappref, maplength,
 638                                               c->prot, MAP_COPY | MAP_FILE,
 639                                               fd, c->mapoff);
 640         /* wld_printf("set  : offset = %x\n", c->mapoff); */
 641         /* wld_printf("l->l_map_start = %x\n", l->l_map_start); */
 642
 643         l->l_map_end = l->l_map_start + maplength;
 644         l->l_addr = l->l_map_start - c->mapstart;
 645
 646         wld_mprotect ((caddr_t) (l->l_addr + c->mapend),
 647                     loadcmds[nloadcmds - 1].allocend - c->mapend,
 648                     PROT_NONE);
 649         goto postmap;
 650     }
 651     else
 652     {
 653         /* sanity check */
 654         if ((char *)c->mapstart + maplength > preloader_start &&
 655             (char *)c->mapstart <= preloader_end)
 656             fatal_error( "%s: binary overlaps preloader (%x-%x)\n",
 657                          name, c->mapstart, (char *)c->mapstart + maplength );
 658
 659         ELF_FIXED_ADDRESS (loader, c->mapstart);
 660     }
 661
 662     /* Remember which part of the address space this object uses.  */
 663     l->l_map_start = c->mapstart + l->l_addr;
 664     l->l_map_end = l->l_map_start + maplength;
 665
 666     while (c < &loadcmds[nloadcmds])
 667       {
 668         if (c->mapend > c->mapstart)
 669             /* Map the segment contents from the file.  */
 670             wld_mmap ((void *) (l->l_addr + c->mapstart),
 671                         c->mapend - c->mapstart, c->prot,
 672                         MAP_FIXED | MAP_COPY | MAP_FILE, fd, c->mapoff);
 673
 674       postmap:
 675         if (l->l_phdr == 0
 676             && (ElfW(Off)) c->mapoff <= header->e_phoff
 677             && ((size_t) (c->mapend - c->mapstart + c->mapoff)
 678                 >= header->e_phoff + header->e_phnum * sizeof (ElfW(Phdr))))
 679           /* Found the program header in this segment.  */
 680           l->l_phdr = (void *)(unsigned int) (c->mapstart + header->e_phoff - c->mapoff);
 681
 682         if (c->allocend > c->dataend)
 683           {
 684             /* Extra zero pages should appear at the end of this segment,
 685                after the data mapped from the file.   */
 686             ElfW(Addr) zero, zeroend, zeropage;
 687
 688             zero = l->l_addr + c->dataend;
 689             zeroend = l->l_addr + c->allocend;
 690             zeropage = (zero + page_mask) & ~page_mask;
 691
 692             /*
 693              * This is different from the dl-load load...
 694              *  ld-linux.so.2 relies on the whole page being zero'ed
 695              */
 696             zeroend = (zeroend + page_mask) & ~page_mask;
 697
 698             if (zeroend < zeropage)
 699             {
 700               /* All the extra data is in the last page of the segment.
 701                  We can just zero it.  */
 702               zeropage = zeroend;
 703             }
 704
 705             if (zeropage > zero)
 706               {
 707                 /* Zero the final part of the last page of the segment.  */
 708                 if ((c->prot & PROT_WRITE) == 0)
 709                   {
 710                     /* Dag nab it.  */
 711                     wld_mprotect ((caddr_t) (zero & ~page_mask), page_size, c->prot|PROT_WRITE);
 712                   }
 713                 wld_memset ((void *) zero, '\0', zeropage - zero);
 714                 if ((c->prot & PROT_WRITE) == 0)
 715                   wld_mprotect ((caddr_t) (zero & ~page_mask), page_size, c->prot);
 716               }
 717
 718             if (zeroend > zeropage)
 719               {
 720                 /* Map the remaining zero pages in from the zero fill FD.  */
 721                 caddr_t mapat;
 722                 mapat = wld_mmap ((caddr_t) zeropage, zeroend - zeropage,
 723                                 c->prot, MAP_ANON|MAP_PRIVATE|MAP_FIXED,
 724                                 -1, 0);
 725               }
 726           }
 727
 728         ++c;
 729       }
 730
 731     if (l->l_phdr == NULL) fatal_error("no program header\n");
 732
 733     l->l_phdr = (void *)((ElfW(Addr))l->l_phdr + l->l_addr);
 734     l->l_entry += l->l_addr;
 735
 736     wld_close( fd );
 737 }
 738
 739
 740 /*
 741  * Find a symbol in the symbol table of the executable loaded
 742  */
 743 static void *find_symbol( const ElfW(Phdr) *phdr, int num, const char *var )
 744 {
 745     const ElfW(Dyn) *dyn = NULL;
 746     const ElfW(Phdr) *ph;
 747     const ElfW(Sym) *symtab = NULL;
 748     const char *strings = NULL;
 749     uint32_t i, symtabend = 0;
 750
 751     /* check the values */
 752 #ifdef DUMP_SYMS
 753     wld_printf("%x %x\n", phdr, num );
 754 #endif
 755     if( ( phdr == NULL ) || ( num == 0 ) )
 756     {
 757         wld_printf("could not find PT_DYNAMIC header entry\n");
 758         return NULL;
 759     }
 760
 761     /* parse the (already loaded) ELF executable's header */
 762     for (ph = phdr; ph < &phdr[num]; ++ph)
 763     {
 764         if( PT_DYNAMIC == ph->p_type )
 765         {
 766             dyn = (void *) ph->p_vaddr;
 767             num = ph->p_memsz / sizeof (Elf32_Dyn);
 768             break;
 769         }
 770     }
 771     if( !dyn ) return NULL;
 772
 773     while( dyn->d_tag )
 774     {
 775         if( dyn->d_tag == DT_STRTAB )
 776             strings = (const char*) dyn->d_un.d_ptr;
 777         if( dyn->d_tag == DT_SYMTAB )
 778             symtab = (const ElfW(Sym) *)dyn->d_un.d_ptr;
 779         if( dyn->d_tag == DT_HASH )
 780             symtabend = *((const uint32_t *)dyn->d_un.d_ptr + 1);
 781 #ifdef DUMP_SYMS
 782         wld_printf("%x %x\n", dyn->d_tag, dyn->d_un.d_ptr );
 783 #endif
 784         dyn++;
 785     }
 786
 787     if( (!symtab) || (!strings) ) return NULL;
 788
 789     for (i = 0; i < symtabend; i++)
 790     {
 791         if( ( ELF32_ST_BIND(symtab[i].st_info) == STT_OBJECT ) &&
 792             ( 0 == wld_strcmp( strings+symtab[i].st_name, var ) ) )
 793         {
 794 #ifdef DUMP_SYMS
 795             wld_printf("Found %s -> %x\n", strings+symtab[i].st_name, symtab[i].st_value );
 796 #endif
 797             return (void*)symtab[i].st_value;
 798         }
 799     }
 800     return NULL;
 801 }
 802
 803 /*
 804  *  preload_reserve
 805  *
 806  * Reserve a range specified in string format
 807  */
 808 static void preload_reserve( const char *str )
 809 {
 810     const char *p;
 811     unsigned long result = 0;
 812     void *start = NULL, *end = NULL;
 813     int first = 1;
 814
 815     for (p = str; *p; p++)
 816     {
 817         if (*p >= '0' && *p <= '9') result = result * 16 + *p - '0';
 818         else if (*p >= 'a' && *p <= 'f') result = result * 16 + *p - 'a' + 10;
 819         else if (*p >= 'A' && *p <= 'F') result = result * 16 + *p - 'A' + 10;
 820         else if (*p == '-')
 821         {
 822             if (!first) goto error;
 823             start = (void *)(result & ~page_mask);
 824             result = 0;
 825             first = 0;
 826         }
 827         else goto error;
 828     }
 829     if (!first) end = (void *)((result + page_mask) & ~page_mask);
 830     else if (result) goto error;  /* single value '0' is allowed */
 831
 832     /* sanity checks */
 833     if (end <= start) start = end = NULL;
 834     else if ((char *)end > preloader_start &&
 835              (char *)start <= preloader_end)
 836     {
 837         wld_printf( "WINEPRELOADRESERVE range %x-%x overlaps preloader %x-%x\n",
 838                      start, end, preloader_start, preloader_end );
 839         start = end = NULL;
 840     }
 841
 842     /* entry 2 is for the PE exe */
 843     preload_info[2].addr = start;
 844     preload_info[2].size = (char *)end - (char *)start;
 845     return;
 846
 847 error:
 848     fatal_error( "invalid WINEPRELOADRESERVE value '%s'\n", str );
 849 }
 850
 851 /*
 852  *  is_in_preload_range
 853  *
 854  * Check if address of the given aux value is in one of the reserved ranges
 855  */
 856 static int is_in_preload_range( const ElfW(auxv_t) *av, int type )
 857 {
 858     int i;
 859
 860     while (av->a_type != type && av->a_type != AT_NULL) av++;
 861
 862     if (av->a_type == type)
 863     {
 864         for (i = 0; preload_info[i].size; i++)
 865         {
 866             if ((char *)av->a_un.a_val >= (char *)preload_info[i].addr &&
 867                 (char *)av->a_un.a_val < (char *)preload_info[i].addr + preload_info[i].size)
 868                 return 1;
 869         }
 870     }
 871     return 0;
 872 }
 873
 874 /*
 875  *  wld_start
 876  *
 877  *  Repeat the actions the kernel would do when loading a dynamically linked .so
 878  *  Load the binary and then its ELF interpreter.
 879  *  Note, we assume that the binary is a dynamically linked ELF shared object.
 880  */
 881 void* wld_start( void **stack )
 882 {
 883     int i, *pargc;
 884     char **argv, **p;
 885     char *interp, *reserve = NULL;
 886     ElfW(auxv_t) new_av[12], delete_av[3], *av;
 887     struct wld_link_map main_binary_map, ld_so_map;
 888     struct wine_preload_info **wine_main_preload_info;
 889
 890     pargc = *stack;
 891     argv = (char **)pargc + 1;
 892     if (*pargc < 2) fatal_error( "Usage: %s wine_binary [args]\n", argv[0] );
 893
 894     /* skip over the parameters */
 895     p = argv + *pargc + 1;
 896
 897     /* skip over the environment */
 898     while (*p)
 899     {
 900         static const char res[] = "WINEPRELOADRESERVE=";
 901         if (!wld_strncmp( *p, res, sizeof(res)-1 )) reserve = *p + sizeof(res) - 1;
 902         p++;
 903     }
 904
 905     av = (ElfW(auxv_t)*) (p+1);
 906     page_size = get_auxiliary( av, AT_PAGESZ, 4096 );
 907     page_mask = page_size - 1;
 908
 909     preloader_start = (char *)_start - ((unsigned int)_start & page_mask);
 910     preloader_end = (char *)((unsigned int)(_end + page_mask) & ~page_mask);
 911
 912 #ifdef DUMP_AUX_INFO
 913     wld_printf( "stack = %x\n", *stack );
 914     for( i = 0; i < *pargc; i++ ) wld_printf("argv[%x] = %s\n", i, argv[i]);
 915     dump_auxiliary( av );
 916 #endif
 917
 918     /* reserve memory that Wine needs */
 919     if (reserve) preload_reserve( reserve );
 920     for (i = 0; preload_info[i].size; i++)
 921         wld_mmap( preload_info[i].addr, preload_info[i].size,
 922                   PROT_NONE, MAP_FIXED | MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, -1, 0 );
 923
 924     /* load the main binary */
 925     map_so_lib( argv[1], &main_binary_map );
 926
 927     /* load the ELF interpreter */
 928     interp = (char *)main_binary_map.l_addr + main_binary_map.l_interp;
 929     map_so_lib( interp, &ld_so_map );
 930
 931     /* store pointer to the preload info into the appropriate main binary variable */
 932     wine_main_preload_info = find_symbol( main_binary_map.l_phdr, main_binary_map.l_phnum,
 933                                           "wine_main_preload_info" );
 934     if (wine_main_preload_info) *wine_main_preload_info = preload_info;
 935     else wld_printf( "wine_main_preload_info not found\n" );
 936
 937 #define SET_NEW_AV(n,type,val) new_av[n].a_type = (type); new_av[n].a_un.a_val = (val);
 938     SET_NEW_AV( 0, AT_PHDR, (unsigned long)main_binary_map.l_phdr );
 939     SET_NEW_AV( 1, AT_PHENT, sizeof(ElfW(Phdr)) );
 940     SET_NEW_AV( 2, AT_PHNUM, main_binary_map.l_phnum );
 941     SET_NEW_AV( 3, AT_PAGESZ, page_size );
 942     SET_NEW_AV( 4, AT_BASE, ld_so_map.l_addr );
 943     SET_NEW_AV( 5, AT_FLAGS, get_auxiliary( av, AT_FLAGS, 0 ) );
 944     SET_NEW_AV( 6, AT_ENTRY, main_binary_map.l_entry );
 945     SET_NEW_AV( 7, AT_UID, get_auxiliary( av, AT_UID, wld_getuid() ) );
 946     SET_NEW_AV( 8, AT_EUID, get_auxiliary( av, AT_EUID, wld_geteuid() ) );
 947     SET_NEW_AV( 9, AT_GID, get_auxiliary( av, AT_GID, wld_getgid() ) );
 948     SET_NEW_AV(10, AT_EGID, get_auxiliary( av, AT_EGID, wld_getegid() ) );
 949     SET_NEW_AV(11, AT_NULL, 0 );
 950 #undef SET_NEW_AV
 951
 952     i = 0;
 953     /* delete sysinfo values if addresses conflict */
 954     if (is_in_preload_range( av, AT_SYSINFO )) delete_av[i++].a_type = AT_SYSINFO;
 955     if (is_in_preload_range( av, AT_SYSINFO_EHDR )) delete_av[i++].a_type = AT_SYSINFO_EHDR;
 956     delete_av[i].a_type = AT_NULL;
 957
 958     /* get rid of first argument */
 959     pargc[1] = pargc[0] - 1;
 960     *stack = pargc + 1;
 961
 962     set_auxiliary_values( av, new_av, delete_av, stack );
 963
 964 #ifdef DUMP_AUX_INFO
 965     wld_printf("new stack = %x\n", *stack);
 966     wld_printf("jumping to %x\n", ld_so_map.l_entry);
 967 #endif
 968
 969     return (void *)ld_so_map.l_entry;
 970 }