4 * Copyright (C) 1995,96,97,98,99,2000,2001,2002 Free Software Foundation, Inc.
5 * Copyright (C) 2004 Mike McCormack for CodeWeavers
6 * Copyright (C) 2004 Alexandre Julliard
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 * The goal of this program is to be a workaround for exec-shield, as used
27 * by the Linux kernel distributed with Fedora Core and other distros.
29 * To do this, we implement our own shared object loader that reserves memory
30 * that is important to Wine, and then loads the main binary and its ELF
33 * We will try to set up the stack and memory area so that the program that
34 * loads after us (eg. the wine binary) never knows we were here, except that
35 * areas of memory it needs are already magically reserved.
37 * The following memory areas are important to Wine:
38 * 0x00000000 - 0x00110000 the DOS area
39 * 0x80000000 - 0x81000000 the shared heap
40 * ??? - ??? the PE binary load address (usually starting at 0x00400000)
42 * If this program is used as the shared object loader, the only difference
43 * that the loaded programs should see is that this loader will be mapped
44 * into memory when it starts.
48 * References (things I consulted to understand how ELF loading works):
50 * glibc 2.3.2 elf/dl-load.c
51 * http://www.gnu.org/directory/glibc.html
53 * Linux 2.6.4 fs/binfmt_elf.c
54 * ftp://ftp.kernel.org/pub/linux/kernel/v2.6/linux-2.6.4.tar.bz2
56 * Userland exec, by <grugq@hcunix.net>
57 * http://cert.uni-stuttgart.de/archive/bugtraq/2004/01/msg00002.html
59 * The ELF specification:
60 * http://www.linuxbase.org/spec/booksets/LSB-Embedded/LSB-Embedded/book387.html
64 #include "wine/port.h"
70 #include <sys/types.h>
73 #ifdef HAVE_SYS_MMAN_H
74 # include <sys/mman.h>
76 #ifdef HAVE_SYS_SYSCALL_H
77 # include <sys/syscall.h>
88 #ifdef HAVE_SYS_LINK_H
89 # include <sys/link.h>
95 #define ELF_PREFERRED_ADDRESS(loader, maplength, mapstartpref) (mapstartpref)
96 #define ELF_FIXED_ADDRESS(loader, mapstart) ((void) 0)
98 #define MAP_BASE_ADDR(l) 0
101 #define MAP_COPY MAP_PRIVATE
103 #ifndef MAP_NORESERVE
104 #define MAP_NORESERVE 0
107 static struct wine_preload_info preload_info
[] =
109 { (void *)0x00000000, 0x00110000 }, /* DOS area */
110 { (void *)0x80000000, 0x01000000 }, /* shared heap */
111 { (void *)0x00110000, 0x0fef0000 }, /* default PE exe range (may be set with WINEPRELOADRESERVE) */
112 { 0, 0 } /* end of list */
120 /* older systems may not define these */
125 static unsigned int page_size
, page_mask
;
126 static char *preloader_start
, *preloader_end
;
128 struct wld_link_map
{
135 ElfW(Addr
) l_map_start
, l_map_end
;
141 * The _start function is the entry and exit point of this program
143 * It calls wld_start, passing a pointer to the args it receives
144 * then jumps to the address wld_start returns.
148 __ASM_GLOBAL_FUNC(_start
,
150 "\tleal -128(%esp),%esp\n" /* allocate some space for extra aux values */
151 "\tpushl %eax\n" /* orig stack pointer */
152 "\tpushl %esp\n" /* ptr to orig stack pointer */
154 "\tpopl %ecx\n" /* remove ptr to stack pointer */
155 "\tpopl %esp\n" /* new stack pointer */
156 "\tpush %eax\n" /* ELF interpreter entry point */
162 /* wrappers for Linux system calls */
164 #define SYSCALL_RET(ret) (((ret) < 0 && (ret) > -4096) ? -1 : (ret))
166 static inline __attribute__((noreturn
)) void wld_exit( int code
)
168 for (;;) /* avoid warning */
169 __asm__
__volatile__( "int $0x80" : : "a" (SYS_exit
), "b" (code
) );
172 static inline int wld_open( const char *name
, int flags
)
175 __asm__
__volatile__( "int $0x80" : "=a" (ret
) : "0" (SYS_open
), "b" (name
), "c" (flags
) );
176 return SYSCALL_RET(ret
);
179 static inline int wld_close( int fd
)
182 __asm__
__volatile__( "int $0x80" : "=a" (ret
) : "0" (SYS_close
), "b" (fd
) );
183 return SYSCALL_RET(ret
);
186 static inline ssize_t
wld_read( int fd
, void *buffer
, size_t len
)
189 __asm__
__volatile__( "int $0x80" : "=a" (ret
)
190 : "0" (SYS_read
), "b" (fd
), "c" (buffer
), "d" (len
)
192 return SYSCALL_RET(ret
);
195 static inline ssize_t
wld_write( int fd
, const void *buffer
, size_t len
)
198 __asm__
__volatile__( "int $0x80" : "=a" (ret
)
199 : "0" (SYS_write
), "b" (fd
), "c" (buffer
), "d" (len
) );
200 return SYSCALL_RET(ret
);
203 static inline int wld_mprotect( const void *addr
, size_t len
, int prot
)
206 __asm__
__volatile__( "int $0x80" : "=a" (ret
) : "0" (SYS_mprotect
), "b" (addr
), "c" (len
), "d" (prot
) );
207 return SYSCALL_RET(ret
);
210 static void *wld_mmap( void *start
, size_t len
, int prot
, int flags
, int fd
, off_t offset
)
229 args
.offset
= offset
;
230 __asm__
__volatile__( "int $0x80" : "=a" (ret
) : "0" (SYS_mmap
), "b" (&args
) : "memory" );
231 return (void *)SYSCALL_RET(ret
);
234 static inline uid_t
wld_getuid(void)
237 __asm__( "int $0x80" : "=a" (ret
) : "0" (SYS_getuid
) );
241 static inline uid_t
wld_geteuid(void)
244 __asm__( "int $0x80" : "=a" (ret
) : "0" (SYS_geteuid
) );
248 static inline gid_t
wld_getgid(void)
251 __asm__( "int $0x80" : "=a" (ret
) : "0" (SYS_getgid
) );
255 static inline gid_t
wld_getegid(void)
258 __asm__( "int $0x80" : "=a" (ret
) : "0" (SYS_getegid
) );
263 /* replacement for libc functions */
265 static int wld_strcmp( const char *str1
, const char *str2
)
267 while (*str1
&& (*str1
== *str2
)) { str1
++; str2
++; }
268 return *str1
- *str2
;
271 static int wld_strncmp( const char *str1
, const char *str2
, size_t len
)
273 if (len
<= 0) return 0;
274 while ((--len
> 0) && *str1
&& (*str1
== *str2
)) { str1
++; str2
++; }
275 return *str1
- *str2
;
278 static inline void *wld_memset( void *dest
, int val
, size_t len
)
281 while (len
--) *dst
++ = val
;
285 static inline void *wld_memmove( void *dest
, const void *src
, size_t len
)
291 if (d
< s
) for (i
= 0; i
< len
; i
++) d
[i
] = s
[i
];
292 else for (i
= len
- 1; i
>= 0; i
--) d
[i
] = s
[i
];
297 * wld_printf - just the basics
299 * %x prints a hex number
302 static void wld_vsprintf(char *str
, const char *fmt
, va_list args
)
304 static const char hex_chars
[16] = "0123456789abcdef";
315 unsigned int x
= va_arg( args
, unsigned int );
317 *str
++ = hex_chars
[(x
>>(i
*4))&0xf];
321 char *s
= va_arg( args
, char * );
334 static void wld_printf(const char *fmt
, ... )
339 va_start( args
, fmt
);
340 wld_vsprintf(buffer
, fmt
, args
);
342 wld_write(2, buffer
, strlen(buffer
));
345 static __attribute__((noreturn
)) void fatal_error(const char *fmt
, ... )
350 va_start( args
, fmt
);
351 wld_vsprintf(buffer
, fmt
, args
);
353 wld_write(2, buffer
, strlen(buffer
));
359 * Dump interesting bits of the ELF auxv_t structure that is passed
360 * as the 4th parameter to the _start function
362 static void dump_auxiliary( ElfW(auxv_t
) *av
)
364 #define NAME(at) { at, #at }
365 static const struct { int val
; const char *name
; } names
[] =
387 for ( ; av
->a_type
!= AT_NULL
; av
++)
389 for (i
= 0; names
[i
].name
; i
++) if (names
[i
].val
== av
->a_type
) break;
390 if (names
[i
].name
) wld_printf("%s = %x\n", names
[i
].name
, av
->a_un
.a_val
);
391 else wld_printf( "%x = %x\n", av
->a_type
, av
->a_un
.a_val
);
397 * set_auxiliary_values
399 * Set the new auxiliary values
401 static void set_auxiliary_values( ElfW(auxv_t
) *av
, const ElfW(auxv_t
) *new_av
, void **stack
)
403 int i
, j
, av_count
= 0, new_count
= 0;
405 /* count how many aux values we have already */
406 while (av
[av_count
].a_type
!= AT_NULL
) av_count
++;
408 /* count how many values we have in new_av that aren't in av */
409 for (j
= 0; new_av
[j
].a_type
!= AT_NULL
; j
++)
411 for (i
= 0; i
< av_count
; i
++) if (av
[i
].a_type
== new_av
[j
].a_type
) break;
412 if (i
== av_count
) new_count
++;
415 if (new_count
) /* need to make room for the extra values */
417 char *new_stack
= (char *)*stack
- new_count
* sizeof(*av
);
418 wld_memmove( new_stack
, *stack
, (char *)(av
+ av_count
) - (char *)*stack
);
423 /* now set the values */
424 for (j
= 0; new_av
[j
].a_type
!= AT_NULL
; j
++)
426 for (i
= 0; i
< av_count
; i
++) if (av
[i
].a_type
== new_av
[j
].a_type
) break;
427 if (i
< av_count
) av
[i
].a_un
.a_val
= new_av
[j
].a_un
.a_val
;
430 av
[av_count
].a_type
= new_av
[j
].a_type
;
431 av
[av_count
].a_un
.a_val
= new_av
[j
].a_un
.a_val
;
437 wld_printf("New auxiliary info:\n");
438 dump_auxiliary( av
);
445 * Get a field of the auxiliary structure
447 static int get_auxiliary( ElfW(auxv_t
) *av
, int type
, int def_val
)
449 for ( ; av
->a_type
!= AT_NULL
; av
++)
450 if( av
->a_type
== type
) return av
->a_un
.a_val
;
457 * modelled after _dl_map_object_from_fd() from glibc-2.3.1/elf/dl-load.c
459 * This function maps the segments from an ELF object, and optionally
460 * stores information about the mapping into the auxv_t structure.
462 static void map_so_lib( const char *name
, struct wld_link_map
*l
)
465 unsigned char buf
[0x800];
466 ElfW(Ehdr
) *header
= (ElfW(Ehdr
)*)buf
;
467 ElfW(Phdr
) *phdr
, *ph
;
468 /* Scan the program header table, collecting its load commands. */
471 ElfW(Addr
) mapstart
, mapend
, dataend
, allocend
;
475 size_t nloadcmds
= 0, maplength
;
477 fd
= wld_open( name
, O_RDONLY
);
478 if (fd
== -1) fatal_error("%s: could not open\n", name
);
480 if (wld_read( fd
, buf
, sizeof(buf
) ) != sizeof(buf
))
481 fatal_error("%s: failed to read ELF header\n", name
);
483 phdr
= (void*) (((unsigned char*)buf
) + header
->e_phoff
);
485 if( ( header
->e_ident
[0] != 0x7f ) ||
486 ( header
->e_ident
[1] != 'E' ) ||
487 ( header
->e_ident
[2] != 'L' ) ||
488 ( header
->e_ident
[3] != 'F' ) )
489 fatal_error( "%s: not an ELF binary... don't know how to load it\n", name
);
491 if( header
->e_machine
!= EM_386
)
492 fatal_error("%s: not an i386 ELF binary... don't know how to load it\n", name
);
494 if (header
->e_phnum
> sizeof(loadcmds
)/sizeof(loadcmds
[0]))
495 fatal_error( "%s: oops... not enough space for load commands\n", name
);
497 maplength
= header
->e_phnum
* sizeof (ElfW(Phdr
));
498 if (header
->e_phoff
+ maplength
> sizeof(buf
))
499 fatal_error( "%s: oops... not enough space for ELF headers\n", name
);
504 l
->l_phnum
= header
->e_phnum
;
505 l
->l_entry
= header
->e_entry
;
508 for (ph
= phdr
; ph
< &phdr
[l
->l_phnum
]; ++ph
)
512 wld_printf( "ph = %x\n", ph
);
513 wld_printf( " p_type = %x\n", ph
->p_type
);
514 wld_printf( " p_flags = %x\n", ph
->p_flags
);
515 wld_printf( " p_offset = %x\n", ph
->p_offset
);
516 wld_printf( " p_vaddr = %x\n", ph
->p_vaddr
);
517 wld_printf( " p_paddr = %x\n", ph
->p_paddr
);
518 wld_printf( " p_filesz = %x\n", ph
->p_filesz
);
519 wld_printf( " p_memsz = %x\n", ph
->p_memsz
);
520 wld_printf( " p_align = %x\n", ph
->p_align
);
525 /* These entries tell us where to find things once the file's
526 segments are mapped in. We record the addresses it says
527 verbatim, and later correct for the run-time load address. */
529 l
->l_ld
= (void *) ph
->p_vaddr
;
530 l
->l_ldnum
= ph
->p_memsz
/ sizeof (Elf32_Dyn
);
534 l
->l_phdr
= (void *) ph
->p_vaddr
;
539 if ((ph
->p_align
& page_mask
) != 0)
540 fatal_error( "%s: ELF load command alignment not page-aligned\n", name
);
542 if (((ph
->p_vaddr
- ph
->p_offset
) & (ph
->p_align
- 1)) != 0)
543 fatal_error( "%s: ELF load command address/offset not properly aligned\n", name
);
545 c
= &loadcmds
[nloadcmds
++];
546 c
->mapstart
= ph
->p_vaddr
& ~(ph
->p_align
- 1);
547 c
->mapend
= ((ph
->p_vaddr
+ ph
->p_filesz
+ page_mask
) & ~page_mask
);
548 c
->dataend
= ph
->p_vaddr
+ ph
->p_filesz
;
549 c
->allocend
= ph
->p_vaddr
+ ph
->p_memsz
;
550 c
->mapoff
= ph
->p_offset
& ~(ph
->p_align
- 1);
553 if (ph
->p_flags
& PF_R
)
554 c
->prot
|= PROT_READ
;
555 if (ph
->p_flags
& PF_W
)
556 c
->prot
|= PROT_WRITE
;
557 if (ph
->p_flags
& PF_X
)
558 c
->prot
|= PROT_EXEC
;
563 l
->l_interp
= ph
->p_vaddr
;
568 * We don't need to set anything up because we're
569 * emulating the kernel, not ld-linux.so.2
570 * The ELF loader will set up the TLS data itself.
579 /* Now process the load commands and map segments into memory. */
582 /* Length of the sections to be loaded. */
583 maplength
= loadcmds
[nloadcmds
- 1].allocend
- c
->mapstart
;
585 if( header
->e_type
== ET_DYN
)
588 mappref
= (ELF_PREFERRED_ADDRESS (loader
, maplength
, c
->mapstart
)
589 - MAP_BASE_ADDR (l
));
591 /* Remember which part of the address space this object uses. */
592 l
->l_map_start
= (ElfW(Addr
)) wld_mmap ((void *) mappref
, maplength
,
593 c
->prot
, MAP_COPY
| MAP_FILE
,
595 /* wld_printf("set : offset = %x\n", c->mapoff); */
596 /* wld_printf("l->l_map_start = %x\n", l->l_map_start); */
598 l
->l_map_end
= l
->l_map_start
+ maplength
;
599 l
->l_addr
= l
->l_map_start
- c
->mapstart
;
601 wld_mprotect ((caddr_t
) (l
->l_addr
+ c
->mapend
),
602 loadcmds
[nloadcmds
- 1].allocend
- c
->mapend
,
609 if ((char *)c
->mapstart
+ maplength
> preloader_start
&&
610 (char *)c
->mapstart
<= preloader_end
)
611 fatal_error( "%s: binary overlaps preloader (%x-%x)\n",
612 name
, c
->mapstart
, (char *)c
->mapstart
+ maplength
);
614 ELF_FIXED_ADDRESS (loader
, c
->mapstart
);
617 /* Remember which part of the address space this object uses. */
618 l
->l_map_start
= c
->mapstart
+ l
->l_addr
;
619 l
->l_map_end
= l
->l_map_start
+ maplength
;
621 while (c
< &loadcmds
[nloadcmds
])
623 if (c
->mapend
> c
->mapstart
)
624 /* Map the segment contents from the file. */
625 wld_mmap ((void *) (l
->l_addr
+ c
->mapstart
),
626 c
->mapend
- c
->mapstart
, c
->prot
,
627 MAP_FIXED
| MAP_COPY
| MAP_FILE
, fd
, c
->mapoff
);
631 && (ElfW(Off
)) c
->mapoff
<= header
->e_phoff
632 && ((size_t) (c
->mapend
- c
->mapstart
+ c
->mapoff
)
633 >= header
->e_phoff
+ header
->e_phnum
* sizeof (ElfW(Phdr
))))
634 /* Found the program header in this segment. */
635 l
->l_phdr
= (void *)(unsigned int) (c
->mapstart
+ header
->e_phoff
- c
->mapoff
);
637 if (c
->allocend
> c
->dataend
)
639 /* Extra zero pages should appear at the end of this segment,
640 after the data mapped from the file. */
641 ElfW(Addr
) zero
, zeroend
, zeropage
;
643 zero
= l
->l_addr
+ c
->dataend
;
644 zeroend
= l
->l_addr
+ c
->allocend
;
645 zeropage
= (zero
+ page_mask
) & ~page_mask
;
648 * This is different from the dl-load load...
649 * ld-linux.so.2 relies on the whole page being zero'ed
651 zeroend
= (zeroend
+ page_mask
) & ~page_mask
;
653 if (zeroend
< zeropage
)
655 /* All the extra data is in the last page of the segment.
656 We can just zero it. */
662 /* Zero the final part of the last page of the segment. */
663 if ((c
->prot
& PROT_WRITE
) == 0)
666 wld_mprotect ((caddr_t
) (zero
& ~page_mask
), page_size
, c
->prot
|PROT_WRITE
);
668 wld_memset ((void *) zero
, '\0', zeropage
- zero
);
669 if ((c
->prot
& PROT_WRITE
) == 0)
670 wld_mprotect ((caddr_t
) (zero
& ~page_mask
), page_size
, c
->prot
);
673 if (zeroend
> zeropage
)
675 /* Map the remaining zero pages in from the zero fill FD. */
677 mapat
= wld_mmap ((caddr_t
) zeropage
, zeroend
- zeropage
,
678 c
->prot
, MAP_ANON
|MAP_PRIVATE
|MAP_FIXED
,
686 if (l
->l_phdr
== NULL
) fatal_error("no program header\n");
688 l
->l_phdr
= (void *)((ElfW(Addr
))l
->l_phdr
+ l
->l_addr
);
689 l
->l_entry
+= l
->l_addr
;
696 * Find a symbol in the symbol table of the executable loaded
698 static void *find_symbol( const ElfW(Phdr
) *phdr
, int num
, char *var
)
700 const ElfW(Dyn
) *dyn
= NULL
;
701 const ElfW(Phdr
) *ph
;
702 const ElfW(Sym
) *symtab
= NULL
;
703 const char *strings
= NULL
;
704 uint32_t i
, symtabend
= 0;
706 /* check the values */
708 wld_printf("%x %x\n", phdr
, num
);
710 if( ( phdr
== NULL
) || ( num
== 0 ) )
712 wld_printf("could not find PT_DYNAMIC header entry\n");
716 /* parse the (already loaded) ELF executable's header */
717 for (ph
= phdr
; ph
< &phdr
[num
]; ++ph
)
719 if( PT_DYNAMIC
== ph
->p_type
)
721 dyn
= (void *) ph
->p_vaddr
;
722 num
= ph
->p_memsz
/ sizeof (Elf32_Dyn
);
726 if( !dyn
) return NULL
;
730 if( dyn
->d_tag
== DT_STRTAB
)
731 strings
= (const char*) dyn
->d_un
.d_ptr
;
732 if( dyn
->d_tag
== DT_SYMTAB
)
733 symtab
= (const ElfW(Sym
) *)dyn
->d_un
.d_ptr
;
734 if( dyn
->d_tag
== DT_HASH
)
735 symtabend
= *((const uint32_t *)dyn
->d_un
.d_ptr
+ 1);
737 wld_printf("%x %x\n", dyn
->d_tag
, dyn
->d_un
.d_ptr
);
742 if( (!symtab
) || (!strings
) ) return NULL
;
744 for (i
= 0; i
< symtabend
; i
++)
746 if( ( ELF32_ST_BIND(symtab
[i
].st_info
) == STT_OBJECT
) &&
747 ( 0 == wld_strcmp( strings
+symtab
[i
].st_name
, var
) ) )
750 wld_printf("Found %s -> %x\n", strings
+symtab
[i
].st_name
, symtab
[i
].st_value
);
752 return (void*)symtab
[i
].st_value
;
761 * Reserve a range specified in string format
763 static void preload_reserve( const char *str
)
766 unsigned long result
= 0;
767 void *start
= NULL
, *end
= NULL
;
770 for (p
= str
; *p
; p
++)
772 if (*p
>= '0' && *p
<= '9') result
= result
* 16 + *p
- '0';
773 else if (*p
>= 'a' && *p
<= 'f') result
= result
* 16 + *p
- 'a' + 10;
774 else if (*p
>= 'A' && *p
<= 'F') result
= result
* 16 + *p
- 'A' + 10;
777 if (!first
) goto error
;
778 start
= (void *)(result
& ~page_mask
);
784 if (!first
) end
= (void *)((result
+ page_mask
) & ~page_mask
);
785 else if (result
) goto error
; /* single value '0' is allowed */
788 if (end
<= start
) start
= end
= NULL
;
789 else if ((char *)end
> preloader_start
&&
790 (char *)start
<= preloader_end
)
792 wld_printf( "WINEPRELOADRESERVE range %x-%x overlaps preloader %x-%x\n",
793 start
, end
, preloader_start
, preloader_end
);
797 /* entry 2 is for the PE exe */
798 preload_info
[2].addr
= start
;
799 preload_info
[2].size
= (char *)end
- (char *)start
;
803 fatal_error( "invalid WINEPRELOADRESERVE value '%s'\n", str
);
810 * Repeat the actions the kernel would do when loading a dynamically linked .so
811 * Load the binary and then its ELF interpreter.
812 * Note, we assume that the binary is a dynamically linked ELF shared object.
814 void* wld_start( void **stack
)
818 char *interp
, *reserve
= NULL
;
819 ElfW(auxv_t
) new_av
[11], *av
;
820 struct wld_link_map main_binary_map
, ld_so_map
;
821 struct wine_preload_info
**wine_main_preload_info
;
824 argv
= (char **)pargc
+ 1;
825 if (*pargc
< 2) fatal_error( "Usage: %s wine_binary [args]\n", argv
[0] );
827 /* skip over the parameters */
828 p
= argv
+ *pargc
+ 1;
830 /* skip over the environment */
833 static const char res
[] = "WINEPRELOADRESERVE=";
834 if (!wld_strncmp( *p
, res
, sizeof(res
)-1 )) reserve
= *p
+ sizeof(res
) - 1;
838 av
= (ElfW(auxv_t
)*) (p
+1);
839 page_size
= get_auxiliary( av
, AT_PAGESZ
, 4096 );
840 page_mask
= page_size
- 1;
842 preloader_start
= (char *)_start
- ((unsigned int)_start
& page_mask
);
843 preloader_end
= (char *)((unsigned int)(_end
+ page_mask
) & ~page_mask
);
846 wld_printf( "stack = %x\n", *stack
);
847 for( i
= 0; i
< *pargc
; i
++ ) wld_printf("argv[%x] = %s\n", i
, argv
[i
]);
848 dump_auxiliary( av
);
851 /* reserve memory that Wine needs */
852 if (reserve
) preload_reserve( reserve
);
853 for (i
= 0; preload_info
[i
].size
; i
++)
854 wld_mmap( preload_info
[i
].addr
, preload_info
[i
].size
,
855 PROT_NONE
, MAP_FIXED
| MAP_PRIVATE
| MAP_ANON
| MAP_NORESERVE
, -1, 0 );
857 /* load the main binary */
858 map_so_lib( argv
[1], &main_binary_map
);
860 /* load the ELF interpreter */
861 interp
= (char *)main_binary_map
.l_addr
+ main_binary_map
.l_interp
;
862 map_so_lib( interp
, &ld_so_map
);
864 /* store pointer to the preload info into the appropriate main binary variable */
865 wine_main_preload_info
= find_symbol( main_binary_map
.l_phdr
, main_binary_map
.l_phnum
,
866 "wine_main_preload_info" );
867 if (wine_main_preload_info
) *wine_main_preload_info
= preload_info
;
868 else wld_printf( "wine_main_preload_info not found\n" );
870 #define SET_NEW_AV(n,type,val) new_av[n].a_type = (type); new_av[n].a_un.a_val = (val);
871 SET_NEW_AV( 0, AT_PHDR
, (unsigned long)main_binary_map
.l_phdr
);
872 SET_NEW_AV( 1, AT_PHENT
, sizeof(ElfW(Phdr
)) );
873 SET_NEW_AV( 2, AT_PHNUM
, main_binary_map
.l_phnum
);
874 SET_NEW_AV( 3, AT_PAGESZ
, page_size
);
875 SET_NEW_AV( 4, AT_BASE
, ld_so_map
.l_addr
);
876 SET_NEW_AV( 5, AT_FLAGS
, get_auxiliary( av
, AT_FLAGS
, 0 ) );
877 SET_NEW_AV( 6, AT_ENTRY
, main_binary_map
.l_entry
);
878 SET_NEW_AV( 7, AT_UID
, get_auxiliary( av
, AT_UID
, wld_getuid() ) );
879 SET_NEW_AV( 8, AT_EUID
, get_auxiliary( av
, AT_EUID
, wld_geteuid() ) );
880 SET_NEW_AV( 9, AT_GID
, get_auxiliary( av
, AT_GID
, wld_getgid() ) );
881 SET_NEW_AV(10, AT_EGID
, get_auxiliary( av
, AT_EGID
, wld_getegid() ) );
884 /* get rid of first argument */
885 pargc
[1] = pargc
[0] - 1;
888 set_auxiliary_values( av
, new_av
, stack
);
891 wld_printf("new stack = %x\n", *stack
);
892 wld_printf("jumping to %x\n", ld_so_map
.l_entry
);
895 return (void *)ld_so_map
.l_entry
;