__uClibc_main.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462
  1. /*
  2. * Copyright (C) 2006 by Steven J. Hill <sjhill@realitydiluted.com>
  3. * Copyright (C) 2001 by Manuel Novoa III <mjn3@uclibc.org>
  4. * Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org>
  5. *
  6. * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
  7. *
  8. * __uClibc_main is the routine to be called by all the arch-specific
  9. * versions of crt1.S in uClibc.
  10. *
  11. * It is meant to handle any special initialization needed by the library
  12. * such as setting the global variable(s) __environ (environ) and
  13. * initializing the stdio package. Using weak symbols, the latter is
  14. * avoided in the static library case.
  15. */
  16. #include <features.h>
  17. #ifndef __UCLIBC_HAS_THREADS_NATIVE__
  18. #define _ERRNO_H
  19. #endif
  20. #include <unistd.h>
  21. #include <stdlib.h>
  22. #include <string.h>
  23. #include <elf.h>
  24. #include <link.h>
  25. #include <bits/uClibc_page.h>
  26. #include <paths.h>
  27. #include <unistd.h>
  28. #include <asm/errno.h>
  29. #include <fcntl.h>
  30. #include <sys/stat.h>
  31. #include <sys/sysmacros.h>
  32. #ifdef __UCLIBC_HAS_THREADS_NATIVE__
  33. #include <errno.h>
  34. #include <pthread-functions.h>
  35. #include <not-cancel.h>
  36. #include <atomic.h>
  37. #endif
  38. #ifndef SHARED
  39. void *__libc_stack_end = NULL;
  40. # ifdef __UCLIBC_HAS_SSP__
  41. # include <dl-osinfo.h>
  42. # ifndef THREAD_SET_STACK_GUARD
  43. /* Only exported for architectures that don't store the stack guard canary
  44. * in thread local area. */
  45. # include <stdint.h>
  46. uintptr_t stack_chk_guard;
  47. /* for gcc-4.1 non-TLS */
  48. uintptr_t __stack_chk_guard attribute_relro;
  49. /* for gcc-3.x + Etoh ssp */
  50. # ifdef __UCLIBC_HAS_SSP_COMPAT__
  51. # ifdef __HAVE_SHARED__
  52. strong_alias(__stack_chk_guard,__guard)
  53. # else
  54. uintptr_t __guard attribute_relro;
  55. # endif
  56. # endif
  57. # elif defined __UCLIBC_HAS_SSP_COMPAT__
  58. uintptr_t __guard attribute_relro;
  59. # endif
  60. # endif
  61. /*
  62. * Needed to initialize _dl_phdr when statically linked
  63. */
  64. void internal_function _dl_aux_init (ElfW(auxv_t) *av);
  65. #endif /* !SHARED */
  66. /*
  67. * Prototypes.
  68. */
  69. extern int *weak_const_function __errno_location(void);
  70. extern int *weak_const_function __h_errno_location(void);
  71. extern void weak_function _stdio_init(void) attribute_hidden;
  72. #ifdef __UCLIBC_HAS_LOCALE__
  73. extern void weak_function _locale_init(void) attribute_hidden;
  74. #endif
  75. #ifdef __UCLIBC_HAS_THREADS__
  76. #if !defined (__UCLIBC_HAS_THREADS_NATIVE__) || defined (SHARED)
  77. extern void weak_function __pthread_initialize_minimal(void);
  78. #else
  79. extern void __pthread_initialize_minimal(void);
  80. #endif
  81. #endif
  82. /* If __UCLIBC_FORMAT_SHARED_FLAT__, all array initialisation and finalisation
  83. * is handled by the routines passed to __uClibc_main(). */
  84. #if defined (__UCLIBC_CTOR_DTOR__) && !defined (__UCLIBC_FORMAT_SHARED_FLAT__)
  85. extern void _dl_app_init_array(void);
  86. extern void _dl_app_fini_array(void);
  87. # ifndef SHARED
  88. /* These magic symbols are provided by the linker. */
  89. extern void (*__preinit_array_start []) (void) attribute_hidden;
  90. extern void (*__preinit_array_end []) (void) attribute_hidden;
  91. extern void (*__init_array_start []) (void) attribute_hidden;
  92. extern void (*__init_array_end []) (void) attribute_hidden;
  93. extern void (*__fini_array_start []) (void) attribute_hidden;
  94. extern void (*__fini_array_end []) (void) attribute_hidden;
  95. # endif
  96. #endif
  97. attribute_hidden const char *__uclibc_progname = "";
  98. #ifdef __UCLIBC_HAS_PROGRAM_INVOCATION_NAME__
  99. const char *program_invocation_short_name = "";
  100. const char *program_invocation_name = "";
  101. #endif
  102. #ifdef __UCLIBC_HAS___PROGNAME__
  103. weak_alias (program_invocation_short_name, __progname)
  104. weak_alias (program_invocation_name, __progname_full)
  105. #endif
  106. /*
  107. * Declare the __environ global variable and create a weak alias environ.
  108. * This must be initialized; we cannot have a weak alias into bss.
  109. */
  110. char **__environ = 0;
  111. weak_alias(__environ, environ)
  112. /* TODO: don't export __pagesize; we cant now because libpthread uses it */
  113. size_t __pagesize = 0;
  114. #ifndef O_NOFOLLOW
  115. # define O_NOFOLLOW 0
  116. #endif
  117. #ifndef __ARCH_HAS_NO_LDSO__
  118. static void __check_one_fd(int fd, int mode)
  119. {
  120. /* Check if the specified fd is already open */
  121. if (fcntl(fd, F_GETFD) == -1)
  122. {
  123. /* The descriptor is probably not open, so try to use /dev/null */
  124. int nullfd = open(_PATH_DEVNULL, mode);
  125. /* /dev/null is major=1 minor=3. Make absolutely certain
  126. * that is in fact the device that we have opened and not
  127. * some other wierd file... [removed in uclibc] */
  128. if (nullfd!=fd)
  129. {
  130. abort();
  131. }
  132. }
  133. }
  134. static int __check_suid(void)
  135. {
  136. uid_t uid, euid;
  137. gid_t gid, egid;
  138. uid = getuid();
  139. euid = geteuid();
  140. if (uid != euid)
  141. return 1;
  142. gid = getgid();
  143. egid = getegid();
  144. if (gid != egid)
  145. return 1;
  146. return 0; /* we are not suid */
  147. }
  148. #endif
  149. /* __uClibc_init completely initialize uClibc so it is ready to use.
  150. *
  151. * On ELF systems (with a dynamic loader) this function must be called
  152. * from the dynamic loader (see TIS and ELF Specification), so that
  153. * constructors of shared libraries (which depend on libc) can use all
  154. * the libc code without restriction. For this we link the shared
  155. * version of the uClibc with -init __uClibc_init so DT_INIT for
  156. * uClibc is the address of __uClibc_init
  157. *
  158. * In all other cases we call it from the main stub
  159. * __uClibc_main.
  160. */
  161. extern void __uClibc_init(void);
  162. libc_hidden_proto(__uClibc_init)
  163. void __uClibc_init(void)
  164. {
  165. static smallint been_there_done_that;
  166. if (been_there_done_that)
  167. return;
  168. been_there_done_that++;
  169. /* Setup an initial value. This may not be perfect, but is
  170. * better than malloc using __pagesize=0 for atexit, ctors, etc. */
  171. __pagesize = PAGE_SIZE;
  172. #ifdef __UCLIBC_HAS_THREADS__
  173. /* Before we start initializing uClibc we have to call
  174. * __pthread_initialize_minimal so we can use pthread_locks
  175. * whenever they are needed.
  176. */
  177. #if !defined (__UCLIBC_HAS_THREADS_NATIVE__) || defined (SHARED)
  178. if (likely(__pthread_initialize_minimal!=NULL))
  179. #endif
  180. __pthread_initialize_minimal();
  181. #endif
  182. #ifndef SHARED
  183. # ifdef __UCLIBC_HAS_SSP__
  184. /* Set up the stack checker's canary. */
  185. # ifdef THREAD_SET_STACK_GUARD
  186. uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard();
  187. THREAD_SET_STACK_GUARD (stack_chk_guard);
  188. # ifdef __UCLIBC_HAS_SSP_COMPAT__
  189. stack_chk_guard = _dl_setup_stack_chk_guard();
  190. __guard = stack_chk_guard;
  191. # endif
  192. # else
  193. __stack_chk_guard = stack_chk_guard;
  194. # if !defined __HAVE_SHARED__ && defined __UCLIBC_HAS_SSP_COMPAT__
  195. __guard = stack_chk_guard;
  196. # endif
  197. # endif
  198. # endif
  199. #endif
  200. #ifdef __UCLIBC_HAS_LOCALE__
  201. /* Initialize the global locale structure. */
  202. if (likely(_locale_init!=NULL))
  203. _locale_init();
  204. #endif
  205. /*
  206. * Initialize stdio here. In the static library case, this will
  207. * be bypassed if not needed because of the weak alias above.
  208. * Thus we get a nice size savings because the stdio functions
  209. * won't be pulled into the final static binary unless used.
  210. */
  211. if (likely(_stdio_init != NULL))
  212. _stdio_init();
  213. }
  214. libc_hidden_def(__uClibc_init)
  215. #ifdef __UCLIBC_CTOR_DTOR__
  216. void attribute_hidden (*__app_fini)(void) = NULL;
  217. #endif
  218. void attribute_hidden (*__rtld_fini)(void) = NULL;
  219. extern void __uClibc_fini(void);
  220. libc_hidden_proto(__uClibc_fini)
  221. void __uClibc_fini(void)
  222. {
  223. #ifdef __UCLIBC_CTOR_DTOR__
  224. /* If __UCLIBC_FORMAT_SHARED_FLAT__, all array finalisation is handled
  225. * by __app_fini. */
  226. # ifdef SHARED
  227. _dl_app_fini_array();
  228. # elif !defined (__UCLIBC_FORMAT_SHARED_FLAT__)
  229. size_t i = __fini_array_end - __fini_array_start;
  230. while (i-- > 0)
  231. (*__fini_array_start [i]) ();
  232. # endif
  233. if (__app_fini != NULL)
  234. (__app_fini)();
  235. #endif
  236. if (__rtld_fini != NULL)
  237. (__rtld_fini)();
  238. }
  239. libc_hidden_def(__uClibc_fini)
  240. /* __uClibc_main is the new main stub for uClibc. This function is
  241. * called from crt1 (version 0.9.28 or newer), after ALL shared libraries
  242. * are initialized, just before we call the application's main function.
  243. */
  244. void __uClibc_main(int (*main)(int, char **, char **), int argc,
  245. char **argv, void (*app_init)(void), void (*app_fini)(void),
  246. void (*rtld_fini)(void),
  247. void *stack_end attribute_unused) attribute_noreturn;
  248. void __uClibc_main(int (*main)(int, char **, char **), int argc,
  249. char **argv, void (*app_init)(void), void (*app_fini)(void),
  250. void (*rtld_fini)(void), void *stack_end attribute_unused)
  251. {
  252. #ifndef __ARCH_HAS_NO_LDSO__
  253. unsigned long *aux_dat;
  254. ElfW(auxv_t) auxvt[AT_EGID + 1];
  255. #endif
  256. #ifdef __UCLIBC_HAS_THREADS_NATIVE__
  257. /* Result of the 'main' function. */
  258. int result;
  259. #endif
  260. #ifndef SHARED
  261. __libc_stack_end = stack_end;
  262. #endif
  263. __rtld_fini = rtld_fini;
  264. /* The environment begins right after argv. */
  265. __environ = &argv[argc + 1];
  266. /* If the first thing after argv is the arguments
  267. * the the environment is empty. */
  268. if ((char *) __environ == *argv) {
  269. /* Make __environ point to the NULL at argv[argc] */
  270. __environ = &argv[argc];
  271. }
  272. #ifndef __ARCH_HAS_NO_LDSO__
  273. /* Pull stuff from the ELF header when possible */
  274. memset(auxvt, 0x00, sizeof(auxvt));
  275. aux_dat = (unsigned long*)__environ;
  276. while (*aux_dat) {
  277. aux_dat++;
  278. }
  279. aux_dat++;
  280. while (*aux_dat) {
  281. ElfW(auxv_t) *auxv_entry = (ElfW(auxv_t) *) aux_dat;
  282. if (auxv_entry->a_type <= AT_EGID) {
  283. memcpy(&(auxvt[auxv_entry->a_type]), auxv_entry, sizeof(ElfW(auxv_t)));
  284. }
  285. aux_dat += 2;
  286. }
  287. #ifndef SHARED
  288. /* Get the program headers (_dl_phdr) from the aux vector
  289. It will be used into __libc_setup_tls. */
  290. _dl_aux_init (auxvt);
  291. #endif
  292. #endif
  293. /* We need to initialize uClibc. If we are dynamically linked this
  294. * may have already been completed by the shared lib loader. We call
  295. * __uClibc_init() regardless, to be sure the right thing happens. */
  296. __uClibc_init();
  297. #ifndef __ARCH_HAS_NO_LDSO__
  298. /* Make certain getpagesize() gives the correct answer */
  299. __pagesize = (auxvt[AT_PAGESZ].a_un.a_val)? auxvt[AT_PAGESZ].a_un.a_val : PAGE_SIZE;
  300. /* Prevent starting SUID binaries where the stdin. stdout, and
  301. * stderr file descriptors are not already opened. */
  302. if ((auxvt[AT_UID].a_un.a_val == (size_t)-1 && __check_suid()) ||
  303. (auxvt[AT_UID].a_un.a_val != (size_t)-1 &&
  304. (auxvt[AT_UID].a_un.a_val != auxvt[AT_EUID].a_un.a_val ||
  305. auxvt[AT_GID].a_un.a_val != auxvt[AT_EGID].a_un.a_val)))
  306. {
  307. __check_one_fd (STDIN_FILENO, O_RDONLY | O_NOFOLLOW);
  308. __check_one_fd (STDOUT_FILENO, O_RDWR | O_NOFOLLOW);
  309. __check_one_fd (STDERR_FILENO, O_RDWR | O_NOFOLLOW);
  310. }
  311. #endif
  312. __uclibc_progname = *argv;
  313. #ifdef __UCLIBC_HAS_PROGRAM_INVOCATION_NAME__
  314. if (*argv != NULL) {
  315. program_invocation_name = *argv;
  316. program_invocation_short_name = strrchr(*argv, '/');
  317. if (program_invocation_short_name != NULL)
  318. ++program_invocation_short_name;
  319. else
  320. program_invocation_short_name = program_invocation_name;
  321. }
  322. #endif
  323. #ifdef __UCLIBC_CTOR_DTOR__
  324. /* Arrange for the application's dtors to run before we exit. */
  325. __app_fini = app_fini;
  326. /* If __UCLIBC_FORMAT_SHARED_FLAT__, all array initialisation is handled
  327. * by __app_init. */
  328. # if !defined (SHARED) && !defined (__UCLIBC_FORMAT_SHARED_FLAT__)
  329. /* For dynamically linked executables the preinit array is executed by
  330. the dynamic linker (before initializing any shared object).
  331. For static executables, preinit happens rights before init. */
  332. {
  333. const size_t size = __preinit_array_end - __preinit_array_start;
  334. size_t i;
  335. for (i = 0; i < size; i++)
  336. (*__preinit_array_start [i]) ();
  337. }
  338. # endif
  339. /* Run all the application's ctors now. */
  340. if (app_init!=NULL) {
  341. app_init();
  342. }
  343. /* If __UCLIBC_FORMAT_SHARED_FLAT__, all array initialisation is handled
  344. * by __app_init. */
  345. # ifdef SHARED
  346. _dl_app_init_array();
  347. # elif !defined (__UCLIBC_FORMAT_SHARED_FLAT__)
  348. {
  349. const size_t size = __init_array_end - __init_array_start;
  350. size_t i;
  351. for (i = 0; i < size; i++)
  352. (*__init_array_start [i]) ();
  353. }
  354. # endif
  355. #endif
  356. /* Note: It is possible that any initialization done above could
  357. * have resulted in errno being set nonzero, so set it to 0 before
  358. * we call main.
  359. */
  360. if (likely(__errno_location!=NULL))
  361. *(__errno_location()) = 0;
  362. /* Set h_errno to 0 as well */
  363. if (likely(__h_errno_location!=NULL))
  364. *(__h_errno_location()) = 0;
  365. #if defined HAVE_CLEANUP_JMP_BUF && defined __UCLIBC_HAS_THREADS_NATIVE__
  366. /* Memory for the cancellation buffer. */
  367. struct pthread_unwind_buf unwind_buf;
  368. int not_first_call;
  369. not_first_call =
  370. setjmp ((struct __jmp_buf_tag *) unwind_buf.cancel_jmp_buf);
  371. if (__builtin_expect (! not_first_call, 1))
  372. {
  373. struct pthread *self = THREAD_SELF;
  374. /* Store old info. */
  375. unwind_buf.priv.data.prev = THREAD_GETMEM (self, cleanup_jmp_buf);
  376. unwind_buf.priv.data.cleanup = THREAD_GETMEM (self, cleanup);
  377. /* Store the new cleanup handler info. */
  378. THREAD_SETMEM (self, cleanup_jmp_buf, &unwind_buf);
  379. /* Run the program. */
  380. result = main (argc, argv, __environ);
  381. }
  382. else
  383. {
  384. /* Remove the thread-local data. */
  385. # ifdef SHARED
  386. __libc_pthread_functions.ptr__nptl_deallocate_tsd ();
  387. # else
  388. extern void __nptl_deallocate_tsd (void) __attribute ((weak));
  389. __nptl_deallocate_tsd ();
  390. # endif
  391. /* One less thread. Decrement the counter. If it is zero we
  392. terminate the entire process. */
  393. result = 0;
  394. # ifdef SHARED
  395. unsigned int *const ptr = __libc_pthread_functions.ptr_nthreads;
  396. # else
  397. extern unsigned int __nptl_nthreads __attribute ((weak));
  398. unsigned int *const ptr = &__nptl_nthreads;
  399. # endif
  400. if (! atomic_decrement_and_test (ptr))
  401. /* Not much left to do but to exit the thread, not the process. */
  402. __exit_thread_inline (0);
  403. }
  404. exit (result);
  405. #else
  406. /*
  407. * Finally, invoke application's main and then exit.
  408. */
  409. exit (main (argc, argv, __environ));
  410. #endif
  411. }