.
[kopensolaris-gnu/glibc.git] / csu / libc-start.c
1 /* Copyright (C) 1998-2003, 2004, 2005 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3
4    The GNU C Library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU Lesser General Public
6    License as published by the Free Software Foundation; either
7    version 2.1 of the License, or (at your option) any later version.
8
9    The GNU C Library is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Lesser General Public License for more details.
13
14    You should have received a copy of the GNU Lesser General Public
15    License along with the GNU C Library; if not, write to the Free
16    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
17    02111-1307 USA.  */
18
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include <unistd.h>
22 #include <ldsodefs.h>
23 #include <bp-start.h>
24 #include <bp-sym.h>
25
26 extern void __libc_init_first (int argc, char **argv, char **envp);
27
28 extern int __libc_multiple_libcs;
29
30 #include <tls.h>
31 #ifndef SHARED
32 # include <dl-osinfo.h>
33 extern void __pthread_initialize_minimal (void)
34 # if !(USE_TLS - 0) && !defined NONTLS_INIT_TP
35      __attribute__ ((weak))
36 # endif
37      ;
38 # ifndef THREAD_SET_STACK_GUARD
39 /* Only exported for architectures that don't store the stack guard canary
40    in thread local area.  */
41 uintptr_t __stack_chk_guard attribute_relro;
42 # endif
43 #endif
44
45 #ifdef HAVE_PTR_NTHREADS
46 /* We need atomic operations.  */
47 # include <atomic.h>
48 #endif
49
50
51 #ifdef LIBC_START_MAIN
52 # ifdef LIBC_START_DISABLE_INLINE
53 #  define STATIC static
54 # else
55 #  define STATIC static inline __attribute__ ((always_inline))
56 # endif
57 #else
58 # define STATIC
59 # define LIBC_START_MAIN BP_SYM (__libc_start_main)
60 #endif
61
62 #ifdef MAIN_AUXVEC_ARG
63 /* main gets passed a pointer to the auxiliary.  */
64 # define MAIN_AUXVEC_DECL       , void *
65 # define MAIN_AUXVEC_PARAM      , auxvec
66 #else
67 # define MAIN_AUXVEC_DECL
68 # define MAIN_AUXVEC_PARAM
69 #endif
70
71 STATIC int LIBC_START_MAIN (int (*main) (int, char **, char **
72                                          MAIN_AUXVEC_DECL),
73                             int argc,
74                             char *__unbounded *__unbounded ubp_av,
75 #ifdef LIBC_START_MAIN_AUXVEC_ARG
76                             ElfW(auxv_t) *__unbounded auxvec,
77 #endif
78                             __typeof (main) init,
79                             void (*fini) (void),
80                             void (*rtld_fini) (void),
81                             void *__unbounded stack_end)
82      __attribute__ ((noreturn));
83
84
85 /* Note: the fini parameter is ignored here for shared library.  It
86    is registered with __cxa_atexit.  This had the disadvantage that
87    finalizers were called in more than one place.  */
88 STATIC int
89 LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),
90                  int argc, char *__unbounded *__unbounded ubp_av,
91 #ifdef LIBC_START_MAIN_AUXVEC_ARG
92                  ElfW(auxv_t) *__unbounded auxvec,
93 #endif
94                  __typeof (main) init,
95                  void (*fini) (void),
96                  void (*rtld_fini) (void), void *__unbounded stack_end)
97 {
98 #if __BOUNDED_POINTERS__
99   char **argv;
100 #else
101 # define argv ubp_av
102 #endif
103
104   /* Result of the 'main' function.  */
105   int result;
106
107   __libc_multiple_libcs = &_dl_starting_up && !_dl_starting_up;
108
109 #ifndef SHARED
110   char *__unbounded *__unbounded ubp_ev = &ubp_av[argc + 1];
111
112   INIT_ARGV_and_ENVIRON;
113
114   /* Store the lowest stack address.  This is done in ld.so if this is
115      the code for the DSO.  */
116   __libc_stack_end = stack_end;
117
118 # ifdef HAVE_AUX_VECTOR
119   /* First process the auxiliary vector since we need to find the
120      program header to locate an eventually present PT_TLS entry.  */
121 #  ifndef LIBC_START_MAIN_AUXVEC_ARG
122   ElfW(auxv_t) *__unbounded auxvec;
123   {
124     char *__unbounded *__unbounded evp = ubp_ev;
125     while (*evp++ != NULL)
126       ;
127     auxvec = (ElfW(auxv_t) *__unbounded) evp;
128   }
129 #  endif
130   _dl_aux_init (auxvec);
131 # endif
132 # ifdef DL_SYSDEP_OSCHECK
133   if (!__libc_multiple_libcs)
134     {
135       /* This needs to run to initiliaze _dl_osversion before TLS
136          setup might check it.  */
137       DL_SYSDEP_OSCHECK (__libc_fatal);
138     }
139 # endif
140
141   /* Initialize the thread library at least a bit since the libgcc
142      functions are using thread functions if these are available and
143      we need to setup errno.  If there is no thread library and we
144      handle TLS the function is defined in the libc to initialized the
145      TLS handling.  */
146 # if !(USE_TLS - 0) && !defined NONTLS_INIT_TP
147   if (__pthread_initialize_minimal)
148 # endif
149     __pthread_initialize_minimal ();
150 #endif
151
152 # ifndef SHARED
153   /* Set up the stack checker's canary.  */
154   uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard ();
155 #  ifdef THREAD_SET_STACK_GUARD
156   THREAD_SET_STACK_GUARD (stack_chk_guard);
157 #  else
158   __stack_chk_guard = stack_chk_guard;
159 #  endif
160 #endif
161
162   /* Register the destructor of the dynamic linker if there is any.  */
163   if (__builtin_expect (rtld_fini != NULL, 1))
164     __cxa_atexit ((void (*) (void *)) rtld_fini, NULL, NULL);
165
166 #ifndef SHARED
167   /* Call the initializer of the libc.  This is only needed here if we
168      are compiling for the static library in which case we haven't
169      run the constructors in `_dl_start_user'.  */
170   __libc_init_first (argc, argv, __environ);
171
172   /* Register the destructor of the program, if any.  */
173   if (fini)
174     __cxa_atexit ((void (*) (void *)) fini, NULL, NULL);
175
176   /* Some security at this point.  Prevent starting a SUID binary where
177      the standard file descriptors are not opened.  We have to do this
178      only for statically linked applications since otherwise the dynamic
179      loader did the work already.  */
180   if (__builtin_expect (__libc_enable_secure, 0))
181     __libc_check_standard_fds ();
182 #endif
183
184   /* Call the initializer of the program, if any.  */
185 #ifdef SHARED
186   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
187     GLRO(dl_debug_printf) ("\ninitialize program: %s\n\n", argv[0]);
188 #endif
189   if (init)
190     (*init) (argc, argv, __environ MAIN_AUXVEC_PARAM);
191
192 #ifdef SHARED
193   /* Auditing checkpoint: we have a new object.  */
194   if (__builtin_expect (GLRO(dl_naudit) > 0, 0))
195     {
196       struct audit_ifaces *afct = GLRO(dl_audit);
197       struct link_map *head = GL(dl_ns)[LM_ID_BASE]._ns_loaded;
198       for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
199         {
200           if (afct->preinit != NULL)
201             afct->preinit (&head->l_audit[cnt].cookie);
202
203           afct = afct->next;
204         }
205     }
206 #endif
207
208 #ifdef SHARED
209   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
210     GLRO(dl_debug_printf) ("\ntransferring control: %s\n\n", argv[0]);
211 #endif
212
213 #ifdef HAVE_CLEANUP_JMP_BUF
214   /* Memory for the cancellation buffer.  */
215   struct pthread_unwind_buf unwind_buf;
216
217   int not_first_call;
218   not_first_call = setjmp ((struct __jmp_buf_tag *) unwind_buf.cancel_jmp_buf);
219   if (__builtin_expect (! not_first_call, 1))
220     {
221       struct pthread *self = THREAD_SELF;
222
223       /* Store old info.  */
224       unwind_buf.priv.data.prev = THREAD_GETMEM (self, cleanup_jmp_buf);
225       unwind_buf.priv.data.cleanup = THREAD_GETMEM (self, cleanup);
226
227       /* Store the new cleanup handler info.  */
228       THREAD_SETMEM (self, cleanup_jmp_buf, &unwind_buf);
229
230       /* Run the program.  */
231       result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);
232     }
233   else
234     {
235       /* Remove the thread-local data.  */
236 # ifdef SHARED
237       __libc_pthread_functions.ptr__nptl_deallocate_tsd ();
238 # else
239       extern void __nptl_deallocate_tsd (void) __attribute ((weak));
240       __nptl_deallocate_tsd ();
241 # endif
242
243       /* One less thread.  Decrement the counter.  If it is zero we
244          terminate the entire process.  */
245       result = 0;
246 # ifdef SHARED
247       unsigned int *const ptr = __libc_pthread_functions.ptr_nthreads;
248 # else
249       extern unsigned int __nptl_nthreads __attribute ((weak));
250       unsigned int *const ptr = &__nptl_nthreads;
251 # endif
252
253       if (! atomic_decrement_and_test (ptr))
254         /* Not much left to do but to exit the thread, not the process.  */
255         __exit_thread (0);
256     }
257 #else
258   /* Nothing fancy, just call the function.  */
259   result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);
260 #endif
261
262   exit (result);
263 }