1 /* Operating system support for run-time dynamic linker. Generic Unix version.
2 Copyright (C) 1995-1998, 2000-2007, 2008 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
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.
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.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
28 #include <sys/types.h>
32 #include <stdio-common/_itoa.h>
33 #include <fpu_control.h>
36 #include <dl-machine.h>
37 #include <dl-procinfo.h>
38 #include <dl-osinfo.h>
39 #include <hp-timing.h>
42 #ifdef _DL_FIRST_PLATFORM
43 # define _DL_FIRST_EXTRA (_DL_FIRST_PLATFORM + _DL_PLATFORMS_COUNT)
45 # define _DL_FIRST_EXTRA _DL_HWCAP_COUNT
48 extern char **_environ attribute_hidden
;
49 extern void _end attribute_hidden
;
51 /* Protect SUID program against misuse of file descriptors. */
52 extern void __libc_check_standard_fds (void);
54 #ifdef NEED_DL_BASE_ADDR
55 ElfW(Addr
) _dl_base_addr
;
57 int __libc_enable_secure attribute_relro
= 0;
58 INTVARDEF(__libc_enable_secure
)
59 int __libc_multiple_libcs
= 0; /* Defining this here avoids the inclusion
61 /* This variable contains the lowest stack address ever used. */
62 void *__libc_stack_end attribute_relro
= NULL
;
63 rtld_hidden_data_def(__libc_stack_end
)
64 static ElfW(auxv_t
) *_dl_auxv attribute_relro
;
66 #ifndef DL_FIND_ARG_COMPONENTS
67 # define DL_FIND_ARG_COMPONENTS(cookie, argc, argv, envp, auxp) \
70 (argc) = *(long int *) cookie; \
71 (argv) = (char **) ((long int *) cookie + 1); \
72 (envp) = (argv) + (argc) + 1; \
73 for (_tmp = (void **) (envp); *_tmp; ++_tmp) \
75 (auxp) = (void *) ++_tmp; \
80 # define DL_STACK_END(cookie) ((void *) (cookie))
84 _dl_sysdep_start (void **start_argptr
,
85 void (*dl_main
) (const ElfW(Phdr
) *phdr
, ElfW(Word
) phnum
,
86 ElfW(Addr
) *user_entry
))
88 const ElfW(Phdr
) *phdr
= NULL
;
90 ElfW(Addr
) user_entry
;
92 #ifdef HAVE_AUX_SECURE
93 # define set_seen(tag) (tag) /* Evaluate for the side effects. */
94 # define set_seen_secure() ((void) 0)
98 unsigned int seen
= 0;
99 # define set_seen_secure() (seen = -1)
101 # define set_seen(tag) (tag) /* Evaluate for the side effects. */
103 # define M(type) (1 << (type))
104 # define set_seen(tag) seen |= M ((tag)->a_type)
107 #ifdef NEED_DL_SYSINFO
108 uintptr_t new_sysinfo
= 0;
111 __libc_stack_end
= DL_STACK_END (start_argptr
);
112 DL_FIND_ARG_COMPONENTS (start_argptr
, _dl_argc
, INTUSE(_dl_argv
), _environ
,
115 user_entry
= (ElfW(Addr
)) ENTRY_POINT
;
116 GLRO(dl_platform
) = NULL
; /* Default to nothing known about the platform. */
118 for (av
= _dl_auxv
; av
->a_type
!= AT_NULL
; set_seen (av
++))
122 phdr
= (void *) av
->a_un
.a_val
;
125 phnum
= av
->a_un
.a_val
;
128 GLRO(dl_pagesize
) = av
->a_un
.a_val
;
131 user_entry
= av
->a_un
.a_val
;
133 #ifdef NEED_DL_BASE_ADDR
135 _dl_base_addr
= av
->a_un
.a_val
;
138 #ifndef HAVE_AUX_SECURE
141 uid
^= av
->a_un
.a_val
;
145 gid
^= av
->a_un
.a_val
;
149 #ifndef HAVE_AUX_SECURE
152 INTUSE(__libc_enable_secure
) = av
->a_un
.a_val
;
155 GLRO(dl_platform
) = (void *) av
->a_un
.a_val
;
158 GLRO(dl_hwcap
) = (unsigned long int) av
->a_un
.a_val
;
161 GLRO(dl_clktck
) = av
->a_un
.a_val
;
164 GLRO(dl_fpu_control
) = av
->a_un
.a_val
;
166 #ifdef NEED_DL_SYSINFO
168 new_sysinfo
= av
->a_un
.a_val
;
171 #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
172 case AT_SYSINFO_EHDR
:
173 GLRO(dl_sysinfo_dso
) = (void *) av
->a_un
.a_val
;
176 #ifdef DL_PLATFORM_AUXV
181 #ifndef HAVE_AUX_SECURE
184 /* Fill in the values we have not gotten from the kernel through the
186 # ifndef HAVE_AUX_XID
187 # define SEE(UID, var, uid) \
188 if ((seen & M (AT_##UID)) == 0) var ^= __get##uid ()
190 SEE (EUID
, uid
, euid
);
192 SEE (EGID
, gid
, egid
);
195 /* If one of the two pairs of IDs does not match this is a setuid
197 INTUSE(__libc_enable_secure
) = uid
| gid
;
201 #ifndef HAVE_AUX_PAGESIZE
202 if (GLRO(dl_pagesize
) == 0)
203 GLRO(dl_pagesize
) = __getpagesize ();
206 #if defined NEED_DL_SYSINFO
207 /* Only set the sysinfo value if we also have the vsyscall DSO. */
208 if (GLRO(dl_sysinfo_dso
) != 0 && new_sysinfo
)
209 GLRO(dl_sysinfo
) = new_sysinfo
;
212 #ifdef DL_SYSDEP_INIT
216 #ifdef DL_PLATFORM_INIT
220 /* Determine the length of the platform name. */
221 if (GLRO(dl_platform
) != NULL
)
222 GLRO(dl_platformlen
) = strlen (GLRO(dl_platform
));
224 if (__sbrk (0) == &_end
)
225 /* The dynamic linker was run as a program, and so the initial break
226 starts just after our bss, at &_end. The malloc in dl-minimal.c
227 will consume the rest of this page, so tell the kernel to move the
228 break up that far. When the user program examines its break, it
229 will see this new value and not clobber our data. */
230 __sbrk (GLRO(dl_pagesize
)
231 - ((&_end
- (void *) 0) & (GLRO(dl_pagesize
) - 1)));
233 /* If this is a SUID program we make sure that FDs 0, 1, and 2 are
234 allocated. If necessary we are doing it ourself. If it is not
235 possible we stop the program. */
236 if (__builtin_expect (INTUSE(__libc_enable_secure
), 0))
237 __libc_check_standard_fds ();
239 (*dl_main
) (phdr
, phnum
, &user_entry
);
245 _dl_sysdep_start_cleanup (void)
256 /* Terminate string. */
259 /* The following code assumes that the AT_* values are encoded
260 starting from 0 with AT_NULL, 1 for AT_IGNORE, and all other values
261 close by (otherwise the array will be too large). In case we have
262 to support a platform where these requirements are not fulfilled
263 some alternative implementation has to be used. */
264 for (av
= _dl_auxv
; av
->a_type
!= AT_NULL
; ++av
)
268 const char label
[20];
269 enum { unknown
= 0, dec
, hex
, str
, ignore
} form
;
272 [AT_EXECFD
- 2] = { "AT_EXECFD: ", dec
},
273 [AT_EXECFN
- 2] = { "AT_EXECFN: ", str
},
274 [AT_PHDR
- 2] = { "AT_PHDR: 0x", hex
},
275 [AT_PHENT
- 2] = { "AT_PHENT: ", dec
},
276 [AT_PHNUM
- 2] = { "AT_PHNUM: ", dec
},
277 [AT_PAGESZ
- 2] = { "AT_PAGESZ: ", dec
},
278 [AT_BASE
- 2] = { "AT_BASE: 0x", hex
},
279 [AT_FLAGS
- 2] = { "AT_FLAGS: 0x", hex
},
280 [AT_ENTRY
- 2] = { "AT_ENTRY: 0x", hex
},
281 [AT_NOTELF
- 2] = { "AT_NOTELF: ", hex
},
282 [AT_UID
- 2] = { "AT_UID: ", dec
},
283 [AT_EUID
- 2] = { "AT_EUID: ", dec
},
284 [AT_GID
- 2] = { "AT_GID: ", dec
},
285 [AT_EGID
- 2] = { "AT_EGID: ", dec
},
286 [AT_PLATFORM
- 2] = { "AT_PLATFORM: ", str
},
287 [AT_HWCAP
- 2] = { "AT_HWCAP: ", hex
},
288 [AT_CLKTCK
- 2] = { "AT_CLKTCK: ", dec
},
289 [AT_FPUCW
- 2] = { "AT_FPUCW: ", hex
},
290 [AT_DCACHEBSIZE
- 2] = { "AT_DCACHEBSIZE: 0x", hex
},
291 [AT_ICACHEBSIZE
- 2] = { "AT_ICACHEBSIZE: 0x", hex
},
292 [AT_UCACHEBSIZE
- 2] = { "AT_UCACHEBSIZE: 0x", hex
},
293 [AT_IGNOREPPC
- 2] = { "AT_IGNOREPPC", ignore
},
294 [AT_SECURE
- 2] = { "AT_SECURE: ", dec
},
295 [AT_SYSINFO
- 2] = { "AT_SYSINFO: 0x", hex
},
296 [AT_SYSINFO_EHDR
- 2] = { "AT_SYSINFO_EHDR: 0x", hex
},
298 unsigned int idx
= (unsigned int) (av
->a_type
- 2);
300 if ((unsigned int) av
->a_type
< 2u || auxvars
[idx
].form
== ignore
)
303 assert (AT_NULL
== 0);
304 assert (AT_IGNORE
== 1);
306 if (av
->a_type
== AT_HWCAP
)
308 /* This is handled special. */
309 if (_dl_procinfo (av
->a_un
.a_val
) == 0)
313 if (idx
< sizeof (auxvars
) / sizeof (auxvars
[0])
314 && auxvars
[idx
].form
!= unknown
)
316 const char *val
= (char *) av
->a_un
.a_val
;
318 if (__builtin_expect (auxvars
[idx
].form
, dec
) == dec
)
319 val
= _itoa ((unsigned long int) av
->a_un
.a_val
,
320 buf
+ sizeof buf
- 1, 10, 0);
321 else if (__builtin_expect (auxvars
[idx
].form
, hex
) == hex
)
322 val
= _itoa ((unsigned long int) av
->a_un
.a_val
,
323 buf
+ sizeof buf
- 1, 16, 0);
325 _dl_printf ("%s%s\n", auxvars
[idx
].label
, val
);
330 /* Unknown value: print a generic line. */
332 buf
[sizeof (buf2
) - 1] = '\0';
333 const char *val2
= _itoa ((unsigned long int) av
->a_un
.a_val
,
334 buf2
+ sizeof buf2
- 1, 16, 0);
335 const char *val
= _itoa ((unsigned long int) av
->a_type
,
336 buf
+ sizeof buf
- 1, 16, 0);
337 _dl_printf ("AT_??? (0x%s): 0x%s\n", val
, val2
);
342 /* Return an array of useful/necessary hardware capability names. */
343 const struct r_strlenpair
*
345 _dl_important_hwcaps (const char *platform
, size_t platform_len
, size_t *sz
,
346 size_t *max_capstrlen
)
348 /* Determine how many important bits are set. */
349 uint64_t masked
= GLRO(dl_hwcap
) & GLRO(dl_hwcap_mask
);
350 size_t cnt
= platform
!= NULL
;
353 struct r_strlenpair
*temp
;
354 struct r_strlenpair
*result
;
355 struct r_strlenpair
*rp
;
358 /* Count the number of bits set in the masked value. */
359 for (n
= 0; (~((1ULL << n
) - 1) & masked
) != 0; ++n
)
360 if ((masked
& (1ULL << n
)) != 0)
363 #if (defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO) && defined SHARED
364 /* The system-supplied DSO can contain a note of type 2, vendor "GNU".
365 This gives us a list of names to treat as fake hwcap bits. */
367 const char *dsocaps
= NULL
;
368 size_t dsocapslen
= 0;
369 if (GLRO(dl_sysinfo_map
) != NULL
)
371 const ElfW(Phdr
) *const phdr
= GLRO(dl_sysinfo_map
)->l_phdr
;
372 const ElfW(Word
) phnum
= GLRO(dl_sysinfo_map
)->l_phnum
;
373 for (uint_fast16_t i
= 0; i
< phnum
; ++i
)
374 if (phdr
[i
].p_type
== PT_NOTE
)
376 const ElfW(Addr
) start
= (phdr
[i
].p_vaddr
377 + GLRO(dl_sysinfo_map
)->l_addr
);
380 ElfW(Word
) vendorlen
;
383 } *note
= (const void *) start
;
384 while ((ElfW(Addr
)) (note
+ 1) - start
< phdr
[i
].p_memsz
)
386 #define ROUND(len) (((len) + sizeof (ElfW(Word)) - 1) & -sizeof (ElfW(Word)))
388 && note
->vendorlen
== sizeof "GNU"
389 && !memcmp ((note
+ 1), "GNU", sizeof "GNU")
390 && note
->datalen
> 2 * sizeof (ElfW(Word
)) + 2)
392 const ElfW(Word
) *p
= ((const void *) (note
+ 1)
393 + ROUND (sizeof "GNU"));
395 ++p
; /* Skip mask word. */
396 dsocaps
= (const char *) p
;
397 dsocapslen
= note
->datalen
- sizeof *p
* 2;
400 note
= ((const void *) (note
+ 1)
401 + ROUND (note
->vendorlen
) + ROUND (note
->datalen
));
410 /* For TLS enabled builds always add 'tls'. */
413 /* Create temporary data structure to generate result table. */
414 temp
= (struct r_strlenpair
*) alloca (cnt
* sizeof (*temp
));
416 #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
419 const ElfW(Word
) mask
= ((const ElfW(Word
) *) dsocaps
)[-1];
420 GLRO(dl_hwcap
) |= (uint64_t) mask
<< _DL_FIRST_EXTRA
;
422 for (const char *p
= dsocaps
; p
< dsocaps
+ dsocapslen
; p
+= len
+ 1)
424 uint_fast8_t bit
= *p
++;
427 /* Skip entries that are not enabled in the mask word. */
428 if (__builtin_expect (mask
& ((ElfW(Word
)) 1 << bit
), 1))
439 for (n
= 0; masked
!= 0; ++n
)
440 if ((masked
& (1ULL << n
)) != 0)
442 temp
[m
].str
= _dl_hwcap_string (n
);
443 temp
[m
].len
= strlen (temp
[m
].str
);
447 if (platform
!= NULL
)
449 temp
[m
].str
= platform
;
450 temp
[m
].len
= platform_len
;
460 /* Determine the total size of all strings together. */
462 total
= temp
[0].len
+ 1;
465 total
= temp
[0].len
+ temp
[cnt
- 1].len
+ 2;
469 for (n
= 1; n
+ 1 < cnt
; ++n
)
470 total
+= temp
[n
].len
+ 1;
472 && (cnt
>= sizeof (size_t) * 8
473 || total
+ (sizeof (*result
) << 3)
474 >= (1UL << (sizeof (size_t) * 8 - cnt
+ 3))))
475 _dl_signal_error (ENOMEM
, NULL
, NULL
,
476 N_("cannot create capability list"));
482 /* The result structure: we use a very compressed way to store the
483 various combinations of capability names. */
485 result
= (struct r_strlenpair
*) malloc (*sz
* sizeof (*result
) + total
);
487 _dl_signal_error (ENOMEM
, NULL
, NULL
,
488 N_("cannot create capability list"));
492 result
[0].str
= (char *) (result
+ *sz
);
493 result
[0].len
= temp
[0].len
+ 1;
494 result
[1].str
= (char *) (result
+ *sz
);
496 cp
= __mempcpy ((char *) (result
+ *sz
), temp
[0].str
, temp
[0].len
);
499 *max_capstrlen
= result
[0].len
;
504 /* Fill in the information. This follows the following scheme
505 (indeces from TEMP for four strings):
506 entry #0: 0, 1, 2, 3 binary: 1111
510 This allows the representation of all possible combinations of
511 capability names in the string. First generate the strings. */
512 result
[1].str
= result
[0].str
= cp
= (char *) (result
+ *sz
);
514 cp = __mempcpy (__mempcpy (cp, temp[idx].str, temp[idx].len), "/", 1);
527 /* We always add the last string. */
530 /* Add the strings which have the bit set in N. */
531 for (m
= cnt
- 2; m
> 0; --m
)
532 if ((n
& (1 << m
)) != 0)
535 /* Always add the first string. */
542 /* Now we are ready to install the string pointers and length. */
543 for (n
= 0; n
< (1UL << cnt
); ++n
)
548 size_t mask
= 1 << --n
;
551 for (m
= 1 << cnt
; m
> 0; ++rp
)
552 if ((--m
& mask
) != 0)
553 rp
->len
+= temp
[n
].len
+ 1;
557 /* The first half of the strings all include the first string. */
560 while (n
!= (1UL << (cnt
- 1)))
563 rp
[0].str
= rp
[-2].str
+ rp
[-2].len
;
565 rp
[0].str
= rp
[-1].str
;
569 /* The second half starts right after the first part of the string of
570 the corresponding entry in the first half. */
573 rp
[0].str
= rp
[-(1 << (cnt
- 1))].str
+ temp
[cnt
- 1].len
+ 1;
578 /* The maximum string length. */
579 *max_capstrlen
= result
[0].len
;