uclibc-ng/libc/misc/internals/__uClibc_main.c

/*
 * Manuel Novoa III           Feb 2001
 * Erik Andersen              2002-2004
 *
 * __uClibc_main is the routine to be called by all the arch-specific
 * versions of crt0.S in uClibc.
 *
 * It is meant to handle any special initialization needed by the library
 * such as setting the global variable(s) __environ (environ) and
 * initializing the stdio package.  Using weak symbols, the latter is
 * avoided in the static library case.
 */

#define	_ERRNO_H
#include <features.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <elf.h>
#include <sys/user.h>
#ifdef __UCLIBC_PROPOLICE__
extern void __guard_setup(void);
#endif


/*
 * Prototypes.
 */
extern int  main(int argc, char **argv, char **envp);
extern void weak_function _stdio_init(void);
extern int *weak_const_function __errno_location(void);
extern int *weak_const_function __h_errno_location(void);
#ifdef __UCLIBC_HAS_LOCALE__
extern void weak_function _locale_init(void);
#endif
#ifdef __UCLIBC_HAS_THREADS__
extern void weak_function __pthread_initialize_minimal(void);
#endif





/*
 * Declare the __environ global variable and create a weak alias environ.
 * Note: Apparently we must initialize __environ to ensure that the weak
 * environ symbol is also included.
 */

extern int _dl_secure;
extern size_t _dl_pagesize;
size_t __dl_pagesize = 0;
weak_alias(__dl_pagesize, _dl_pagesize);

char **__environ = 0;
const char *__progname = 0;
weak_alias(__environ, environ);



/* __uClibc_init completely initialize uClibc so it is ready to use.
 *
 * On ELF systems (with a dynamic loader) this function must be called
 * from the dynamic loader (see TIS and ELF Specification), so that
 * constructors of shared libraries (which depend on libc) can use all
 * the libc code without restriction.  For this we link the shared
 * version of the uClibc with -init __uClibc_init so DT_INIT for
 * uClibc is the address of __uClibc_init
 *
 * In all other cases we call it from the main stub
 * __uClibc_start_main.
 */

void __uClibc_init(void)
{
    static int been_there_done_that = 0;

    if (been_there_done_that)
	return;
    been_there_done_that++;

#ifdef __UCLIBC_HAS_THREADS__
    /* Before we start initialzing uClibc we have to call
     * __pthread_initialize_minimal so we can use pthread_locks
     * whenever they are needed.
     */
    if (likely(__pthread_initialize_minimal!=NULL))
	__pthread_initialize_minimal();
#endif

#if 0
    /* Some security at this point.  Prevent starting a SUID binary
     * where the standard file descriptors are not opened.  We have
     * to do this only for statically linked applications since
     * otherwise the dynamic loader did the work already.  */
    if (unlikely (__libc_enable_secure!=NULL))
	__libc_check_standard_fds ();
#endif

#ifdef __UCLIBC_HAS_LOCALE__
    /* Initialize the global locale structure. */
    if (likely(_locale_init!=NULL))
	_locale_init();
#endif

    /*
     * Initialize stdio here.  In the static library case, this will
     * be bypassed if not needed because of the weak alias above.
     */
    if (likely(_stdio_init != NULL))
	_stdio_init();

}

#ifdef __UCLIBC_CTOR_DTOR__
void (*__app_fini)(void) = NULL;
#endif

/* __uClibc_start_main is the new main stub for uClibc. This function is
 * called from crt0 (version 0.9.16 or newer), after ALL shared libraries
 * are initialized, just before we call the application's main function.
 */
void __attribute__ ((__noreturn__))
__uClibc_start_main(int argc, char **argv, char **envp,
	void (*app_init)(void), void (*app_fini)(void))
{
    /* Pull stuff from the ELF header when possible */
#ifdef __ARCH_HAS_MMU__
    unsigned long *aux_dat;
    Elf32_auxv_t auxvt[AT_EGID + 1];
    aux_dat = (unsigned long*)envp;
    while (*aux_dat) {
	aux_dat++;
    }
    aux_dat++;
    while (*aux_dat) {
	Elf32_auxv_t *auxv_entry = (Elf32_auxv_t *) aux_dat;
	if (auxv_entry->a_type <= AT_EGID) {
	    memcpy(&(auxvt[auxv_entry->a_type]), auxv_entry, sizeof(Elf32_auxv_t));
	}
	aux_dat += 2;
    }
    _dl_pagesize = (auxvt[AT_PAGESZ].a_un.a_val)? auxvt[AT_PAGESZ].a_un.a_val : PAGE_SIZE;
#else
    _dl_pagesize = PAGE_SIZE;
#endif

    /* If we are dynamically linked the shared lib loader already
     * did this for us.  But if we are statically linked, we need
     * to do this for ourselves.  */
    if (__environ==NULL) {
	/* Statically linked. */
	__environ = envp;
    }

    /* We need to initialize uClibc.  If we are dynamically linked this
     * may have already been completed by the shared lib loader.  We call
     * __uClibc_init() regardless, to be sure the right thing happens. */
    __uClibc_init();

    __progname = *argv;

#ifdef __UCLIBC_CTOR_DTOR__
    /* Arrange for the application's dtors to run before we exit.  */
    __app_fini = app_fini;

    /* Run all the application's ctors now.  */
    if (app_init!=NULL) {
	app_init();
    }
#endif

#ifdef __UCLIBC_PROPOLICE__
    __guard_setup ();
#endif

    /* Note: It is possible that any initialization done above could
     * have resulted in errno being set nonzero, so set it to 0 before
     * we call main.
     */
    if (likely(__errno_location!=NULL))
	*(__errno_location()) = 0;

    /* Set h_errno to 0 as well */
    if (likely(__h_errno_location!=NULL))
	*(__h_errno_location()) = 0;

    /*
     * Finally, invoke application's main and then exit.
     */
    exit(main(argc, argv, envp));
}


/* __uClibc_main is the old main stub of the uClibc. This
 * function is called from crt0 (uClibc 0.9.15 and older) after
 * ALL shared libraries are initialized, and just before we call
 * the application's main() function.
 *
 * Attention: This stub does not call the .init/.fini sections of
 * the application. If you need this, please fix your uClibc port
 * so that  __uClibc_start_main is called by your crt0.S with
 * _init and _fini properly set.
*/
void __attribute__ ((__noreturn__))
__uClibc_main(int argc, char **argv, char ** envp)
{
    __uClibc_start_main(argc, argv, envp, NULL, NULL);
}