1 /* Initialization code run first thing by the ELF startup code. For i386/Hurd.
2 Copyright (C) 1995-2015 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
26 #include <set-hooks.h>
27 #include "hurdstartup.h"
28 #include "hurdmalloc.h" /* XXX */
29 #include "../locale/localeinfo.h"
32 #include <fpu_control.h>
34 extern void __mach_init (void);
35 extern void __init_misc (int, char **, char **);
36 #ifdef USE_NONOPTION_FLAGS
37 extern void __getopt_clean_environment (char **);
39 extern void __libc_global_ctors (void);
41 unsigned int __hurd_threadvar_max
;
42 unsigned long int __hurd_threadvar_stack_offset
;
43 unsigned long int __hurd_threadvar_stack_mask
;
46 int __libc_enable_secure
;
48 int __libc_multiple_libcs attribute_hidden
= 1;
50 extern int __libc_argc attribute_hidden
;
51 extern char **__libc_argv attribute_hidden
;
52 extern char **_dl_argv
;
54 extern void *(*_cthread_init_routine
) (void) __attribute__ ((weak
));
55 void (*_cthread_exit_routine
) (int status
) __attribute__ ((__noreturn__
));
57 /* Things that want to be run before _hurd_init or much anything else.
58 Importantly, these are called before anything tries to use malloc. */
59 DEFINE_HOOK (_hurd_preinit_hook
, (void));
62 /* We call this once the Hurd magic is all set up and we are ready to be a
63 Posixoid program. This does the same things the generic version does. */
65 posixland_init (int argc
, char **argv
, char **envp
)
67 __libc_multiple_libcs
= &_dl_starting_up
&& !_dl_starting_up
;
69 /* Make sure we don't initialize twice. */
70 if (!__libc_multiple_libcs
)
72 /* Set the FPU control word to the proper default value. */
73 __setfpucw (__fpu_control
);
77 /* Initialize data structures so the additional libc can do RPCs. */
81 /* Save the command-line arguments. */
87 _dl_non_dynamic_init ();
89 __init_misc (argc
, argv
, envp
);
91 #ifdef USE_NONOPTION_FLAGS
92 /* This is a hack to make the special getopt in GNU libc working. */
93 __getopt_clean_environment (envp
);
96 /* Initialize ctype data. */
99 #if defined SHARED && !defined NO_CTORS_DTORS_SECTIONS
100 __libc_global_ctors ();
106 init1 (int argc
, char *arg0
, ...)
109 char **envp
= &argv
[argc
+ 1];
110 struct hurd_startup_data
*d
;
116 /* If we are the bootstrap task started by the kernel,
117 then after the environment pointers there is no Hurd
118 data block; the argument strings start there. */
119 if ((void *) d
== argv
[0])
122 /* With a new enough linker (binutils-2.23 or better),
123 the magic __ehdr_start symbol will be available and
124 __libc_start_main will have done this that way already. */
125 if (_dl_phdr
== NULL
)
127 /* We may need to see our own phdrs, e.g. for TLS setup.
128 Try the usual kludge to find the headers without help from
130 extern const void __executable_start
;
131 const ElfW(Ehdr
) *const ehdr
= &__executable_start
;
132 _dl_phdr
= (const void *) ehdr
+ ehdr
->e_phoff
;
133 _dl_phnum
= ehdr
->e_phnum
;
134 assert (ehdr
->e_phentsize
== sizeof (ElfW(Phdr
)));
141 __libc_enable_secure
= d
->flags
& EXEC_SECURE
;
143 _dl_phdr
= (ElfW(Phdr
) *) d
->phdr
;
144 _dl_phnum
= d
->phdrsz
/ sizeof (ElfW(Phdr
));
145 assert (d
->phdrsz
% sizeof (ElfW(Phdr
)) == 0);
148 _hurd_init_dtable
= d
->dtable
;
149 _hurd_init_dtablesize
= d
->dtablesize
;
152 /* Check if the stack we are now on is different from
153 the one described by _hurd_stack_{base,size}. */
156 const vm_address_t newsp
= (vm_address_t
) &dummy
;
158 if (d
->stack_size
!= 0 && (newsp
< d
->stack_base
||
159 newsp
- d
->stack_base
> d
->stack_size
))
160 /* The new stack pointer does not intersect with the
161 stack the exec server set up for us, so free that stack. */
162 __vm_deallocate (__mach_task_self (), d
->stack_base
, d
->stack_size
);
165 if (d
->portarray
|| d
->intarray
)
166 /* Initialize library data structures, start signal processing, etc. */
167 _hurd_init (d
->flags
, argv
,
168 d
->portarray
, d
->portarraysize
,
169 d
->intarray
, d
->intarraysize
);
177 char **argv
= (void *) (data
+ 1);
178 char **envp
= &argv
[argc
+ 1];
179 struct hurd_startup_data
*d
;
180 unsigned long int threadvars
[_HURD_THREADVAR_MAX
];
182 /* Provide temporary storage for thread-specific variables on the
183 startup stack so the cthreads initialization code can use them
184 for malloc et al, or so we can use malloc below for the real
186 memset (threadvars
, 0, sizeof threadvars
);
187 threadvars
[_HURD_THREADVAR_LOCALE
] = (unsigned long int) &_nl_global_locale
;
188 __hurd_threadvar_stack_offset
= (unsigned long int) threadvars
;
190 /* Since the cthreads initialization code uses malloc, and the
191 malloc initialization code needs to get at the environment, make
192 sure we can find it. We'll need to do this again later on since
193 switching stacks changes the location where the environment is
201 /* The user might have defined a value for this, to get more variables.
202 Otherwise it will be zero on startup. We must make sure it is set
203 properly before before cthreads initialization, so cthreads can know
204 how much space to leave for thread variables. */
205 if (__hurd_threadvar_max
< _HURD_THREADVAR_MAX
)
206 __hurd_threadvar_max
= _HURD_THREADVAR_MAX
;
209 /* After possibly switching stacks, call `init1' (above) with the user
210 code as the return address, and the argument data immediately above
211 that on the stack. */
213 if (&_cthread_init_routine
&& _cthread_init_routine
)
215 /* Initialize cthreads, which will allocate us a new stack to run on. */
216 int *newsp
= (*_cthread_init_routine
) ();
217 struct hurd_startup_data
*od
;
219 void switch_stacks (void);
221 __libc_stack_end
= newsp
;
223 /* Copy per-thread variables from that temporary
224 area onto the new cthread stack. */
225 memcpy (__hurd_threadvar_location_from_sp (0, newsp
),
226 threadvars
, sizeof threadvars
);
228 /* Copy the argdata from the old stack to the new one. */
229 newsp
= memcpy (newsp
- ((char *) &d
[1] - (char *) data
), data
,
230 (char *) d
- (char *) data
);
233 /* And readjust the dynamic linker's idea of where the argument
235 assert (_dl_argv
== argv
);
236 _dl_argv
= (void *) (newsp
+ 1);
239 /* Set up the Hurd startup data block immediately following
240 the argument and environment pointers on the new stack. */
241 od
= ((void *) newsp
+ ((char *) d
- (char *) data
));
242 if ((void *) argv
[0] == d
)
243 /* We were started up by the kernel with arguments on the stack.
244 There is no Hurd startup data, so zero the block. */
245 memset (od
, 0, sizeof *od
);
247 /* Copy the Hurd startup data block to the new stack. */
250 /* Push the user code address on the top of the new stack. It will
251 be the return address for `init1'; we will jump there with NEWSP
252 as the stack pointer. */
253 /* The following expression would typically be written as
254 ``__builtin_return_address (0)''. But, for example, GCC 4.4.6 doesn't
255 recognize that this read operation may alias the following write
256 operation, and thus is free to reorder the two, clobbering the
257 original return address. */
258 *--newsp
= *((int *) __builtin_frame_address (0) + 1);
259 /* GCC 4.4.6 also wants us to force loading *NEWSP already here. */
260 asm volatile ("# %0" : : "X" (*newsp
));
261 *((void **) __builtin_frame_address (0) + 1) = &switch_stacks
;
262 /* Force NEWSP into %eax and &init1 into %ecx, which are not restored
263 by function return. */
264 asm volatile ("# a %0 c %1" : : "a" (newsp
), "c" (&init1
));
268 /* We are not using cthreads, so we will have just a single allocated
269 area for the per-thread variables of the main user thread. */
270 unsigned long int *array
;
274 void call_init1 (void);
276 array
= malloc (__hurd_threadvar_max
* sizeof (unsigned long int));
278 __libc_fatal ("Can't allocate single-threaded thread variables.");
280 /* Copy per-thread variables from the temporary array into the
281 newly malloc'd space. */
282 memcpy (array
, threadvars
, sizeof threadvars
);
283 __hurd_threadvar_stack_offset
= (unsigned long int) array
;
284 for (i
= _HURD_THREADVAR_MAX
; i
< __hurd_threadvar_max
; ++i
)
287 /* The argument data is just above the stack frame we will unwind by
288 returning. Mutate our own return address to run the code below. */
289 /* The following expression would typically be written as
290 ``__builtin_return_address (0)''. But, for example, GCC 4.4.6 doesn't
291 recognize that this read operation may alias the following write
292 operation, and thus is free to reorder the two, clobbering the
293 original return address. */
294 usercode
= *((int *) __builtin_frame_address (0) + 1);
295 /* GCC 4.4.6 also wants us to force loading USERCODE already here. */
296 asm volatile ("# %0" : : "X" (usercode
));
297 *((void **) __builtin_frame_address (0) + 1) = &call_init1
;
298 /* Force USERCODE into %eax and &init1 into %ecx, which are not
299 restored by function return. */
300 asm volatile ("# a %0 c %1" : : "a" (usercode
), "c" (&init1
));
304 /* These bits of inline assembler used to be located inside `init'.
305 However they were optimized away by gcc 2.95. */
307 /* The return address of `init' above, was redirected to here, so at
308 this point our stack is unwound and callers' registers restored.
309 Only %ecx and %eax are call-clobbered and thus still have the
310 values we set just above. Fetch from there the new stack pointer
311 we will run on, and jmp to the run-time address of `init1'; when it
312 returns, it will run the user code with the argument data at the
314 asm ("switch_stacks:\n"
318 /* As in the stack-switching case, at this point our stack is unwound
319 and callers' registers restored, and only %ecx and %eax communicate
320 values from the lines above. In this case we have stashed in %eax
321 the user code return address. Push it on the top of the stack so
322 it acts as init1's return address, and then jump there. */
328 /* Do the first essential initializations that must precede all else. */
332 /* Initialize data structures so we can do RPCs. */
335 RUN_HOOK (_hurd_preinit_hook
, ());
339 /* This function is called specially by the dynamic linker to do early
340 initialization of the shared C library before normal initializers
341 expecting a Posixoid environment can run. It gets called with the
342 stack set up just as the user will see it, so it can switch stacks. */
345 _dl_init_first (int argc
, ...)
349 /* If we use ``__builtin_frame_address (0) + 2'' here, GCC gets confused. */
356 /* The regular posixland initialization is what goes into libc's
357 normal initializer. */
358 /* NOTE! The linker notices the magical name `_init' and sets the DT_INIT
359 pointer in the dynamic section based solely on that. It is convention
360 for this function to be in the `.init' section, but the symbol name is
361 the only thing that really matters!! */
362 strong_alias (posixland_init
, _init
);
365 __libc_init_first (int argc
, char **argv
, char **envp
)
367 /* Everything was done in the shared library initializer, _init. */
370 strong_alias (posixland_init
, __libc_init_first
);
373 /* XXX This is all a crock and I am not happy with it.
374 This poorly-named function is called by static-start.S,
375 which should not exist at all. */
377 _hurd_stack_setup (void)
379 intptr_t caller
= (intptr_t) __builtin_return_address (0);
381 void doinit (intptr_t *data
)
383 /* This function gets called with the argument data at TOS. */
384 void doinit1 (int argc
, ...)
386 /* If we use ``__builtin_frame_address (0) + 2'' here, GCC gets
388 init ((int *) &argc
);
391 /* Push the user return address after the argument data, and then
392 jump to `doinit1' (above), so it is as if __libc_init_first's
393 caller had called `doinit1' with the argument data already on the
396 asm volatile ("movl %0, %%esp\n" /* Switch to new outermost stack. */
397 "movl $0, %%ebp\n" /* Clear outermost frame pointer. */
398 "jmp *%1" : : "r" (data
), "r" (&doinit1
) : "sp");
404 _hurd_startup ((void **) __builtin_frame_address (0) + 2, &doinit
);
409 /* This function is defined here so that if this file ever gets into
410 ld.so we will get a link error. Having this file silently included
411 in ld.so causes disaster, because the _init definition above will
412 cause ld.so to gain an init function, which is not a cool thing. */