preloader.c 41 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
    { 0, 0 }                             /* end of list */
};

/* debugging */
#undef DUMP_SEGMENTS
#undef DUMP_AUX_INFO
#undef DUMP_SYMS
130
#undef DUMP_MAPS
131 132 133 134 135 136

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

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

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

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

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

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

171 172 173 174 175 176 177
/*
 * 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.
 */
178
void __bb_init_func(void) { return; }
179

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

185 186
#ifdef __i386__

187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
/* 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;
202
    unsigned int  usable : 1;
203 204 205 206
    unsigned int  garbage : 25;
} thread_ldt = { -1, (unsigned long)thread_data, 0xfffff, 1, 0, 0, 1, 0, 1, 0 };


207 208 209 210
/*
 * The _start function is the entry and exit point of this program
 *
 *  It calls wld_start, passing a pointer to the args it receives
211
 *  then jumps to the address wld_start returns.
212
 */
213
void _start(void);
214 215
extern char _end[];
__ASM_GLOBAL_FUNC(_start,
216
                  __ASM_CFI("\t.cfi_undefined %eip\n")
217 218 219 220 221 222 223 224 225 226 227
                  "\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"
228
                  "\tleal -136(%esp),%esp\n"  /* allocate some space for extra aux values */
229 230
                  "\tpushl %eax\n"            /* orig stack pointer */
                  "\tpushl %esp\n"            /* ptr to orig stack pointer */
231
                  "\tcall wld_start\n"
232 233 234
                  "\tpopl %ecx\n"             /* remove ptr to stack pointer */
                  "\tpopl %esp\n"             /* new stack pointer */
                  "\tpush %eax\n"             /* ELF interpreter entry point */
235 236 237
                  "\txor %eax,%eax\n"
                  "\txor %ecx,%ecx\n"
                  "\txor %edx,%edx\n"
238
                  "\tmov %ax,%gs\n"           /* clear %gs again */
239 240
                  "\tret\n")

241 242 243 244 245 246 247
/* 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 */
248
        __asm__ __volatile__( "pushl %%ebx; movl %1,%%ebx; int $0x80; popl %%ebx"
249
                              : : "a" (1 /* SYS_exit */), "r" (code) );
250 251 252 253 254
}

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

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

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

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

static inline int wld_mprotect( const void *addr, size_t len, int prot )
{
    int ret;
289
    __asm__ __volatile__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
290
                          : "=a" (ret) : "0" (125 /* SYS_mprotect */), "r" (addr), "c" (len), "d" (prot) );
291 292 293
    return SYSCALL_RET(ret);
}

294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
void *wld_mmap( void *start, size_t len, int prot, int flags, int fd, unsigned int offset );
__ASM_GLOBAL_FUNC(wld_mmap,
                  "\tpushl %ebp\n"
                  __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
                  "\tpushl %ebx\n"
                  __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
                  "\tpushl %esi\n"
                  __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
                  "\tpushl %edi\n"
                  __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
                  "\tmovl $192,%eax\n"      /* SYS_mmap2 */
                  "\tmovl 20(%esp),%ebx\n"  /* start */
                  "\tmovl 24(%esp),%ecx\n"  /* len */
                  "\tmovl 28(%esp),%edx\n"  /* prot */
                  "\tmovl 32(%esp),%esi\n"  /* flags */
                  "\tmovl 36(%esp),%edi\n"  /* fd */
                  "\tmovl 40(%esp),%ebp\n"  /* offset */
                  "\tshrl $12,%ebp\n"
                  "\tint $0x80\n"
                  "\tcmpl $-4096,%eax\n"
314 315 316 317 318 319 320 321 322 323
                  "\tjbe 2f\n"
                  "\tcmpl $-38,%eax\n"      /* ENOSYS */
                  "\tjne 1f\n"
                  "\tmovl $90,%eax\n"       /* SYS_mmap */
                  "\tleal 20(%esp),%ebx\n"
                  "\tint $0x80\n"
                  "\tcmpl $-4096,%eax\n"
                  "\tjbe 2f\n"
                  "1:\tmovl $-1,%eax\n"
                  "2:\tpopl %edi\n"
324 325 326 327 328 329 330 331
                  __ASM_CFI(".cfi_adjust_cfa_offset -4\n\t")
                  "\tpopl %esi\n"
                  __ASM_CFI(".cfi_adjust_cfa_offset -4\n\t")
                  "\tpopl %ebx\n"
                  __ASM_CFI(".cfi_adjust_cfa_offset -4\n\t")
                  "\tpopl %ebp\n"
                  __ASM_CFI(".cfi_adjust_cfa_offset -4\n\t")
                  "\tret\n" )
332 333 334 335

static inline uid_t wld_getuid(void)
{
    uid_t ret;
336
    __asm__( "int $0x80" : "=a" (ret) : "0" (24 /* SYS_getuid */) );
337 338 339 340 341 342
    return ret;
}

static inline uid_t wld_geteuid(void)
{
    uid_t ret;
343
    __asm__( "int $0x80" : "=a" (ret) : "0" (49 /* SYS_geteuid */) );
344 345 346 347 348 349
    return ret;
}

static inline gid_t wld_getgid(void)
{
    gid_t ret;
350
    __asm__( "int $0x80" : "=a" (ret) : "0" (47 /* SYS_getgid */) );
351 352 353 354 355 356
    return ret;
}

static inline gid_t wld_getegid(void)
{
    gid_t ret;
357
    __asm__( "int $0x80" : "=a" (ret) : "0" (50 /* SYS_getegid */) );
358 359 360
    return ret;
}

361
static inline int wld_prctl( int code, long arg )
362 363 364
{
    int ret;
    __asm__ __volatile__( "pushl %%ebx; movl %2,%%ebx; int $0x80; popl %%ebx"
365
                          : "=a" (ret) : "0" (172 /* SYS_prctl */), "r" (code), "c" (arg) );
366 367 368
    return SYSCALL_RET(ret);
}

369 370
#elif defined(__x86_64__)

371 372
void *thread_data[256];

373 374 375 376 377 378 379 380 381
/*
 * 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,
382
                  __ASM_CFI(".cfi_undefined %rip\n\t")
383 384
                  "movq %rsp,%rax\n\t"
                  "leaq -144(%rsp),%rsp\n\t" /* allocate some space for extra aux values */
385 386 387 388 389
                  "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"
390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
                  "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")

405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
#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 */ );
436 437

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

440 441
int wld_mprotect( const void *addr, size_t len, int prot );
SYSCALL_FUNC( wld_mprotect, 10 /* SYS_mprotect */ );
442

443
int wld_prctl( int code, long arg );
444
SYSCALL_FUNC( wld_prctl, 157 /* SYS_prctl */ );
445

446 447
uid_t wld_getuid(void);
SYSCALL_NOERR( wld_getuid, 102 /* SYS_getuid */ );
448

449 450
gid_t wld_getgid(void);
SYSCALL_NOERR( wld_getgid, 104 /* SYS_getgid */ );
451

452 453 454 455 456
uid_t wld_geteuid(void);
SYSCALL_NOERR( wld_geteuid, 107 /* SYS_geteuid */ );

gid_t wld_getegid(void);
SYSCALL_NOERR( wld_getegid, 108 /* SYS_getegid */ );
457 458 459 460

#else
#error preloader not implemented for this CPU
#endif
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483

/* 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;
}

484 485 486 487 488
/*
 * wld_printf - just the basics
 *
 *  %x prints a hex number
 *  %s prints a string
489
 *  %p prints a pointer
490
 */
Alexandre Julliard's avatar
Alexandre Julliard committed
491
static int wld_vsprintf(char *buffer, const char *fmt, va_list args )
492
{
Alexandre Julliard's avatar
Alexandre Julliard committed
493 494
    static const char hex_chars[16] = "0123456789abcdef";
    const char *p = fmt;
Alexandre Julliard's avatar
Alexandre Julliard committed
495
    char *str = buffer;
496
    int i;
497 498 499 500 501 502 503 504

    while( *p )
    {
        if( *p == '%' )
        {
            p++;
            if( *p == 'x' )
            {
Alexandre Julliard's avatar
Alexandre Julliard committed
505
                unsigned int x = va_arg( args, unsigned int );
506
                for (i = 2*sizeof(x) - 1; i >= 0; i--)
Alexandre Julliard's avatar
Alexandre Julliard committed
507
                    *str++ = hex_chars[(x>>(i*4))&0xf];
508
            }
509 510 511
            else if (p[0] == 'l' && p[1] == 'x')
            {
                unsigned long x = va_arg( args, unsigned long );
512
                for (i = 2*sizeof(x) - 1; i >= 0; i--)
513 514 515 516 517 518
                    *str++ = hex_chars[(x>>(i*4))&0xf];
                p++;
            }
            else if( *p == 'p' )
            {
                unsigned long x = (unsigned long)va_arg( args, void * );
519
                for (i = 2*sizeof(x) - 1; i >= 0; i--)
520 521
                    *str++ = hex_chars[(x>>(i*4))&0xf];
            }
522 523 524 525 526 527 528 529 530 531 532 533 534
            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
535
    return str - buffer;
536 537
}

538
static __attribute__((format(printf,1,2))) void wld_printf(const char *fmt, ... )
539 540 541
{
    va_list args;
    char buffer[256];
Alexandre Julliard's avatar
Alexandre Julliard committed
542
    int len;
543 544

    va_start( args, fmt );
Alexandre Julliard's avatar
Alexandre Julliard committed
545
    len = wld_vsprintf(buffer, fmt, args );
546
    va_end( args );
Alexandre Julliard's avatar
Alexandre Julliard committed
547
    wld_write(2, buffer, len);
548 549
}

550
static __attribute__((noreturn,format(printf,1,2))) void fatal_error(const char *fmt, ... )
551 552 553
{
    va_list args;
    char buffer[256];
Alexandre Julliard's avatar
Alexandre Julliard committed
554
    int len;
555 556

    va_start( args, fmt );
Alexandre Julliard's avatar
Alexandre Julliard committed
557
    len = wld_vsprintf(buffer, fmt, args );
558
    va_end( args );
Alexandre Julliard's avatar
Alexandre Julliard committed
559
    wld_write(2, buffer, len);
560
    wld_exit(1);
561 562 563 564 565 566 567
}

#ifdef DUMP_AUX_INFO
/*
 *  Dump interesting bits of the ELF auxv_t structure that is passed
 *   as the 4th parameter to the _start function
 */
568
static void dump_auxiliary( struct wld_auxv *av )
569
{
570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
#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),
586 587
        NAME(AT_SYSINFO),
        NAME(AT_SYSINFO_EHDR),
588 589 590 591 592 593 594 595 596 597
        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;
598 599
        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 );
600
    }
601 602 603 604
}
#endif

/*
605
 * set_auxiliary_values
606
 *
607
 * Set the new auxiliary values
608
 */
609 610
static void set_auxiliary_values( struct wld_auxv *av, const struct wld_auxv *new_av,
                                  const struct wld_auxv *delete_av, void **stack )
611
{
612 613
    int i, j, av_count = 0, new_count = 0, delete_count = 0;
    char *src, *dst;
614 615 616 617

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

618 619 620 621 622 623 624 625 626 627 628 629 630
    /* 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;
        }
    }

631 632
    /* 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
633
    {
634 635
        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
636
    }
637

638 639
    src = (char *)*stack;
    dst = src - (new_count - delete_count) * sizeof(*av);
640 641
    dst = (char *)((unsigned long)dst & ~15);
    if (dst < src)   /* need to make room for the extra values */
642 643 644 645
    {
        int len = (char *)(av + av_count + 1) - src;
        for (i = 0; i < len; i++) dst[i] = src[i];
    }
646
    else if (dst > src)  /* get rid of unused values */
647
    {
648
        int len = (char *)(av + av_count + 1) - src;
649
        for (i = len - 1; i >= 0; i--) dst[i] = src[i];
650
    }
651
    *stack = dst;
652
    av = (struct wld_auxv *)((char *)av + (dst - src));
653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670

    /* 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
671 672 673 674 675 676 677
}

/*
 * get_auxiliary
 *
 * Get a field of the auxiliary structure
 */
678
static int get_auxiliary( struct wld_auxv *av, int type, int def_val )
679 680
{
  for ( ; av->a_type != AT_NULL; av++)
681 682
      if( av->a_type == type ) return av->a_un.a_val;
  return def_val;
683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707
}

/*
 * 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;

708
    fd = wld_open( name, O_RDONLY );
709 710
    if (fd == -1) fatal_error("%s: could not open\n", name );

711
    if (wld_read( fd, buf, sizeof(buf) ) != sizeof(buf))
712 713 714 715 716 717 718 719 720 721
        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 );

722
#ifdef __i386__
723 724
    if( header->e_machine != EM_386 )
        fatal_error("%s: not an i386 ELF binary... don't know how to load it\n", name );
725 726 727 728
#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
729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747

    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
748
      wld_printf( "ph = %p\n", ph );
749 750 751 752 753 754 755 756
      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 );
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 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815
#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.  */
816 817
    if (!nloadcmds)
        fatal_error( "%s: no segments to load\n", name );
818 819 820 821 822 823 824 825 826 827 828 829
    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.  */
830
        l->l_map_start = (ElfW(Addr)) wld_mmap ((void *) mappref, maplength,
831 832 833 834 835 836 837 838
                                              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;

839
        wld_mprotect ((caddr_t) (l->l_addr + c->mapend),
840 841 842 843 844 845 846 847 848
                    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)
849 850
            fatal_error( "%s: binary overlaps preloader (%p-%p)\n",
                         name, (char *)c->mapstart, (char *)c->mapstart + maplength );
851 852 853 854 855 856 857 858 859 860 861 862

        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.  */
863
            wld_mmap ((void *) (l->l_addr + c->mapstart),
864 865 866 867 868 869 870 871 872
                        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.  */
873
          l->l_phdr = (void *)(unsigned long)(c->mapstart + header->e_phoff - c->mapoff);
874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903

        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.  */
904
                    wld_mprotect ((caddr_t) (zero & ~page_mask), page_size, c->prot|PROT_WRITE);
905
                  }
906
                wld_memset ((void *) zero, '\0', zeropage - zero);
907
                if ((c->prot & PROT_WRITE) == 0)
908
                  wld_mprotect ((caddr_t) (zero & ~page_mask), page_size, c->prot);
909 910 911 912 913
              }

            if (zeroend > zeropage)
              {
                /* Map the remaining zero pages in from the zero fill FD.  */
914
                wld_mmap ((caddr_t) zeropage, zeroend - zeropage,
915 916 917 918 919 920 921 922 923 924 925 926 927
                                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;

928
    wld_close( fd );
929 930 931
}


932
static unsigned int wld_elf_hash( const char *name )
933 934 935 936 937 938 939 940 941 942 943 944
{
    unsigned int hi, hash = 0;
    while (*name)
    {
        hash = (hash << 4) + (unsigned char)*name++;
        hi = hash & 0xf0000000;
        hash ^= hi;
        hash ^= hi >> 24;
    }
    return hash;
}

945 946 947 948 949 950 951
static unsigned int gnu_hash( const char *name )
{
    unsigned int h = 5381;
    while (*name) h = h * 33 + (unsigned char)*name++;
    return h;
}

952 953 954
/*
 * Find a symbol in the symbol table of the executable loaded
 */
955
static void *find_symbol( const struct wld_link_map *map, const char *var, int type )
956 957 958 959
{
    const ElfW(Dyn) *dyn = NULL;
    const ElfW(Phdr) *ph;
    const ElfW(Sym) *symtab = NULL;
960
    const Elf32_Word *hashtab = NULL;
961
    const Elf32_Word *gnu_hashtab = NULL;
962
    const char *strings = NULL;
963
    Elf32_Word idx;
964 965 966

    /* check the values */
#ifdef DUMP_SYMS
967
    wld_printf("%p %x\n", map->l_phdr, map->l_phnum );
968 969
#endif
    /* parse the (already loaded) ELF executable's header */
970
    for (ph = map->l_phdr; ph < &map->l_phdr[map->l_phnum]; ++ph)
971 972 973
    {
        if( PT_DYNAMIC == ph->p_type )
        {
974
            dyn = (void *)(ph->p_vaddr + map->l_addr);
975 976 977 978 979 980 981 982
            break;
        }
    }
    if( !dyn ) return NULL;

    while( dyn->d_tag )
    {
        if( dyn->d_tag == DT_STRTAB )
983
            strings = (const char*)(dyn->d_un.d_ptr + map->l_addr);
984
        if( dyn->d_tag == DT_SYMTAB )
985
            symtab = (const ElfW(Sym) *)(dyn->d_un.d_ptr + map->l_addr);
986
        if( dyn->d_tag == DT_HASH )
987
            hashtab = (const Elf32_Word *)(dyn->d_un.d_ptr + map->l_addr);
988
        if( dyn->d_tag == DT_GNU_HASH )
989
            gnu_hashtab = (const Elf32_Word *)(dyn->d_un.d_ptr + map->l_addr);
990
#ifdef DUMP_SYMS
991
        wld_printf("%lx %p\n", (unsigned long)dyn->d_tag, (void *)dyn->d_un.d_ptr );
992 993 994 995 996 997
#endif
        dyn++;
    }

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

998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
    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) &&
1012 1013
                ELF32_ST_BIND(symtab[idx].st_info) == STB_GLOBAL &&
                ELF32_ST_TYPE(symtab[idx].st_info) == type &&
1014 1015 1016 1017 1018
                !wld_strcmp( strings + symtab[idx].st_name, var ))
                goto found;
        } while (!(chains[idx++] & 1u));
    }
    else if (hashtab)  /* old style hash table */
1019
    {
1020
        const unsigned int hash   = wld_elf_hash(var);
1021 1022 1023
        const Elf32_Word nbuckets = hashtab[0];
        const Elf32_Word *buckets = hashtab + 2;
        const Elf32_Word *chains  = buckets + nbuckets;
1024

1025
        for (idx = buckets[hash % nbuckets]; idx; idx = chains[idx])
1026
        {
1027 1028
            if (ELF32_ST_BIND(symtab[idx].st_info) == STB_GLOBAL &&
                ELF32_ST_TYPE(symtab[idx].st_info) == type &&
1029
                !wld_strcmp( strings + symtab[idx].st_name, var ))
1030
                goto found;
1031 1032 1033
        }
    }
    return NULL;
1034 1035 1036

found:
#ifdef DUMP_SYMS
1037
    wld_printf("Found %s -> %p\n", strings + symtab[idx].st_name, (void *)symtab[idx].st_value );
1038
#endif
1039
    return (void *)(symtab[idx].st_value + map->l_addr);
1040 1041
}

1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
/*
 *  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;
1052
    int i, first = 1;
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075

    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)
    {
1076
        wld_printf( "WINEPRELOADRESERVE range %p-%p overlaps preloader %p-%p\n",
1077 1078 1079 1080
                     start, end, preloader_start, preloader_end );
        start = end = NULL;
    }

1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
    /* 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;
    }
1093

1094 1095 1096
    while (preload_info[i].size) i++;
    preload_info[i].addr = start;
    preload_info[i].size = (char *)end - (char *)start;
1097 1098 1099 1100 1101 1102
    return;

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

1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127
/* 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++;
    }
}

1128 1129 1130 1131 1132
/*
 *  is_in_preload_range
 *
 * Check if address of the given aux value is in one of the reserved ranges
 */
1133
static int is_in_preload_range( const struct wld_auxv *av, int type )
1134
{
1135
    while (av->a_type != AT_NULL)
1136
    {
1137 1138
        if (av->a_type == type) return is_addr_reserved( (const void *)av->a_un.a_val );
        av++;
1139 1140 1141
    }
    return 0;
}
1142

1143 1144 1145
/* set the process name if supported */
static void set_process_name( int argc, char *argv[] )
{
1146 1147
    int i;
    unsigned int off;
1148 1149 1150 1151
    char *p, *name, *end;

    /* set the process short name */
    for (p = name = argv[1]; *p; p++) if (p[0] == '/' && p[1]) name = p + 1;
1152
    if (wld_prctl( 15 /* PR_SET_NAME */, (long)name ) == -1) return;
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163

    /* 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;
}


1164 1165 1166 1167 1168 1169 1170
/*
 *  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.
 */
1171
void* wld_start( void **stack )
1172
{
1173
    long i, *pargc;
1174
    char **argv, **p;
1175
    char *interp, *reserve = NULL;
1176
    struct wld_auxv new_av[12], delete_av[3], *av;
1177 1178 1179
    struct wld_link_map main_binary_map, ld_so_map;
    struct wine_preload_info **wine_main_preload_info;

1180 1181
    pargc = *stack;
    argv = (char **)pargc + 1;
1182
    if (*pargc < 2) fatal_error( "Usage: %s wine_binary [args]\n", argv[0] );
1183 1184

    /* skip over the parameters */
1185
    p = argv + *pargc + 1;
1186 1187

    /* skip over the environment */
1188 1189 1190
    while (*p)
    {
        static const char res[] = "WINEPRELOADRESERVE=";
1191
        if (!wld_strncmp( *p, res, sizeof(res)-1 )) reserve = *p + sizeof(res) - 1;
1192 1193
        p++;
    }
1194

1195
    av = (struct wld_auxv *)(p+1);
1196
    page_size = get_auxiliary( av, AT_PAGESZ, 4096 );
1197 1198
    page_mask = page_size - 1;

1199 1200
    preloader_start = (char *)_start - ((unsigned long)_start & page_mask);
    preloader_end = (char *)((unsigned long)(_end + page_mask) & ~page_mask);
1201

1202
#ifdef DUMP_AUX_INFO
1203
    wld_printf( "stack = %p\n", *stack );
1204
    for( i = 0; i < *pargc; i++ ) wld_printf("argv[%lx] = %s\n", i, argv[i]);
1205 1206 1207 1208
    dump_auxiliary( av );
#endif

    /* reserve memory that Wine needs */
1209
    if (reserve) preload_reserve( reserve );
1210
    for (i = 0; preload_info[i].size; i++)
1211
    {
1212 1213 1214 1215 1216 1217 1218 1219
        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)
1220
        {
1221 1222 1223 1224
            /* 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 );
1225 1226 1227 1228
            remove_preload_range( i );
            i--;
        }
    }
1229

1230 1231
    /* add an executable page at the top of the address space to defeat
     * broken no-exec protections that play with the code selector limit */
1232 1233
    if (is_addr_reserved( (char *)0x80000000 - page_size ))
        wld_mprotect( (char *)0x80000000 - page_size, page_size, PROT_EXEC | PROT_READ );
1234

1235
    /* load the main binary */
1236
    map_so_lib( argv[1], &main_binary_map );
1237 1238 1239 1240 1241 1242

    /* 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 */
1243
    wine_main_preload_info = find_symbol( &main_binary_map, "wine_main_preload_info", STT_OBJECT );
1244 1245 1246
    if (wine_main_preload_info) *wine_main_preload_info = preload_info;
    else wld_printf( "wine_main_preload_info not found\n" );

1247 1248 1249 1250 1251 1252 1253 1254
#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 );
1255 1256 1257 1258
    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() ) );
1259
    SET_NEW_AV(11, AT_NULL, 0 );
1260 1261
#undef SET_NEW_AV

1262 1263
    i = 0;
    /* delete sysinfo values if addresses conflict */
1264 1265 1266 1267 1268
    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;
    }
1269 1270
    delete_av[i].a_type = AT_NULL;

1271
    /* get rid of first argument */
1272
    set_process_name( *pargc, argv );
1273 1274 1275
    pargc[1] = pargc[0] - 1;
    *stack = pargc + 1;

1276
    set_auxiliary_values( av, new_av, delete_av, stack );
1277 1278

#ifdef DUMP_AUX_INFO
1279
    wld_printf("new stack = %p\n", *stack);
1280
    wld_printf("jumping to %p\n", (void *)ld_so_map.l_entry);
1281
#endif
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292
#ifdef DUMP_MAPS
    {
        char buffer[1024];
        int len, fd = wld_open( "/proc/self/maps", O_RDONLY );
        if (fd != -1)
        {
            while ((len = wld_read( fd, buffer, sizeof(buffer) )) > 0) wld_write( 2, buffer, len );
            wld_close( fd );
        }
    }
#endif
1293 1294 1295

    return (void *)ld_so_map.l_entry;
}