__uClibc_main.c 4.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171
  1. /*
  2. * Manuel Novoa III Feb 2001
  3. * Erik Andersen Mar 2002
  4. *
  5. * __uClibc_main is the routine to be called by all the arch-specific
  6. * versions of crt0.S in uClibc.
  7. *
  8. * It is meant to handle any special initialization needed by the library
  9. * such as setting the global variable(s) __environ (environ) and
  10. * initializing the stdio package. Using weak symbols, the latter is
  11. * avoided in the static library case.
  12. */
  13. #define _ERRNO_H
  14. #include <features.h>
  15. #include <unistd.h>
  16. #include <stdlib.h>
  17. /*
  18. * Prototypes.
  19. */
  20. extern int main(int argc, char **argv, char **envp);
  21. extern void weak_function _stdio_init(void);
  22. extern int *weak_const_function __errno_location(void);
  23. extern int *weak_const_function __h_errno_location(void);
  24. #ifdef __UCLIBC_HAS_LOCALE__
  25. extern void weak_function _locale_init(void);
  26. #endif
  27. #ifdef __UCLIBC_HAS_THREADS__
  28. extern void weak_function __pthread_initialize_minimal(void);
  29. #endif
  30. /*
  31. * Declare the __environ global variable and create a weak alias environ.
  32. * Note: Apparently we must initialize __environ to ensure that the weak
  33. * environ symbol is also included.
  34. */
  35. char **__environ = 0;
  36. weak_alias(__environ, environ);
  37. /* __uClibc_init completely initialize uClibc so it is ready to use.
  38. *
  39. * On ELF systems (with a dynamic loader) this function must be called
  40. * from the dynamic loader (see TIS and ELF Specification), so that
  41. * constructors of shared libraries (which depend on libc) can use all
  42. * the libc code without restriction. For this we link the shared
  43. * version of the uClibc with -init __uClibc_init so DT_INIT for
  44. * uClibc is the address of __uClibc_init
  45. *
  46. * In all other cases we call it from the main stub
  47. * __uClibc_start_main.
  48. */
  49. void __uClibc_init(void)
  50. {
  51. static int been_there_done_that = 0;
  52. if (been_there_done_that)
  53. return;
  54. been_there_done_that++;
  55. #ifdef __UCLIBC_HAS_THREADS__
  56. /* Before we start initialzing uClibc we have to call
  57. * __pthread_initialize_minimal so we can use pthread_locks
  58. * whenever they are needed.
  59. */
  60. if (likely(__pthread_initialize_minimal!=NULL))
  61. __pthread_initialize_minimal();
  62. #endif
  63. #if 0
  64. /* Some security at this point. Prevent starting a SUID binary
  65. * where the standard file descriptors are not opened. We have
  66. * to do this only for statically linked applications since
  67. * otherwise the dynamic loader did the work already. */
  68. if (unlikely (__libc_enable_secure!=NULL))
  69. __libc_check_standard_fds ();
  70. #endif
  71. #ifdef __UCLIBC_HAS_LOCALE__
  72. /* Initialize the global locale structure. */
  73. if (likely(_locale_init!=NULL))
  74. _locale_init();
  75. #endif
  76. /*
  77. * Initialize stdio here. In the static library case, this will
  78. * be bypassed if not needed because of the weak alias above.
  79. */
  80. if (likely(_stdio_init != NULL))
  81. _stdio_init();
  82. }
  83. /* __uClibc_start_main is the new main stub for uClibc. This function is
  84. * called from crt0 (version 0.9.16 or newer), after ALL shared libraries
  85. * are initialized, just before we call the application's main function.
  86. */
  87. void __attribute__ ((__noreturn__))
  88. __uClibc_start_main(int argc, char **argv, char **envp,
  89. void (*app_init)(void), void (*app_fini)(void))
  90. {
  91. /* If we are dynamically linked the shared lib loader already
  92. * did this for us. But if we are statically linked, we need
  93. * to do this for ourselves. */
  94. if (__environ==NULL) {
  95. /* Statically linked. */
  96. __environ = envp;
  97. }
  98. /* We need to initialize uClibc. If we are dynamically linked this
  99. * may have already been completed by the shared lib loader. We call
  100. * __uClibc_init() regardless, to be sure the right thing happens. */
  101. __uClibc_init();
  102. #ifdef __UCLIBC_CTOR_DTOR__
  103. /* Arrange for the application's dtors to run before we exit. */
  104. if (app_fini!=NULL) {
  105. atexit(app_fini);
  106. }
  107. /* Run all the application's ctors now. */
  108. if (app_init!=NULL) {
  109. app_init();
  110. }
  111. #endif
  112. /* Note: It is possible that any initialization done above could
  113. * have resulted in errno being set nonzero, so set it to 0 before
  114. * we call main.
  115. */
  116. if (likely(__errno_location!=NULL))
  117. *(__errno_location()) = 0;
  118. /* Set h_errno to 0 as well */
  119. if (likely(__h_errno_location!=NULL))
  120. *(__h_errno_location()) = 0;
  121. /*
  122. * Finally, invoke application's main and then exit.
  123. */
  124. exit(main(argc, argv, envp));
  125. }
  126. /* __uClibc_main is the old main stub of the uClibc. This
  127. * function is called from crt0 (uClibc 0.9.15 and older) after
  128. * ALL shared libraries are initialized, and just before we call
  129. * the application's main() function.
  130. *
  131. * Attention: This stub does not call the .init/.fini sections of
  132. * the application. If you need this, please fix your uClibc port
  133. * so that __uClibc_start_main is called by your crt0.S with
  134. * _init and _fini properly set.
  135. */
  136. void __attribute__ ((__noreturn__))
  137. __uClibc_main(int argc, char **argv, char ** envp)
  138. {
  139. __uClibc_start_main(argc, argv, envp, NULL, NULL);
  140. }