preloader.c 39.6 KB
Newer Older
1 2 3 4
/*
 * Preloader for ld.so
 *
 * Copyright (C) 1995,96,97,98,99,2000,2001,2002 Free Software Foundation, Inc.
5
 * Copyright (C) 2004 Mike McCormack for CodeWeavers
6 7 8 9 10 11 12 13 14 15 16 17 18 19
 * Copyright (C) 2004 Alexandre Julliard
 *
 * This 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.
 *
 * This 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 this library; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
 */

/*
 * Design notes
 *
 * The goal of this program is to be a workaround for exec-shield, as used
 *  by the Linux kernel distributed with Fedora Core and other distros.
 *
 * To do this, we implement our own shared object loader that reserves memory
 * that is important to Wine, and then loads the main binary and its ELF
 * interpreter.
 *
 * We will try to set up the stack and memory area so that the program that
 * loads after us (eg. the wine binary) never knows we were here, except that
 * areas of memory it needs are already magically reserved.
 *
 * The following memory areas are important to Wine:
 *  0x00000000 - 0x00110000  the DOS area
 *  0x80000000 - 0x81000000  the shared heap
 *  ???        - ???         the PE binary load address (usually starting at 0x00400000)
 *
 * If this program is used as the shared object loader, the only difference
 * that the loaded programs should see is that this loader will be mapped
 * into memory when it starts.
 */

/*
 * References (things I consulted to understand how ELF loading works):
 *
 * glibc 2.3.2   elf/dl-load.c
 *  http://www.gnu.org/directory/glibc.html
 *
 * Linux 2.6.4   fs/binfmt_elf.c
 *  ftp://ftp.kernel.org/pub/linux/kernel/v2.6/linux-2.6.4.tar.bz2
 *
 * Userland exec, by <grugq@hcunix.net>
 *  http://cert.uni-stuttgart.de/archive/bugtraq/2004/01/msg00002.html
 *
 * The ELF specification:
 *  http://www.linuxbase.org/spec/booksets/LSB-Embedded/LSB-Embedded/book387.html
 */

#include "config.h"
#include "wine/port.h"

#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
71 72 73
#ifdef HAVE_SYS_STAT_H
# include <sys/stat.h>
#endif
74 75 76 77
#include <fcntl.h>
#ifdef HAVE_SYS_MMAN_H
# include <sys/mman.h>
#endif
78 79 80
#ifdef HAVE_SYS_SYSCALL_H
# include <sys/syscall.h>
#endif
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef HAVE_ELF_H
# include <elf.h>
#endif
#ifdef HAVE_LINK_H
# include <link.h>
#endif
#ifdef HAVE_SYS_LINK_H
# include <sys/link.h>
#endif

#include "main.h"

/* ELF definitions */
#define ELF_PREFERRED_ADDRESS(loader, maplength, mapstartpref) (mapstartpref)
#define ELF_FIXED_ADDRESS(loader, mapstart) ((void) 0)

#define MAP_BASE_ADDR(l)     0

#ifndef MAP_COPY
#define MAP_COPY MAP_PRIVATE
#endif
#ifndef MAP_NORESERVE
#define MAP_NORESERVE 0
#endif

static struct wine_preload_info preload_info[] =
{
111
#ifdef __i386__
112 113
    { (void *)0x00000000, 0x00010000 },  /* low 64k */
    { (void *)0x00010000, 0x00100000 },  /* DOS area */
114
    { (void *)0x00110000, 0x67ef0000 },  /* low memory area */
115
    { (void *)0x7f000000, 0x03000000 },  /* top-down allocations + shared heap + virtual heap */
116 117 118 119 120 121
#else
    { (void *)0x000000010000, 0x00100000 },  /* DOS area */
    { (void *)0x000000110000, 0x67ef0000 },  /* low memory area */
    { (void *)0x00007ff00000, 0x000f0000 },  /* shared user data */
    { (void *)0x7ffffe000000, 0x01ff0000 },  /* top-down allocations + virtual heap */
#endif
122
    { 0, 0 },                            /* PE exe range set with WINEPRELOADRESERVE */
123 124 125 126 127 128 129 130 131 132 133 134 135
    { 0, 0 }                             /* end of list */
};

/* debugging */
#undef DUMP_SEGMENTS
#undef DUMP_AUX_INFO
#undef DUMP_SYMS

/* older systems may not define these */
#ifndef PT_TLS
#define PT_TLS 7
#endif

136 137 138 139 140 141 142
#ifndef AT_SYSINFO
#define AT_SYSINFO 32
#endif
#ifndef AT_SYSINFO_EHDR
#define AT_SYSINFO_EHDR 33
#endif

143 144 145 146
#ifndef DT_GNU_HASH
#define DT_GNU_HASH 0x6ffffef5
#endif

147
static size_t page_size, page_mask;
148
static char *preloader_start, *preloader_end;
149 150 151 152

struct wld_link_map {
    ElfW(Addr) l_addr;
    ElfW(Dyn) *l_ld;
153
    ElfW(Phdr)*l_phdr;
154 155 156 157 158 159 160
    ElfW(Addr) l_entry;
    ElfW(Half) l_ldnum;
    ElfW(Half) l_phnum;
    ElfW(Addr) l_map_start, l_map_end;
    ElfW(Addr) l_interp;
};

161 162 163 164 165 166 167 168
struct wld_auxv
{
    ElfW(Addr) a_type;
    union
    {
        ElfW(Addr) a_val;
    } a_un;
};
169

170 171 172 173 174 175 176
/*
 * The __bb_init_func is an empty function only called when file is
 * compiled with gcc flags "-fprofile-arcs -ftest-coverage".  This
 * function is normally provided by libc's startup files, but since we
 * build the preloader with "-nostartfiles -nodefaultlibs", we have to
 * provide our own (empty) version, otherwise linker fails.
 */
177
void __bb_init_func(void) { return; }
178

179 180
/* similar to the above but for -fstack-protector */
void *__stack_chk_guard = 0;
181
void __stack_chk_fail_local(void) { return; }
182
void __stack_chk_fail(void) { return; }
183

184 185
#ifdef __i386__

186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
/* data for setting up the glibc-style thread-local storage in %gs */

static int thread_data[256];

struct
{
    /* this is the kernel modify_ldt struct */
    unsigned int  entry_number;
    unsigned long base_addr;
    unsigned int  limit;
    unsigned int  seg_32bit : 1;
    unsigned int  contents : 2;
    unsigned int  read_exec_only : 1;
    unsigned int  limit_in_pages : 1;
    unsigned int  seg_not_present : 1;
201
    unsigned int  usable : 1;
202 203 204 205
    unsigned int  garbage : 25;
} thread_ldt = { -1, (unsigned long)thread_data, 0xfffff, 1, 0, 0, 1, 0, 1, 0 };


206 207 208 209
/*
 * The _start function is the entry and exit point of this program
 *
 *  It calls wld_start, passing a pointer to the args it receives
210
 *  then jumps to the address wld_start returns.
211
 */
212
void _start(void);
213 214
extern char _end[];
__ASM_GLOBAL_FUNC(_start,
215 216 217 218 219 220 221 222 223 224 225
                  "\tmovl $243,%eax\n"        /* SYS_set_thread_area */
                  "\tmovl $thread_ldt,%ebx\n"
                  "\tint $0x80\n"             /* allocate gs segment */
                  "\torl %eax,%eax\n"
                  "\tjl 1f\n"
                  "\tmovl thread_ldt,%eax\n"  /* thread_ldt.entry_number */
                  "\tshl $3,%eax\n"
                  "\torl $3,%eax\n"
                  "\tmov %ax,%gs\n"
                  "\tmov %ax,%fs\n"           /* set %fs too so libwine can retrieve it later on */
                  "1:\tmovl %esp,%eax\n"
226
                  "\tleal -136(%esp),%esp\n"  /* allocate some space for extra aux values */
227 228
                  "\tpushl %eax\n"            /* orig stack pointer */
                  "\tpushl %esp\n"            /* ptr to orig stack pointer */
229
                  "\tcall wld_start\n"
230 231 232
                  "\tpopl %ecx\n"             /* remove ptr to stack pointer */
                  "\tpopl %esp\n"             /* new stack pointer */
                  "\tpush %eax\n"             /* ELF interpreter entry point */
233 234 235
                  "\txor %eax,%eax\n"
                  "\txor %ecx,%ecx\n"
                  "\txor %edx,%edx\n"
236
                  "\tmov %ax,%gs\n"           /* clear %gs again */
237 238
                  "\tret\n")

239 240 241 242 243 244 245
/* wrappers for Linux system calls */

#define SYSCALL_RET(ret) (((ret) < 0 && (ret) > -4096) ? -1 : (ret))

static inline __attribute__((noreturn)) void wld_exit( int code )
{
    for (;;)  /* avoid warning */
246
        __asm__ __volatile__( "pushl %%ebx; movl %1,%%ebx; int $0x80; popl %%ebx"
247
                              : : "a" (1 /* SYS_exit */), "r" (code) );
248 249 250 251 252
}

static inline int wld_open( const char *name, int flags )
{
    int ret;
253
    __asm__ __volatile__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
254
                          : "=a" (ret) : "0" (5 /* SYS_open */), "r" (name), "c" (flags) );
255 256 257 258 259 260
    return SYSCALL_RET(ret);
}

static inline int wld_close( int fd )
{
    int ret;
261
    __asm__ __volatile__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
262
                          : "=a" (ret) : "0" (6 /* SYS_close */), "r" (fd) );
263 264 265 266 267 268
    return SYSCALL_RET(ret);
}

static inline ssize_t wld_read( int fd, void *buffer, size_t len )
{
    int ret;
269 270
    __asm__ __volatile__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
                          : "=a" (ret)
271
                          : "0" (3 /* SYS_read */), "r" (fd), "c" (buffer), "d" (len)
272 273 274 275 276 277 278
                          : "memory" );
    return SYSCALL_RET(ret);
}

static inline ssize_t wld_write( int fd, const void *buffer, size_t len )
{
    int ret;
279
    __asm__ __volatile__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
280
                          : "=a" (ret) : "0" (4 /* SYS_write */), "r" (fd), "c" (buffer), "d" (len) );
281 282 283 284 285 286
    return SYSCALL_RET(ret);
}

static inline int wld_mprotect( const void *addr, size_t len, int prot )
{
    int ret;
287
    __asm__ __volatile__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
288
                          : "=a" (ret) : "0" (125 /* SYS_mprotect */), "r" (addr), "c" (len), "d" (prot) );
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
    return SYSCALL_RET(ret);
}

static void *wld_mmap( void *start, size_t len, int prot, int flags, int fd, off_t offset )
{
    int ret;

    struct
    {
        void        *addr;
        unsigned int length;
        unsigned int prot;
        unsigned int flags;
        unsigned int fd;
        unsigned int offset;
    } args;

    args.addr   = start;
    args.length = len;
    args.prot   = prot;
    args.flags  = flags;
    args.fd     = fd;
    args.offset = offset;
312
    __asm__ __volatile__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
313
                          : "=a" (ret) : "0" (90 /* SYS_mmap */), "q" (&args) : "memory" );
314 315 316 317 318 319
    return (void *)SYSCALL_RET(ret);
}

static inline uid_t wld_getuid(void)
{
    uid_t ret;
320
    __asm__( "int $0x80" : "=a" (ret) : "0" (24 /* SYS_getuid */) );
321 322 323 324 325 326
    return ret;
}

static inline uid_t wld_geteuid(void)
{
    uid_t ret;
327
    __asm__( "int $0x80" : "=a" (ret) : "0" (49 /* SYS_geteuid */) );
328 329 330 331 332 333
    return ret;
}

static inline gid_t wld_getgid(void)
{
    gid_t ret;
334
    __asm__( "int $0x80" : "=a" (ret) : "0" (47 /* SYS_getgid */) );
335 336 337 338 339 340
    return ret;
}

static inline gid_t wld_getegid(void)
{
    gid_t ret;
341
    __asm__( "int $0x80" : "=a" (ret) : "0" (50 /* SYS_getegid */) );
342 343 344
    return ret;
}

345
static inline int wld_prctl( int code, long arg )
346 347 348
{
    int ret;
    __asm__ __volatile__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
349
                          : "=a" (ret) : "0" (172 /* SYS_prctl */), "r" (code), "c" (arg) );
350 351 352
    return SYSCALL_RET(ret);
}

353 354
#elif defined(__x86_64__)

355 356
void *thread_data[256];

357 358 359 360 361 362 363 364 365 366 367
/*
 * The _start function is the entry and exit point of this program
 *
 *  It calls wld_start, passing a pointer to the args it receives
 *  then jumps to the address wld_start returns.
 */
void _start(void);
extern char _end[];
__ASM_GLOBAL_FUNC(_start,
                  "movq %rsp,%rax\n\t"
                  "leaq -144(%rsp),%rsp\n\t" /* allocate some space for extra aux values */
368 369 370 371 372
                  "movq %rax,(%rsp)\n\t"     /* orig stack pointer */
                  "movq $thread_data,%rsi\n\t"
                  "movq $0x1002,%rdi\n\t"    /* ARCH_SET_FS */
                  "movq $158,%rax\n\t"       /* SYS_arch_prctl */
                  "syscall\n\t"
373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
                  "movq %rsp,%rdi\n\t"       /* ptr to orig stack pointer */
                  "call wld_start\n\t"
                  "movq (%rsp),%rsp\n\t"     /* new stack pointer */
                  "pushq %rax\n\t"           /* ELF interpreter entry point */
                  "xorq %rax,%rax\n\t"
                  "xorq %rcx,%rcx\n\t"
                  "xorq %rdx,%rdx\n\t"
                  "xorq %rsi,%rsi\n\t"
                  "xorq %rdi,%rdi\n\t"
                  "xorq %r8,%r8\n\t"
                  "xorq %r9,%r9\n\t"
                  "xorq %r10,%r10\n\t"
                  "xorq %r11,%r11\n\t"
                  "ret")

388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418
#define SYSCALL_FUNC( name, nr ) \
    __ASM_GLOBAL_FUNC( name, \
                       "movq $" #nr ",%rax\n\t" \
                       "movq %rcx,%r10\n\t" \
                       "syscall\n\t" \
                       "leaq 4096(%rax),%rcx\n\t" \
                       "movq $-1,%rdx\n\t" \
                       "cmp $4096,%rcx\n\t" \
                       "cmovb %rdx,%rax\n\t" \
                       "ret" )

#define SYSCALL_NOERR( name, nr ) \
    __ASM_GLOBAL_FUNC( name, \
                       "movq $" #nr ",%rax\n\t" \
                       "syscall\n\t" \
                       "ret" )

void wld_exit( int code ) __attribute__((noreturn));
SYSCALL_NOERR( wld_exit, 60 /* SYS_exit */ );

ssize_t wld_read( int fd, void *buffer, size_t len );
SYSCALL_FUNC( wld_read, 0 /* SYS_read */ );

ssize_t wld_write( int fd, const void *buffer, size_t len );
SYSCALL_FUNC( wld_write, 1 /* SYS_write */ );

int wld_open( const char *name, int flags );
SYSCALL_FUNC( wld_open, 2 /* SYS_open */ );

int wld_close( int fd );
SYSCALL_FUNC( wld_close, 3 /* SYS_close */ );
419 420

void *wld_mmap( void *start, size_t len, int prot, int flags, int fd, off_t offset );
421
SYSCALL_FUNC( wld_mmap, 9 /* SYS_mmap */ );
422

423 424
int wld_mprotect( const void *addr, size_t len, int prot );
SYSCALL_FUNC( wld_mprotect, 10 /* SYS_mprotect */ );
425

426 427
int wld_prctl( int code, int arg );
SYSCALL_FUNC( wld_prctl, 157 /* SYS_prctl */ );
428

429 430
uid_t wld_getuid(void);
SYSCALL_NOERR( wld_getuid, 102 /* SYS_getuid */ );
431

432 433
gid_t wld_getgid(void);
SYSCALL_NOERR( wld_getgid, 104 /* SYS_getgid */ );
434

435 436 437 438 439
uid_t wld_geteuid(void);
SYSCALL_NOERR( wld_geteuid, 107 /* SYS_geteuid */ );

gid_t wld_getegid(void);
SYSCALL_NOERR( wld_getegid, 108 /* SYS_getegid */ );
440 441 442 443

#else
#error preloader not implemented for this CPU
#endif
444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466

/* replacement for libc functions */

static int wld_strcmp( const char *str1, const char *str2 )
{
    while (*str1 && (*str1 == *str2)) { str1++; str2++; }
    return *str1 - *str2;
}

static int wld_strncmp( const char *str1, const char *str2, size_t len )
{
    if (len <= 0) return 0;
    while ((--len > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
    return *str1 - *str2;
}

static inline void *wld_memset( void *dest, int val, size_t len )
{
    char *dst = dest;
    while (len--) *dst++ = val;
    return dest;
}

467 468 469 470 471
/*
 * wld_printf - just the basics
 *
 *  %x prints a hex number
 *  %s prints a string
472
 *  %p prints a pointer
473
 */
Alexandre Julliard's avatar
Alexandre Julliard committed
474
static int wld_vsprintf(char *buffer, const char *fmt, va_list args )
475
{
Alexandre Julliard's avatar
Alexandre Julliard committed
476 477
    static const char hex_chars[16] = "0123456789abcdef";
    const char *p = fmt;
Alexandre Julliard's avatar
Alexandre Julliard committed
478
    char *str = buffer;
479
    int i;
480 481 482 483 484 485 486 487

    while( *p )
    {
        if( *p == '%' )
        {
            p++;
            if( *p == 'x' )
            {
Alexandre Julliard's avatar
Alexandre Julliard committed
488
                unsigned int x = va_arg( args, unsigned int );
489
                for (i = 2*sizeof(x) - 1; i >= 0; i--)
Alexandre Julliard's avatar
Alexandre Julliard committed
490
                    *str++ = hex_chars[(x>>(i*4))&0xf];
491
            }
492 493 494
            else if (p[0] == 'l' && p[1] == 'x')
            {
                unsigned long x = va_arg( args, unsigned long );
495
                for (i = 2*sizeof(x) - 1; i >= 0; i--)
496 497 498 499 500 501
                    *str++ = hex_chars[(x>>(i*4))&0xf];
                p++;
            }
            else if( *p == 'p' )
            {
                unsigned long x = (unsigned long)va_arg( args, void * );
502
                for (i = 2*sizeof(x) - 1; i >= 0; i--)
503 504
                    *str++ = hex_chars[(x>>(i*4))&0xf];
            }
505 506 507 508 509 510 511 512 513 514 515 516 517
            else if( *p == 's' )
            {
                char *s = va_arg( args, char * );
                while(*s)
                    *str++ = *s++;
            }
            else if( *p == 0 )
                break;
            p++;
        }
        *str++ = *p++;
    }
    *str = 0;
Alexandre Julliard's avatar
Alexandre Julliard committed
518
    return str - buffer;
519 520
}

521
static __attribute__((format(printf,1,2))) void wld_printf(const char *fmt, ... )
522 523 524
{
    va_list args;
    char buffer[256];
Alexandre Julliard's avatar
Alexandre Julliard committed
525
    int len;
526 527

    va_start( args, fmt );
Alexandre Julliard's avatar
Alexandre Julliard committed
528
    len = wld_vsprintf(buffer, fmt, args );
529
    va_end( args );
Alexandre Julliard's avatar
Alexandre Julliard committed
530
    wld_write(2, buffer, len);
531 532
}

533
static __attribute__((noreturn,format(printf,1,2))) void fatal_error(const char *fmt, ... )
534 535 536
{
    va_list args;
    char buffer[256];
Alexandre Julliard's avatar
Alexandre Julliard committed
537
    int len;
538 539

    va_start( args, fmt );
Alexandre Julliard's avatar
Alexandre Julliard committed
540
    len = wld_vsprintf(buffer, fmt, args );
541
    va_end( args );
Alexandre Julliard's avatar
Alexandre Julliard committed
542
    wld_write(2, buffer, len);
543
    wld_exit(1);
544 545 546 547 548 549 550
}

#ifdef DUMP_AUX_INFO
/*
 *  Dump interesting bits of the ELF auxv_t structure that is passed
 *   as the 4th parameter to the _start function
 */
551
static void dump_auxiliary( struct wld_auxv *av )
552
{
553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568
#define NAME(at) { at, #at }
    static const struct { int val; const char *name; } names[] =
    {
        NAME(AT_BASE),
        NAME(AT_CLKTCK),
        NAME(AT_EGID),
        NAME(AT_ENTRY),
        NAME(AT_EUID),
        NAME(AT_FLAGS),
        NAME(AT_GID),
        NAME(AT_HWCAP),
        NAME(AT_PAGESZ),
        NAME(AT_PHDR),
        NAME(AT_PHENT),
        NAME(AT_PHNUM),
        NAME(AT_PLATFORM),
569 570
        NAME(AT_SYSINFO),
        NAME(AT_SYSINFO_EHDR),
571 572 573 574 575 576 577 578 579 580
        NAME(AT_UID),
        { 0, NULL }
    };
#undef NAME

    int i;

    for (  ; av->a_type != AT_NULL; av++)
    {
        for (i = 0; names[i].name; i++) if (names[i].val == av->a_type) break;
581 582
        if (names[i].name) wld_printf("%s = %lx\n", names[i].name, (unsigned long)av->a_un.a_val);
        else wld_printf( "%lx = %lx\n", (unsigned long)av->a_type, (unsigned long)av->a_un.a_val );
583
    }
584 585 586 587
}
#endif

/*
588
 * set_auxiliary_values
589
 *
590
 * Set the new auxiliary values
591
 */
592 593
static void set_auxiliary_values( struct wld_auxv *av, const struct wld_auxv *new_av,
                                  const struct wld_auxv *delete_av, void **stack )
594
{
595 596
    int i, j, av_count = 0, new_count = 0, delete_count = 0;
    char *src, *dst;
597 598 599 600

    /* count how many aux values we have already */
    while (av[av_count].a_type != AT_NULL) av_count++;

601 602 603 604 605 606 607 608 609 610 611 612 613
    /* delete unwanted values */
    for (j = 0; delete_av[j].a_type != AT_NULL; j++)
    {
        for (i = 0; i < av_count; i++) if (av[i].a_type == delete_av[j].a_type)
        {
            av[i].a_type = av[av_count-1].a_type;
            av[i].a_un.a_val = av[av_count-1].a_un.a_val;
            av[--av_count].a_type = AT_NULL;
            delete_count++;
            break;
        }
    }

614 615
    /* count how many values we have in new_av that aren't in av */
    for (j = 0; new_av[j].a_type != AT_NULL; j++)
Alexandre Julliard's avatar
Alexandre Julliard committed
616
    {
617 618
        for (i = 0; i < av_count; i++) if (av[i].a_type == new_av[j].a_type) break;
        if (i == av_count) new_count++;
Alexandre Julliard's avatar
Alexandre Julliard committed
619
    }
620

621 622
    src = (char *)*stack;
    dst = src - (new_count - delete_count) * sizeof(*av);
623 624
    dst = (char *)((unsigned long)dst & ~15);
    if (dst < src)   /* need to make room for the extra values */
625 626 627 628
    {
        int len = (char *)(av + av_count + 1) - src;
        for (i = 0; i < len; i++) dst[i] = src[i];
    }
629
    else if (dst > src)  /* get rid of unused values */
630
    {
631
        int len = (char *)(av + av_count + 1) - src;
632
        for (i = len - 1; i >= 0; i--) dst[i] = src[i];
633
    }
634
    *stack = dst;
635
    av = (struct wld_auxv *)((char *)av + (dst - src));
636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653

    /* now set the values */
    for (j = 0; new_av[j].a_type != AT_NULL; j++)
    {
        for (i = 0; i < av_count; i++) if (av[i].a_type == new_av[j].a_type) break;
        if (i < av_count) av[i].a_un.a_val = new_av[j].a_un.a_val;
        else
        {
            av[av_count].a_type     = new_av[j].a_type;
            av[av_count].a_un.a_val = new_av[j].a_un.a_val;
            av_count++;
        }
    }

#ifdef DUMP_AUX_INFO
    wld_printf("New auxiliary info:\n");
    dump_auxiliary( av );
#endif
654 655 656 657 658 659 660
}

/*
 * get_auxiliary
 *
 * Get a field of the auxiliary structure
 */
661
static int get_auxiliary( struct wld_auxv *av, int type, int def_val )
662 663
{
  for ( ; av->a_type != AT_NULL; av++)
664 665
      if( av->a_type == type ) return av->a_un.a_val;
  return def_val;
666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690
}

/*
 * map_so_lib
 *
 * modelled after _dl_map_object_from_fd() from glibc-2.3.1/elf/dl-load.c
 *
 * This function maps the segments from an ELF object, and optionally
 *  stores information about the mapping into the auxv_t structure.
 */
static void map_so_lib( const char *name, struct wld_link_map *l)
{
    int fd;
    unsigned char buf[0x800];
    ElfW(Ehdr) *header = (ElfW(Ehdr)*)buf;
    ElfW(Phdr) *phdr, *ph;
    /* Scan the program header table, collecting its load commands.  */
    struct loadcmd
      {
        ElfW(Addr) mapstart, mapend, dataend, allocend;
        off_t mapoff;
        int prot;
      } loadcmds[16], *c;
    size_t nloadcmds = 0, maplength;

691
    fd = wld_open( name, O_RDONLY );
692 693
    if (fd == -1) fatal_error("%s: could not open\n", name );

694
    if (wld_read( fd, buf, sizeof(buf) ) != sizeof(buf))
695 696 697 698 699 700 701 702 703 704
        fatal_error("%s: failed to read ELF header\n", name);

    phdr = (void*) (((unsigned char*)buf) + header->e_phoff);

    if( ( header->e_ident[0] != 0x7f ) ||
        ( header->e_ident[1] != 'E' ) ||
        ( header->e_ident[2] != 'L' ) ||
        ( header->e_ident[3] != 'F' ) )
        fatal_error( "%s: not an ELF binary... don't know how to load it\n", name );

705
#ifdef __i386__
706 707
    if( header->e_machine != EM_386 )
        fatal_error("%s: not an i386 ELF binary... don't know how to load it\n", name );
708 709 710 711
#elif defined(__x86_64__)
    if( header->e_machine != EM_X86_64 )
        fatal_error("%s: not an x86-64 ELF binary... don't know how to load it\n", name );
#endif
712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730

    if (header->e_phnum > sizeof(loadcmds)/sizeof(loadcmds[0]))
        fatal_error( "%s: oops... not enough space for load commands\n", name );

    maplength = header->e_phnum * sizeof (ElfW(Phdr));
    if (header->e_phoff + maplength > sizeof(buf))
        fatal_error( "%s: oops... not enough space for ELF headers\n", name );

    l->l_ld = 0;
    l->l_addr = 0;
    l->l_phdr = 0;
    l->l_phnum = header->e_phnum;
    l->l_entry = header->e_entry;
    l->l_interp = 0;

    for (ph = phdr; ph < &phdr[l->l_phnum]; ++ph)
    {

#ifdef DUMP_SEGMENTS
731
      wld_printf( "ph = %p\n", ph );
732 733 734 735 736 737 738 739
      wld_printf( " p_type   = %lx\n", (unsigned long)ph->p_type );
      wld_printf( " p_flags  = %lx\n", (unsigned long)ph->p_flags );
      wld_printf( " p_offset = %lx\n", (unsigned long)ph->p_offset );
      wld_printf( " p_vaddr  = %lx\n", (unsigned long)ph->p_vaddr );
      wld_printf( " p_paddr  = %lx\n", (unsigned long)ph->p_paddr );
      wld_printf( " p_filesz = %lx\n", (unsigned long)ph->p_filesz );
      wld_printf( " p_memsz  = %lx\n", (unsigned long)ph->p_memsz );
      wld_printf( " p_align  = %lx\n", (unsigned long)ph->p_align );
740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
#endif

      switch (ph->p_type)
        {
          /* These entries tell us where to find things once the file's
             segments are mapped in.  We record the addresses it says
             verbatim, and later correct for the run-time load address.  */
        case PT_DYNAMIC:
          l->l_ld = (void *) ph->p_vaddr;
          l->l_ldnum = ph->p_memsz / sizeof (Elf32_Dyn);
          break;

        case PT_PHDR:
          l->l_phdr = (void *) ph->p_vaddr;
          break;

        case PT_LOAD:
          {
            if ((ph->p_align & page_mask) != 0)
              fatal_error( "%s: ELF load command alignment not page-aligned\n", name );

            if (((ph->p_vaddr - ph->p_offset) & (ph->p_align - 1)) != 0)
              fatal_error( "%s: ELF load command address/offset not properly aligned\n", name );

            c = &loadcmds[nloadcmds++];
            c->mapstart = ph->p_vaddr & ~(ph->p_align - 1);
            c->mapend = ((ph->p_vaddr + ph->p_filesz + page_mask) & ~page_mask);
            c->dataend = ph->p_vaddr + ph->p_filesz;
            c->allocend = ph->p_vaddr + ph->p_memsz;
            c->mapoff = ph->p_offset & ~(ph->p_align - 1);

            c->prot = 0;
            if (ph->p_flags & PF_R)
              c->prot |= PROT_READ;
            if (ph->p_flags & PF_W)
              c->prot |= PROT_WRITE;
            if (ph->p_flags & PF_X)
              c->prot |= PROT_EXEC;
          }
          break;

        case PT_INTERP:
          l->l_interp = ph->p_vaddr;
          break;

        case PT_TLS:
          /*
           * We don't need to set anything up because we're
           * emulating the kernel, not ld-linux.so.2
           * The ELF loader will set up the TLS data itself.
           */
        case PT_SHLIB:
        case PT_NOTE:
        default:
          break;
        }
    }

    /* Now process the load commands and map segments into memory.  */
799 800
    if (!nloadcmds)
        fatal_error( "%s: no segments to load\n", name );
801 802 803 804 805 806 807 808 809 810 811 812
    c = loadcmds;

    /* Length of the sections to be loaded.  */
    maplength = loadcmds[nloadcmds - 1].allocend - c->mapstart;

    if( header->e_type == ET_DYN )
    {
        ElfW(Addr) mappref;
        mappref = (ELF_PREFERRED_ADDRESS (loader, maplength, c->mapstart)
                   - MAP_BASE_ADDR (l));

        /* Remember which part of the address space this object uses.  */
813
        l->l_map_start = (ElfW(Addr)) wld_mmap ((void *) mappref, maplength,
814 815 816 817 818 819 820 821
                                              c->prot, MAP_COPY | MAP_FILE,
                                              fd, c->mapoff);
        /* wld_printf("set  : offset = %x\n", c->mapoff); */
        /* wld_printf("l->l_map_start = %x\n", l->l_map_start); */

        l->l_map_end = l->l_map_start + maplength;
        l->l_addr = l->l_map_start - c->mapstart;

822
        wld_mprotect ((caddr_t) (l->l_addr + c->mapend),
823 824 825 826 827 828 829 830 831
                    loadcmds[nloadcmds - 1].allocend - c->mapend,
                    PROT_NONE);
        goto postmap;
    }
    else
    {
        /* sanity check */
        if ((char *)c->mapstart + maplength > preloader_start &&
            (char *)c->mapstart <= preloader_end)
832 833
            fatal_error( "%s: binary overlaps preloader (%p-%p)\n",
                         name, (char *)c->mapstart, (char *)c->mapstart + maplength );
834 835 836 837 838 839 840 841 842 843 844 845

        ELF_FIXED_ADDRESS (loader, c->mapstart);
    }

    /* Remember which part of the address space this object uses.  */
    l->l_map_start = c->mapstart + l->l_addr;
    l->l_map_end = l->l_map_start + maplength;

    while (c < &loadcmds[nloadcmds])
      {
        if (c->mapend > c->mapstart)
            /* Map the segment contents from the file.  */
846
            wld_mmap ((void *) (l->l_addr + c->mapstart),
847 848 849 850 851 852 853 854 855
                        c->mapend - c->mapstart, c->prot,
                        MAP_FIXED | MAP_COPY | MAP_FILE, fd, c->mapoff);

      postmap:
        if (l->l_phdr == 0
            && (ElfW(Off)) 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.  */
856
          l->l_phdr = (void *)(unsigned long)(c->mapstart + header->e_phoff - c->mapoff);
857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886

        if (c->allocend > c->dataend)
          {
            /* Extra zero pages should appear at the end of this segment,
               after the data mapped from the file.   */
            ElfW(Addr) zero, zeroend, zeropage;

            zero = l->l_addr + c->dataend;
            zeroend = l->l_addr + c->allocend;
            zeropage = (zero + page_mask) & ~page_mask;

            /*
             * This is different from the dl-load load...
             *  ld-linux.so.2 relies on the whole page being zero'ed
             */
            zeroend = (zeroend + page_mask) & ~page_mask;

            if (zeroend < zeropage)
            {
              /* All the extra data is in the last page of the segment.
                 We can just zero it.  */
              zeropage = zeroend;
            }

            if (zeropage > zero)
              {
                /* Zero the final part of the last page of the segment.  */
                if ((c->prot & PROT_WRITE) == 0)
                  {
                    /* Dag nab it.  */
887
                    wld_mprotect ((caddr_t) (zero & ~page_mask), page_size, c->prot|PROT_WRITE);
888
                  }
889
                wld_memset ((void *) zero, '\0', zeropage - zero);
890
                if ((c->prot & PROT_WRITE) == 0)
891
                  wld_mprotect ((caddr_t) (zero & ~page_mask), page_size, c->prot);
892 893 894 895 896
              }

            if (zeroend > zeropage)
              {
                /* Map the remaining zero pages in from the zero fill FD.  */
897
                wld_mmap ((caddr_t) zeropage, zeroend - zeropage,
898 899 900 901 902 903 904 905 906 907 908 909 910
                                c->prot, MAP_ANON|MAP_PRIVATE|MAP_FIXED,
                                -1, 0);
              }
          }

        ++c;
      }

    if (l->l_phdr == NULL) fatal_error("no program header\n");

    l->l_phdr = (void *)((ElfW(Addr))l->l_phdr + l->l_addr);
    l->l_entry += l->l_addr;

911
    wld_close( fd );
912 913 914
}


915
static unsigned int wld_elf_hash( const char *name )
916 917 918 919 920 921 922 923 924 925 926 927
{
    unsigned int hi, hash = 0;
    while (*name)
    {
        hash = (hash << 4) + (unsigned char)*name++;
        hi = hash & 0xf0000000;
        hash ^= hi;
        hash ^= hi >> 24;
    }
    return hash;
}

928 929 930 931 932 933 934
static unsigned int gnu_hash( const char *name )
{
    unsigned int h = 5381;
    while (*name) h = h * 33 + (unsigned char)*name++;
    return h;
}

935 936 937
/*
 * Find a symbol in the symbol table of the executable loaded
 */
938
static void *find_symbol( const ElfW(Phdr) *phdr, int num, const char *var, int type )
939 940 941 942
{
    const ElfW(Dyn) *dyn = NULL;
    const ElfW(Phdr) *ph;
    const ElfW(Sym) *symtab = NULL;
943
    const Elf32_Word *hashtab = NULL;
944
    const Elf32_Word *gnu_hashtab = NULL;
945
    const char *strings = NULL;
946
    Elf32_Word idx;
947 948 949

    /* check the values */
#ifdef DUMP_SYMS
950
    wld_printf("%p %x\n", phdr, num );
951 952 953 954 955 956 957 958 959 960 961 962 963
#endif
    if( ( phdr == NULL ) || ( num == 0 ) )
    {
        wld_printf("could not find PT_DYNAMIC header entry\n");
        return NULL;
    }

    /* parse the (already loaded) ELF executable's header */
    for (ph = phdr; ph < &phdr[num]; ++ph)
    {
        if( PT_DYNAMIC == ph->p_type )
        {
            dyn = (void *) ph->p_vaddr;
964
            num = ph->p_memsz / sizeof (*dyn);
965 966 967 968 969 970 971 972 973 974 975 976
            break;
        }
    }
    if( !dyn ) return NULL;

    while( dyn->d_tag )
    {
        if( dyn->d_tag == DT_STRTAB )
            strings = (const char*) dyn->d_un.d_ptr;
        if( dyn->d_tag == DT_SYMTAB )
            symtab = (const ElfW(Sym) *)dyn->d_un.d_ptr;
        if( dyn->d_tag == DT_HASH )
977
            hashtab = (const Elf32_Word *)dyn->d_un.d_ptr;
978 979
        if( dyn->d_tag == DT_GNU_HASH )
            gnu_hashtab = (const Elf32_Word *)dyn->d_un.d_ptr;
980
#ifdef DUMP_SYMS
981
        wld_printf("%lx %p\n", (unsigned long)dyn->d_tag, (void *)dyn->d_un.d_ptr );
982 983 984 985 986 987
#endif
        dyn++;
    }

    if( (!symtab) || (!strings) ) return NULL;

988 989 990 991 992 993 994 995 996 997 998 999 1000 1001
    if (gnu_hashtab)  /* new style hash table */
    {
        const unsigned int hash   = gnu_hash(var);
        const Elf32_Word nbuckets = gnu_hashtab[0];
        const Elf32_Word symbias  = gnu_hashtab[1];
        const Elf32_Word nwords   = gnu_hashtab[2];
        const ElfW(Addr) *bitmask = (const ElfW(Addr) *)(gnu_hashtab + 4);
        const Elf32_Word *buckets = (const Elf32_Word *)(bitmask + nwords);
        const Elf32_Word *chains  = buckets + nbuckets - symbias;

        if (!(idx = buckets[hash % nbuckets])) return NULL;
        do
        {
            if ((chains[idx] & ~1u) == (hash & ~1u) &&
1002 1003
                ELF32_ST_BIND(symtab[idx].st_info) == STB_GLOBAL &&
                ELF32_ST_TYPE(symtab[idx].st_info) == type &&
1004 1005 1006 1007 1008
                !wld_strcmp( strings + symtab[idx].st_name, var ))
                goto found;
        } while (!(chains[idx++] & 1u));
    }
    else if (hashtab)  /* old style hash table */
1009
    {
1010
        const unsigned int hash   = wld_elf_hash(var);
1011 1012 1013
        const Elf32_Word nbuckets = hashtab[0];
        const Elf32_Word *buckets = hashtab + 2;
        const Elf32_Word *chains  = buckets + nbuckets;
1014

1015
        for (idx = buckets[hash % nbuckets]; idx; idx = chains[idx])
1016
        {
1017 1018
            if (ELF32_ST_BIND(symtab[idx].st_info) == STB_GLOBAL &&
                ELF32_ST_TYPE(symtab[idx].st_info) == type &&
1019
                !wld_strcmp( strings + symtab[idx].st_name, var ))
1020
                goto found;
1021 1022 1023
        }
    }
    return NULL;
1024 1025 1026

found:
#ifdef DUMP_SYMS
1027
    wld_printf("Found %s -> %p\n", strings + symtab[idx].st_name, (void *)symtab[idx].st_value );
1028 1029
#endif
    return (void *)symtab[idx].st_value;
1030 1031
}

1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
/*
 *  preload_reserve
 *
 * Reserve a range specified in string format
 */
static void preload_reserve( const char *str )
{
    const char *p;
    unsigned long result = 0;
    void *start = NULL, *end = NULL;
1042
    int i, first = 1;
1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065

    for (p = str; *p; p++)
    {
        if (*p >= '0' && *p <= '9') result = result * 16 + *p - '0';
        else if (*p >= 'a' && *p <= 'f') result = result * 16 + *p - 'a' + 10;
        else if (*p >= 'A' && *p <= 'F') result = result * 16 + *p - 'A' + 10;
        else if (*p == '-')
        {
            if (!first) goto error;
            start = (void *)(result & ~page_mask);
            result = 0;
            first = 0;
        }
        else goto error;
    }
    if (!first) end = (void *)((result + page_mask) & ~page_mask);
    else if (result) goto error;  /* single value '0' is allowed */

    /* sanity checks */
    if (end <= start) start = end = NULL;
    else if ((char *)end > preloader_start &&
             (char *)start <= preloader_end)
    {
1066
        wld_printf( "WINEPRELOADRESERVE range %p-%p overlaps preloader %p-%p\n",
1067 1068 1069 1070
                     start, end, preloader_start, preloader_end );
        start = end = NULL;
    }

1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
    /* check for overlap with low memory areas */
    for (i = 0; preload_info[i].size; i++)
    {
        if ((char *)preload_info[i].addr > (char *)0x00110000) break;
        if ((char *)end <= (char *)preload_info[i].addr + preload_info[i].size)
        {
            start = end = NULL;
            break;
        }
        if ((char *)start < (char *)preload_info[i].addr + preload_info[i].size)
            start = (char *)preload_info[i].addr + preload_info[i].size;
    }
1083

1084 1085 1086
    while (preload_info[i].size) i++;
    preload_info[i].addr = start;
    preload_info[i].size = (char *)end - (char *)start;
1087 1088 1089 1090 1091 1092
    return;

error:
    fatal_error( "invalid WINEPRELOADRESERVE value '%s'\n", str );
}

1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
/* check if address is in one of the reserved ranges */
static int is_addr_reserved( const void *addr )
{
    int i;

    for (i = 0; preload_info[i].size; i++)
    {
        if ((const char *)addr >= (const char *)preload_info[i].addr &&
            (const char *)addr <  (const char *)preload_info[i].addr + preload_info[i].size)
            return 1;
    }
    return 0;
}

/* remove a range from the preload list */
static void remove_preload_range( int i )
{
    while (preload_info[i].size)
    {
        preload_info[i].addr = preload_info[i+1].addr;
        preload_info[i].size = preload_info[i+1].size;
        i++;
    }
}

1118 1119 1120 1121 1122
/*
 *  is_in_preload_range
 *
 * Check if address of the given aux value is in one of the reserved ranges
 */
1123
static int is_in_preload_range( const struct wld_auxv *av, int type )
1124
{
1125
    while (av->a_type != AT_NULL)
1126
    {
1127 1128
        if (av->a_type == type) return is_addr_reserved( (const void *)av->a_un.a_val );
        av++;
1129 1130 1131
    }
    return 0;
}
1132

1133 1134 1135
/* set the process name if supported */
static void set_process_name( int argc, char *argv[] )
{
1136 1137
    int i;
    unsigned int off;
1138 1139 1140 1141
    char *p, *name, *end;

    /* set the process short name */
    for (p = name = argv[1]; *p; p++) if (p[0] == '/' && p[1]) name = p + 1;
1142
    if (wld_prctl( 15 /* PR_SET_NAME */, (long)name ) == -1) return;
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153

    /* find the end of the argv array and move everything down */
    end = argv[argc - 1];
    while (*end) end++;
    off = argv[1] - argv[0];
    for (p = argv[1]; p <= end; p++) *(p - off) = *p;
    wld_memset( end - off, 0, off );
    for (i = 1; i < argc; i++) argv[i] -= off;
}


1154 1155 1156 1157 1158 1159 1160
/*
 *  wld_start
 *
 *  Repeat the actions the kernel would do when loading a dynamically linked .so
 *  Load the binary and then its ELF interpreter.
 *  Note, we assume that the binary is a dynamically linked ELF shared object.
 */
1161
void* wld_start( void **stack )
1162
{
1163
    long i, *pargc;
1164
    char **argv, **p;
1165
    char *interp, *reserve = NULL;
1166
    struct wld_auxv new_av[12], delete_av[3], *av;
1167 1168 1169
    struct wld_link_map main_binary_map, ld_so_map;
    struct wine_preload_info **wine_main_preload_info;

1170 1171
    pargc = *stack;
    argv = (char **)pargc + 1;
1172
    if (*pargc < 2) fatal_error( "Usage: %s wine_binary [args]\n", argv[0] );
1173 1174

    /* skip over the parameters */
1175
    p = argv + *pargc + 1;
1176 1177

    /* skip over the environment */
1178 1179 1180
    while (*p)
    {
        static const char res[] = "WINEPRELOADRESERVE=";
1181
        if (!wld_strncmp( *p, res, sizeof(res)-1 )) reserve = *p + sizeof(res) - 1;
1182 1183
        p++;
    }
1184

1185
    av = (struct wld_auxv *)(p+1);
1186
    page_size = get_auxiliary( av, AT_PAGESZ, 4096 );
1187 1188
    page_mask = page_size - 1;

1189 1190
    preloader_start = (char *)_start - ((unsigned long)_start & page_mask);
    preloader_end = (char *)((unsigned long)(_end + page_mask) & ~page_mask);
1191

1192
#ifdef DUMP_AUX_INFO
1193
    wld_printf( "stack = %p\n", *stack );
1194
    for( i = 0; i < *pargc; i++ ) wld_printf("argv[%lx] = %s\n", i, argv[i]);
1195 1196 1197 1198
    dump_auxiliary( av );
#endif

    /* reserve memory that Wine needs */
1199
    if (reserve) preload_reserve( reserve );
1200
    for (i = 0; preload_info[i].size; i++)
1201
    {
1202 1203 1204 1205 1206 1207 1208 1209
        if ((char *)av >= (char *)preload_info[i].addr &&
            (char *)pargc <= (char *)preload_info[i].addr + preload_info[i].size)
        {
            remove_preload_range( i );
            i--;
        }
        else if (wld_mmap( preload_info[i].addr, preload_info[i].size, PROT_NONE,
                           MAP_FIXED | MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, -1, 0 ) == (void *)-1)
1210
        {
1211 1212 1213 1214
            /* don't warn for low 64k */
            if (preload_info[i].addr >= (void *)0x10000)
                wld_printf( "preloader: Warning: failed to reserve range %p-%p\n",
                            preload_info[i].addr, (char *)preload_info[i].addr + preload_info[i].size );
1215 1216 1217 1218
            remove_preload_range( i );
            i--;
        }
    }
1219

1220 1221
    /* add an executable page at the top of the address space to defeat
     * broken no-exec protections that play with the code selector limit */
1222 1223
    if (is_addr_reserved( (char *)0x80000000 - page_size ))
        wld_mprotect( (char *)0x80000000 - page_size, page_size, PROT_EXEC | PROT_READ );
1224

1225
    /* load the main binary */
1226
    map_so_lib( argv[1], &main_binary_map );
1227 1228 1229 1230 1231 1232 1233

    /* load the ELF interpreter */
    interp = (char *)main_binary_map.l_addr + main_binary_map.l_interp;
    map_so_lib( interp, &ld_so_map );

    /* store pointer to the preload info into the appropriate main binary variable */
    wine_main_preload_info = find_symbol( main_binary_map.l_phdr, main_binary_map.l_phnum,
1234
                                          "wine_main_preload_info", STT_OBJECT );
1235 1236 1237
    if (wine_main_preload_info) *wine_main_preload_info = preload_info;
    else wld_printf( "wine_main_preload_info not found\n" );

1238 1239 1240 1241 1242 1243 1244 1245
#define SET_NEW_AV(n,type,val) new_av[n].a_type = (type); new_av[n].a_un.a_val = (val);
    SET_NEW_AV( 0, AT_PHDR, (unsigned long)main_binary_map.l_phdr );
    SET_NEW_AV( 1, AT_PHENT, sizeof(ElfW(Phdr)) );
    SET_NEW_AV( 2, AT_PHNUM, main_binary_map.l_phnum );
    SET_NEW_AV( 3, AT_PAGESZ, page_size );
    SET_NEW_AV( 4, AT_BASE, ld_so_map.l_addr );
    SET_NEW_AV( 5, AT_FLAGS, get_auxiliary( av, AT_FLAGS, 0 ) );
    SET_NEW_AV( 6, AT_ENTRY, main_binary_map.l_entry );
1246 1247 1248 1249
    SET_NEW_AV( 7, AT_UID, get_auxiliary( av, AT_UID, wld_getuid() ) );
    SET_NEW_AV( 8, AT_EUID, get_auxiliary( av, AT_EUID, wld_geteuid() ) );
    SET_NEW_AV( 9, AT_GID, get_auxiliary( av, AT_GID, wld_getgid() ) );
    SET_NEW_AV(10, AT_EGID, get_auxiliary( av, AT_EGID, wld_getegid() ) );
1250
    SET_NEW_AV(11, AT_NULL, 0 );
1251 1252
#undef SET_NEW_AV

1253 1254
    i = 0;
    /* delete sysinfo values if addresses conflict */
1255 1256 1257 1258 1259
    if (is_in_preload_range( av, AT_SYSINFO ) || is_in_preload_range( av, AT_SYSINFO_EHDR ))
    {
        delete_av[i++].a_type = AT_SYSINFO;
        delete_av[i++].a_type = AT_SYSINFO_EHDR;
    }
1260 1261
    delete_av[i].a_type = AT_NULL;

1262
    /* get rid of first argument */
1263
    set_process_name( *pargc, argv );
1264 1265 1266
    pargc[1] = pargc[0] - 1;
    *stack = pargc + 1;

1267
    set_auxiliary_values( av, new_av, delete_av, stack );
1268 1269

#ifdef DUMP_AUX_INFO
1270
    wld_printf("new stack = %p\n", *stack);
1271
    wld_printf("jumping to %p\n", (void *)ld_so_map.l_entry);
1272 1273 1274 1275
#endif

    return (void *)ld_so_map.l_entry;
}