__uClibc_main.c 15 KB

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