[thirdparty/glibc.git] / elf / dl-sysdep.c

/* Operating system support for run-time dynamic linker.  Generic Unix version.
   Copyright (C) 1995-2019 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

/* We conditionalize the whole of this file rather than simply eliding it
   from the static build, because other sysdeps/ versions of this file
   might define things needed by a static build.  */

#ifdef SHARED

#include <assert.h>
#include <elf.h>
#include <errno.h>
#include <fcntl.h>
#include <libintl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <ldsodefs.h>
#include <_itoa.h>
#include <fpu_control.h>

#include <entry.h>
#include <dl-machine.h>
#include <dl-procinfo.h>
#include <dl-osinfo.h>
#include <libc-internal.h>
#include <tls.h>

#include <dl-tunables.h>

extern char **_environ attribute_hidden;
extern char _end[] attribute_hidden;

/* Protect SUID program against misuse of file descriptors.  */
extern void __libc_check_standard_fds (void);

#ifdef NEED_DL_BASE_ADDR
ElfW(Addr) _dl_base_addr;
#endif
int __libc_enable_secure attribute_relro = 0;
rtld_hidden_data_def (__libc_enable_secure)
int __libc_multiple_libcs = 0;	/* Defining this here avoids the inclusion
				   of init-first.  */
/* This variable contains the lowest stack address ever used.  */
void *__libc_stack_end attribute_relro = NULL;
rtld_hidden_data_def(__libc_stack_end)
void *_dl_random attribute_relro = NULL;

#ifndef DL_FIND_ARG_COMPONENTS
# define DL_FIND_ARG_COMPONENTS(cookie, argc, argv, envp, auxp)	\
  do {									      \
    void **_tmp;							      \
    (argc) = *(long int *) cookie;					      \
    (argv) = (char **) ((long int *) cookie + 1);			      \
    (envp) = (argv) + (argc) + 1;					      \
    for (_tmp = (void **) (envp); *_tmp; ++_tmp)			      \
      continue;								      \
    (auxp) = (void *) ++_tmp;						      \
  } while (0)
#endif

#ifndef DL_STACK_END
# define DL_STACK_END(cookie) ((void *) (cookie))
#endif

ElfW(Addr)
_dl_sysdep_start (void **start_argptr,
		  void (*dl_main) (const ElfW(Phdr) *phdr, ElfW(Word) phnum,
				   ElfW(Addr) *user_entry, ElfW(auxv_t) *auxv))
{
  const ElfW(Phdr) *phdr = NULL;
  ElfW(Word) phnum = 0;
  ElfW(Addr) user_entry;
  ElfW(auxv_t) *av;
#ifdef HAVE_AUX_SECURE
# define set_seen(tag) (tag)	/* Evaluate for the side effects.  */
# define set_seen_secure() ((void) 0)
#else
  uid_t uid = 0;
  gid_t gid = 0;
  unsigned int seen = 0;
# define set_seen_secure() (seen = -1)
# ifdef HAVE_AUX_XID
#  define set_seen(tag) (tag)	/* Evaluate for the side effects.  */
# else
#  define M(type) (1 << (type))
#  define set_seen(tag) seen |= M ((tag)->a_type)
# endif
#endif
#ifdef NEED_DL_SYSINFO
  uintptr_t new_sysinfo = 0;
#endif

  __libc_stack_end = DL_STACK_END (start_argptr);
  DL_FIND_ARG_COMPONENTS (start_argptr, _dl_argc, _dl_argv, _environ,
			  GLRO(dl_auxv));

  user_entry = (ElfW(Addr)) ENTRY_POINT;
  GLRO(dl_platform) = NULL; /* Default to nothing known about the platform.  */

  for (av = GLRO(dl_auxv); av->a_type != AT_NULL; set_seen (av++))
    switch (av->a_type)
      {
      case AT_PHDR:
	phdr = (void *) av->a_un.a_val;
	break;
      case AT_PHNUM:
	phnum = av->a_un.a_val;
	break;
      case AT_PAGESZ:
	GLRO(dl_pagesize) = av->a_un.a_val;
	break;
      case AT_ENTRY:
	user_entry = av->a_un.a_val;
	break;
#ifdef NEED_DL_BASE_ADDR
      case AT_BASE:
	_dl_base_addr = av->a_un.a_val;
	break;
#endif
#ifndef HAVE_AUX_SECURE
      case AT_UID:
      case AT_EUID:
	uid ^= av->a_un.a_val;
	break;
      case AT_GID:
      case AT_EGID:
	gid ^= av->a_un.a_val;
	break;
#endif
      case AT_SECURE:
#ifndef HAVE_AUX_SECURE
	seen = -1;
#endif
	__libc_enable_secure = av->a_un.a_val;
	break;
      case AT_PLATFORM:
	GLRO(dl_platform) = (void *) av->a_un.a_val;
	break;
      case AT_HWCAP:
	GLRO(dl_hwcap) = (unsigned long int) av->a_un.a_val;
	break;
      case AT_HWCAP2:
	GLRO(dl_hwcap2) = (unsigned long int) av->a_un.a_val;
	break;
      case AT_CLKTCK:
	GLRO(dl_clktck) = av->a_un.a_val;
	break;
      case AT_FPUCW:
	GLRO(dl_fpu_control) = av->a_un.a_val;
	break;
#ifdef NEED_DL_SYSINFO
      case AT_SYSINFO:
	new_sysinfo = av->a_un.a_val;
	break;
#endif
#ifdef NEED_DL_SYSINFO_DSO
      case AT_SYSINFO_EHDR:
	GLRO(dl_sysinfo_dso) = (void *) av->a_un.a_val;
	break;
#endif
      case AT_RANDOM:
	_dl_random = (void *) av->a_un.a_val;
	break;
#ifdef DL_PLATFORM_AUXV
      DL_PLATFORM_AUXV
#endif
      }

#ifndef HAVE_AUX_SECURE
  if (seen != -1)
    {
      /* Fill in the values we have not gotten from the kernel through the
	 auxiliary vector.  */
# ifndef HAVE_AUX_XID
#  define SEE(UID, var, uid) \
   if ((seen & M (AT_##UID)) == 0) var ^= __get##uid ()
      SEE (UID, uid, uid);
      SEE (EUID, uid, euid);
      SEE (GID, gid, gid);
      SEE (EGID, gid, egid);
# endif

      /* If one of the two pairs of IDs does not match this is a setuid
	 or setgid run.  */
      __libc_enable_secure = uid | gid;
    }
#endif

#ifndef HAVE_AUX_PAGESIZE
  if (GLRO(dl_pagesize) == 0)
    GLRO(dl_pagesize) = __getpagesize ();
#endif

#ifdef NEED_DL_SYSINFO
  if (new_sysinfo != 0)
    {
# ifdef NEED_DL_SYSINFO_DSO
      /* Only set the sysinfo value if we also have the vsyscall DSO.  */
      if (GLRO(dl_sysinfo_dso) != 0)
# endif
        GLRO(dl_sysinfo) = new_sysinfo;
    }
#endif

  __tunables_init (_environ);

#ifdef DL_SYSDEP_INIT
  DL_SYSDEP_INIT;
#endif

#ifdef DL_PLATFORM_INIT
  DL_PLATFORM_INIT;
#endif

  /* Determine the length of the platform name.  */
  if (GLRO(dl_platform) != NULL)
    GLRO(dl_platformlen) = strlen (GLRO(dl_platform));

  if (__sbrk (0) == _end)
    /* The dynamic linker was run as a program, and so the initial break
       starts just after our bss, at &_end.  The malloc in dl-minimal.c
       will consume the rest of this page, so tell the kernel to move the
       break up that far.  When the user program examines its break, it
       will see this new value and not clobber our data.  */
    __sbrk (GLRO(dl_pagesize)
	    - ((_end - (char *) 0) & (GLRO(dl_pagesize) - 1)));

  /* If this is a SUID program we make sure that FDs 0, 1, and 2 are
     allocated.  If necessary we are doing it ourself.  If it is not
     possible we stop the program.  */
  if (__builtin_expect (__libc_enable_secure, 0))
    __libc_check_standard_fds ();

  (*dl_main) (phdr, phnum, &user_entry, GLRO(dl_auxv));
  return user_entry;
}

void
_dl_sysdep_start_cleanup (void)
{
}

void
_dl_show_auxv (void)
{
  char buf[64];
  ElfW(auxv_t) *av;

  /* Terminate string.  */
  buf[63] = '\0';

  /* The following code assumes that the AT_* values are encoded
     starting from 0 with AT_NULL, 1 for AT_IGNORE, and all other values
     close by (otherwise the array will be too large).  In case we have
     to support a platform where these requirements are not fulfilled
     some alternative implementation has to be used.  */
  for (av = GLRO(dl_auxv); av->a_type != AT_NULL; ++av)
    {
      static const struct
      {
	const char label[22];
	enum { unknown = 0, dec, hex, str, ignore } form : 8;
      } auxvars[] =
	{
	  [AT_EXECFD - 2] =		{ "EXECFD:            ", dec },
	  [AT_EXECFN - 2] =		{ "EXECFN:            ", str },
	  [AT_PHDR - 2] =		{ "PHDR:              0x", hex },
	  [AT_PHENT - 2] =		{ "PHENT:             ", dec },
	  [AT_PHNUM - 2] =		{ "PHNUM:             ", dec },
	  [AT_PAGESZ - 2] =		{ "PAGESZ:            ", dec },
	  [AT_BASE - 2] =		{ "BASE:              0x", hex },
	  [AT_FLAGS - 2] =		{ "FLAGS:             0x", hex },
	  [AT_ENTRY - 2] =		{ "ENTRY:             0x", hex },
	  [AT_NOTELF - 2] =		{ "NOTELF:            ", hex },
	  [AT_UID - 2] =		{ "UID:               ", dec },
	  [AT_EUID - 2] =		{ "EUID:              ", dec },
	  [AT_GID - 2] =		{ "GID:               ", dec },
	  [AT_EGID - 2] =		{ "EGID:              ", dec },
	  [AT_PLATFORM - 2] =		{ "PLATFORM:          ", str },
	  [AT_HWCAP - 2] =		{ "HWCAP:             ", hex },
	  [AT_CLKTCK - 2] =		{ "CLKTCK:            ", dec },
	  [AT_FPUCW - 2] =		{ "FPUCW:             ", hex },
	  [AT_DCACHEBSIZE - 2] =	{ "DCACHEBSIZE:       0x", hex },
	  [AT_ICACHEBSIZE - 2] =	{ "ICACHEBSIZE:       0x", hex },
	  [AT_UCACHEBSIZE - 2] =	{ "UCACHEBSIZE:       0x", hex },
	  [AT_IGNOREPPC - 2] =		{ "IGNOREPPC", ignore },
	  [AT_SECURE - 2] =		{ "SECURE:            ", dec },
	  [AT_BASE_PLATFORM - 2] =	{ "BASE_PLATFORM:     ", str },
	  [AT_SYSINFO - 2] =		{ "SYSINFO:           0x", hex },
	  [AT_SYSINFO_EHDR - 2] =	{ "SYSINFO_EHDR:      0x", hex },
	  [AT_RANDOM - 2] =		{ "RANDOM:            0x", hex },
	  [AT_HWCAP2 - 2] =		{ "HWCAP2:            0x", hex },
	  [AT_L1I_CACHESIZE - 2] =	{ "L1I_CACHESIZE:     ", dec },
	  [AT_L1I_CACHEGEOMETRY - 2] =	{ "L1I_CACHEGEOMETRY: 0x", hex },
	  [AT_L1D_CACHESIZE - 2] =	{ "L1D_CACHESIZE:     ", dec },
	  [AT_L1D_CACHEGEOMETRY - 2] =	{ "L1D_CACHEGEOMETRY: 0x", hex },
	  [AT_L2_CACHESIZE - 2] =	{ "L2_CACHESIZE:      ", dec },
	  [AT_L2_CACHEGEOMETRY - 2] =	{ "L2_CACHEGEOMETRY:  0x", hex },
	  [AT_L3_CACHESIZE - 2] =	{ "L3_CACHESIZE:      ", dec },
	  [AT_L3_CACHEGEOMETRY - 2] =	{ "L3_CACHEGEOMETRY:  0x", hex },
	};
      unsigned int idx = (unsigned int) (av->a_type - 2);

      if ((unsigned int) av->a_type < 2u
	  || (idx < sizeof (auxvars) / sizeof (auxvars[0])
	      && auxvars[idx].form == ignore))
	continue;

      assert (AT_NULL == 0);
      assert (AT_IGNORE == 1);

      /* Some entries are handled in a special way per platform.  */
      if (_dl_procinfo (av->a_type, av->a_un.a_val) == 0)
	continue;

      if (idx < sizeof (auxvars) / sizeof (auxvars[0])
	  && auxvars[idx].form != unknown)
	{
	  const char *val = (char *) av->a_un.a_val;

	  if (__builtin_expect (auxvars[idx].form, dec) == dec)
	    val = _itoa ((unsigned long int) av->a_un.a_val,
			 buf + sizeof buf - 1, 10, 0);
	  else if (__builtin_expect (auxvars[idx].form, hex) == hex)
	    val = _itoa ((unsigned long int) av->a_un.a_val,
			 buf + sizeof buf - 1, 16, 0);

	  _dl_printf ("AT_%s%s\n", auxvars[idx].label, val);

	  continue;
	}

      /* Unknown value: print a generic line.  */
      char buf2[17];
      buf2[sizeof (buf2) - 1] = '\0';
      const char *val2 = _itoa ((unsigned long int) av->a_un.a_val,
				buf2 + sizeof buf2 - 1, 16, 0);
      const char *val =  _itoa ((unsigned long int) av->a_type,
				buf + sizeof buf - 1, 16, 0);
      _dl_printf ("AT_??? (0x%s): 0x%s\n", val, val2);
    }
}

#endif
Commit	Line	Data
b6ab06ce	1	/* Operating system support for run-time dynamic linker. Generic Unix version.
04277e02	2	Copyright (C) 1995-2019 Free Software Foundation, Inc.
b6ab06ce UD	3	This file is part of the GNU C Library.
	4
	5	The GNU C Library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	The GNU C Library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	16	License along with the GNU C Library; if not, see
59ba27a6 PE	17	<http://www.gnu.org/licenses/>. */
b6ab06ce	18
91363dbb RM	19	/* We conditionalize the whole of this file rather than simply eliding it
	20	from the static build, because other sysdeps/ versions of this file
	21	might define things needed by a static build. */
	22
	23	#ifdef SHARED
	24
b6ab06ce UD	25	#include <assert.h>
	26	#include <elf.h>
	27	#include <errno.h>
	28	#include <fcntl.h>
	29	#include <libintl.h>
	30	#include <stdlib.h>
	31	#include <string.h>
	32	#include <unistd.h>
	33	#include <sys/types.h>
	34	#include <sys/stat.h>
	35	#include <sys/mman.h>
	36	#include <ldsodefs.h>
eb96ffb0	37	#include <_itoa.h>
b6ab06ce UD	38	#include <fpu_control.h>
	39
	40	#include <entry.h>
	41	#include <dl-machine.h>
	42	#include <dl-procinfo.h>
	43	#include <dl-osinfo.h>
54e4b8f2	44	#include <libc-internal.h>
b6ab06ce UD	45	#include <tls.h>
b6ab06ce UD	46
67e58f39 SP	47	#include <dl-tunables.h>
67e58f39 SP	48
b6ab06ce	49	extern char **_environ attribute_hidden;
b1c1949e	50	extern char _end[] attribute_hidden;
b6ab06ce UD	51
	52	/* Protect SUID program against misuse of file descriptors. */
	53	extern void __libc_check_standard_fds (void);
	54
	55	#ifdef NEED_DL_BASE_ADDR
	56	ElfW(Addr) _dl_base_addr;
	57	#endif
	58	int __libc_enable_secure attribute_relro = 0;
6bc6bd3b	59	rtld_hidden_data_def (__libc_enable_secure)
b6ab06ce UD	60	int __libc_multiple_libcs = 0; /* Defining this here avoids the inclusion
	61	of init-first. */
	62	/* This variable contains the lowest stack address ever used. */
	63	void *__libc_stack_end attribute_relro = NULL;
	64	rtld_hidden_data_def(__libc_stack_end)
965cb60a	65	void *_dl_random attribute_relro = NULL;
b6ab06ce UD	66
	67	#ifndef DL_FIND_ARG_COMPONENTS
	68	# define DL_FIND_ARG_COMPONENTS(cookie, argc, argv, envp, auxp) \
	69	do { \
	70	void **_tmp; \
	71	(argc) = (long int ) cookie; \
	72	(argv) = (char *) ((long int ) cookie + 1); \
	73	(envp) = (argv) + (argc) + 1; \
	74	for (_tmp = (void *) (envp); _tmp; ++_tmp) \
	75	continue; \
	76	(auxp) = (void *) ++_tmp; \
	77	} while (0)
	78	#endif
	79
	80	#ifndef DL_STACK_END
	81	# define DL_STACK_END(cookie) ((void *) (cookie))
	82	#endif
	83
	84	ElfW(Addr)
	85	_dl_sysdep_start (void **start_argptr,
	86	void (dl_main) (const ElfW(Phdr) phdr, ElfW(Word) phnum,
3a56ea26	87	ElfW(Addr) user_entry, ElfW(auxv_t) auxv))
b6ab06ce UD	88	{
	89	const ElfW(Phdr) *phdr = NULL;
	90	ElfW(Word) phnum = 0;
	91	ElfW(Addr) user_entry;
	92	ElfW(auxv_t) *av;
	93	#ifdef HAVE_AUX_SECURE
	94	# define set_seen(tag) (tag) /* Evaluate for the side effects. */
	95	# define set_seen_secure() ((void) 0)
	96	#else
	97	uid_t uid = 0;
	98	gid_t gid = 0;
	99	unsigned int seen = 0;
	100	# define set_seen_secure() (seen = -1)
	101	# ifdef HAVE_AUX_XID
	102	# define set_seen(tag) (tag) /* Evaluate for the side effects. */
	103	# else
	104	# define M(type) (1 << (type))
	105	# define set_seen(tag) seen \|= M ((tag)->a_type)
	106	# endif
	107	#endif
	108	#ifdef NEED_DL_SYSINFO
	109	uintptr_t new_sysinfo = 0;
	110	#endif
	111
	112	__libc_stack_end = DL_STACK_END (start_argptr);
4243cbea	113	DL_FIND_ARG_COMPONENTS (start_argptr, _dl_argc, _dl_argv, _environ,
c7683a6d	114	GLRO(dl_auxv));
b6ab06ce UD	115
	116	user_entry = (ElfW(Addr)) ENTRY_POINT;
	117	GLRO(dl_platform) = NULL; /* Default to nothing known about the platform. */
	118
c7683a6d	119	for (av = GLRO(dl_auxv); av->a_type != AT_NULL; set_seen (av++))
b6ab06ce UD	120	switch (av->a_type)
	121	{
	122	case AT_PHDR:
	123	phdr = (void *) av->a_un.a_val;
	124	break;
	125	case AT_PHNUM:
	126	phnum = av->a_un.a_val;
	127	break;
	128	case AT_PAGESZ:
	129	GLRO(dl_pagesize) = av->a_un.a_val;
	130	break;
	131	case AT_ENTRY:
	132	user_entry = av->a_un.a_val;
	133	break;
	134	#ifdef NEED_DL_BASE_ADDR
	135	case AT_BASE:
	136	_dl_base_addr = av->a_un.a_val;
	137	break;
	138	#endif
	139	#ifndef HAVE_AUX_SECURE
	140	case AT_UID:
	141	case AT_EUID:
	142	uid ^= av->a_un.a_val;
	143	break;
	144	case AT_GID:
	145	case AT_EGID:
	146	gid ^= av->a_un.a_val;
	147	break;
	148	#endif
	149	case AT_SECURE:
	150	#ifndef HAVE_AUX_SECURE
	151	seen = -1;
	152	#endif
6bc6bd3b	153	__libc_enable_secure = av->a_un.a_val;
b6ab06ce UD	154	break;
	155	case AT_PLATFORM:
	156	GLRO(dl_platform) = (void *) av->a_un.a_val;
	157	break;
	158	case AT_HWCAP:
	159	GLRO(dl_hwcap) = (unsigned long int) av->a_un.a_val;
	160	break;
1ae8bfe0 RA	161	case AT_HWCAP2:
	162	GLRO(dl_hwcap2) = (unsigned long int) av->a_un.a_val;
	163	break;
b6ab06ce UD	164	case AT_CLKTCK:
	165	GLRO(dl_clktck) = av->a_un.a_val;
	166	break;
	167	case AT_FPUCW:
	168	GLRO(dl_fpu_control) = av->a_un.a_val;
	169	break;
	170	#ifdef NEED_DL_SYSINFO
	171	case AT_SYSINFO:
	172	new_sysinfo = av->a_un.a_val;
	173	break;
	174	#endif
7775448e	175	#ifdef NEED_DL_SYSINFO_DSO
b6ab06ce UD	176	case AT_SYSINFO_EHDR:
	177	GLRO(dl_sysinfo_dso) = (void *) av->a_un.a_val;
	178	break;
	179	#endif
965cb60a UD	180	case AT_RANDOM:
	181	_dl_random = (void *) av->a_un.a_val;
	182	break;
b6ab06ce UD	183	#ifdef DL_PLATFORM_AUXV
	184	DL_PLATFORM_AUXV
	185	#endif
	186	}
	187
	188	#ifndef HAVE_AUX_SECURE
	189	if (seen != -1)
	190	{
	191	/* Fill in the values we have not gotten from the kernel through the
	192	auxiliary vector. */
	193	# ifndef HAVE_AUX_XID
	194	# define SEE(UID, var, uid) \
	195	if ((seen & M (AT_##UID)) == 0) var ^= __get##uid ()
	196	SEE (UID, uid, uid);
	197	SEE (EUID, uid, euid);
	198	SEE (GID, gid, gid);
	199	SEE (EGID, gid, egid);
	200	# endif
	201
	202	/* If one of the two pairs of IDs does not match this is a setuid
	203	or setgid run. */
6bc6bd3b	204	__libc_enable_secure = uid \| gid;
b6ab06ce UD	205	}
	206	#endif
	207
	208	#ifndef HAVE_AUX_PAGESIZE
	209	if (GLRO(dl_pagesize) == 0)
	210	GLRO(dl_pagesize) = __getpagesize ();
	211	#endif
	212
60bfd54c RM	213	#ifdef NEED_DL_SYSINFO
	214	if (new_sysinfo != 0)
	215	{
	216	# ifdef NEED_DL_SYSINFO_DSO
	217	/* Only set the sysinfo value if we also have the vsyscall DSO. */
	218	if (GLRO(dl_sysinfo_dso) != 0)
	219	# endif
	220	GLRO(dl_sysinfo) = new_sysinfo;
	221	}
b6ab06ce UD	222	#endif
b6ab06ce UD	223
67e58f39 SP	224	__tunables_init (_environ);
67e58f39 SP	225
b6ab06ce UD	226	#ifdef DL_SYSDEP_INIT
	227	DL_SYSDEP_INIT;
	228	#endif
	229
	230	#ifdef DL_PLATFORM_INIT
	231	DL_PLATFORM_INIT;
	232	#endif
	233
	234	/* Determine the length of the platform name. */
	235	if (GLRO(dl_platform) != NULL)
	236	GLRO(dl_platformlen) = strlen (GLRO(dl_platform));
	237
b1c1949e	238	if (__sbrk (0) == _end)
b6ab06ce UD	239	/* The dynamic linker was run as a program, and so the initial break
	240	starts just after our bss, at &_end. The malloc in dl-minimal.c
	241	will consume the rest of this page, so tell the kernel to move the
	242	break up that far. When the user program examines its break, it
	243	will see this new value and not clobber our data. */
	244	__sbrk (GLRO(dl_pagesize)
b1c1949e	245	- ((_end - (char *) 0) & (GLRO(dl_pagesize) - 1)));
b6ab06ce UD	246
	247	/* If this is a SUID program we make sure that FDs 0, 1, and 2 are
	248	allocated. If necessary we are doing it ourself. If it is not
	249	possible we stop the program. */
6bc6bd3b	250	if (__builtin_expect (__libc_enable_secure, 0))
b6ab06ce UD	251	__libc_check_standard_fds ();
b6ab06ce UD	252
c7683a6d	253	(*dl_main) (phdr, phnum, &user_entry, GLRO(dl_auxv));
b6ab06ce UD	254	return user_entry;
	255	}
	256
	257	void
b6ab06ce UD	258	_dl_sysdep_start_cleanup (void)
	259	{
	260	}
	261
	262	void
b6ab06ce UD	263	_dl_show_auxv (void)
	264	{
	265	char buf[64];
	266	ElfW(auxv_t) *av;
	267
	268	/* Terminate string. */
	269	buf[63] = '\0';
	270
	271	/* The following code assumes that the AT_* values are encoded
	272	starting from 0 with AT_NULL, 1 for AT_IGNORE, and all other values
	273	close by (otherwise the array will be too large). In case we have
	274	to support a platform where these requirements are not fulfilled
	275	some alternative implementation has to be used. */
c7683a6d	276	for (av = GLRO(dl_auxv); av->a_type != AT_NULL; ++av)
b6ab06ce UD	277	{
	278	static const struct
	279	{
1616d034	280	const char label[22];
f53713a8	281	enum { unknown = 0, dec, hex, str, ignore } form : 8;
b6ab06ce UD	282	} auxvars[] =
b6ab06ce UD	283	{
1616d034 TMQMF	284	[AT_EXECFD - 2] = { "EXECFD: ", dec },
	285	[AT_EXECFN - 2] = { "EXECFN: ", str },
	286	[AT_PHDR - 2] = { "PHDR: 0x", hex },
	287	[AT_PHENT - 2] = { "PHENT: ", dec },
	288	[AT_PHNUM - 2] = { "PHNUM: ", dec },
	289	[AT_PAGESZ - 2] = { "PAGESZ: ", dec },
	290	[AT_BASE - 2] = { "BASE: 0x", hex },
	291	[AT_FLAGS - 2] = { "FLAGS: 0x", hex },
	292	[AT_ENTRY - 2] = { "ENTRY: 0x", hex },
	293	[AT_NOTELF - 2] = { "NOTELF: ", hex },
	294	[AT_UID - 2] = { "UID: ", dec },
	295	[AT_EUID - 2] = { "EUID: ", dec },
	296	[AT_GID - 2] = { "GID: ", dec },
	297	[AT_EGID - 2] = { "EGID: ", dec },
	298	[AT_PLATFORM - 2] = { "PLATFORM: ", str },
	299	[AT_HWCAP - 2] = { "HWCAP: ", hex },
	300	[AT_CLKTCK - 2] = { "CLKTCK: ", dec },
	301	[AT_FPUCW - 2] = { "FPUCW: ", hex },
	302	[AT_DCACHEBSIZE - 2] = { "DCACHEBSIZE: 0x", hex },
	303	[AT_ICACHEBSIZE - 2] = { "ICACHEBSIZE: 0x", hex },
	304	[AT_UCACHEBSIZE - 2] = { "UCACHEBSIZE: 0x", hex },
f53713a8	305	[AT_IGNOREPPC - 2] = { "IGNOREPPC", ignore },
1616d034 TMQMF	306	[AT_SECURE - 2] = { "SECURE: ", dec },
	307	[AT_BASE_PLATFORM - 2] = { "BASE_PLATFORM: ", str },
	308	[AT_SYSINFO - 2] = { "SYSINFO: 0x", hex },
	309	[AT_SYSINFO_EHDR - 2] = { "SYSINFO_EHDR: 0x", hex },
	310	[AT_RANDOM - 2] = { "RANDOM: 0x", hex },
	311	[AT_HWCAP2 - 2] = { "HWCAP2: 0x", hex },
	312	[AT_L1I_CACHESIZE - 2] = { "L1I_CACHESIZE: ", dec },
	313	[AT_L1I_CACHEGEOMETRY - 2] = { "L1I_CACHEGEOMETRY: 0x", hex },
	314	[AT_L1D_CACHESIZE - 2] = { "L1D_CACHESIZE: ", dec },
	315	[AT_L1D_CACHEGEOMETRY - 2] = { "L1D_CACHEGEOMETRY: 0x", hex },
	316	[AT_L2_CACHESIZE - 2] = { "L2_CACHESIZE: ", dec },
	317	[AT_L2_CACHEGEOMETRY - 2] = { "L2_CACHEGEOMETRY: 0x", hex },
	318	[AT_L3_CACHESIZE - 2] = { "L3_CACHESIZE: ", dec },
	319	[AT_L3_CACHEGEOMETRY - 2] = { "L3_CACHEGEOMETRY: 0x", hex },
b6ab06ce UD	320	};
	321	unsigned int idx = (unsigned int) (av->a_type - 2);
	322
171a70b4 PP	323	if ((unsigned int) av->a_type < 2u
	324	\|\| (idx < sizeof (auxvars) / sizeof (auxvars[0])
	325	&& auxvars[idx].form == ignore))
b6ab06ce UD	326	continue;
	327
	328	assert (AT_NULL == 0);
	329	assert (AT_IGNORE == 1);
	330
7c651308 SL	331	/* Some entries are handled in a special way per platform. */
	332	if (_dl_procinfo (av->a_type, av->a_un.a_val) == 0)
	333	continue;
b6ab06ce UD	334
	335	if (idx < sizeof (auxvars) / sizeof (auxvars[0])
	336	&& auxvars[idx].form != unknown)
	337	{
	338	const char val = (char ) av->a_un.a_val;
	339
	340	if (__builtin_expect (auxvars[idx].form, dec) == dec)
	341	val = _itoa ((unsigned long int) av->a_un.a_val,
	342	buf + sizeof buf - 1, 10, 0);
	343	else if (__builtin_expect (auxvars[idx].form, hex) == hex)
	344	val = _itoa ((unsigned long int) av->a_un.a_val,
	345	buf + sizeof buf - 1, 16, 0);
	346
f53713a8	347	_dl_printf ("AT_%s%s\n", auxvars[idx].label, val);
b6ab06ce UD	348
	349	continue;
	350	}
	351
	352	/* Unknown value: print a generic line. */
	353	char buf2[17];
fbb04b35	354	buf2[sizeof (buf2) - 1] = '\0';
b6ab06ce UD	355	const char *val2 = _itoa ((unsigned long int) av->a_un.a_val,
	356	buf2 + sizeof buf2 - 1, 16, 0);
	357	const char *val = _itoa ((unsigned long int) av->a_type,
	358	buf + sizeof buf - 1, 16, 0);
	359	_dl_printf ("AT_??? (0x%s): 0x%s\n", val, val2);
	360	}
	361	}
	362
91363dbb	363	#endif