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
;
177 GLRO(dl_execfn
) = (void *) av
->a_un
.a_val
;
179 #ifdef DL_PLATFORM_AUXV
184 #ifndef HAVE_AUX_SECURE
187 /* Fill in the values we have not gotten from the kernel through the
189 # ifndef HAVE_AUX_XID
190 # define SEE(UID, var, uid) \
191 if ((seen & M (AT_##UID)) == 0) var ^= __get##uid ()
193 SEE (EUID
, uid
, euid
);
195 SEE (EGID
, gid
, egid
);
198 /* If one of the two pairs of IDs does not match this is a setuid
200 INTUSE(__libc_enable_secure
) = uid
| gid
;
204 #ifndef HAVE_AUX_PAGESIZE
205 if (GLRO(dl_pagesize
) == 0)
206 GLRO(dl_pagesize
) = __getpagesize ();
209 #if defined NEED_DL_SYSINFO
210 /* Only set the sysinfo value if we also have the vsyscall DSO. */
211 if (GLRO(dl_sysinfo_dso
) != 0 && new_sysinfo
)
212 GLRO(dl_sysinfo
) = new_sysinfo
;
215 #ifdef DL_SYSDEP_INIT
219 #ifdef DL_PLATFORM_INIT
223 /* Determine the length of the platform name. */
224 if (GLRO(dl_platform
) != NULL
)
225 GLRO(dl_platformlen
) = strlen (GLRO(dl_platform
));
227 if (__sbrk (0) == &_end
)
228 /* The dynamic linker was run as a program, and so the initial break
229 starts just after our bss, at &_end. The malloc in dl-minimal.c
230 will consume the rest of this page, so tell the kernel to move the
231 break up that far. When the user program examines its break, it
232 will see this new value and not clobber our data. */
233 __sbrk (GLRO(dl_pagesize
)
234 - ((&_end
- (void *) 0) & (GLRO(dl_pagesize
) - 1)));
236 /* If this is a SUID program we make sure that FDs 0, 1, and 2 are
237 allocated. If necessary we are doing it ourself. If it is not
238 possible we stop the program. */
239 if (__builtin_expect (INTUSE(__libc_enable_secure
), 0))
240 __libc_check_standard_fds ();
242 (*dl_main
) (phdr
, phnum
, &user_entry
);
248 _dl_sysdep_start_cleanup (void)
259 /* Terminate string. */
262 /* The following code assumes that the AT_* values are encoded
263 starting from 0 with AT_NULL, 1 for AT_IGNORE, and all other values
264 close by (otherwise the array will be too large). In case we have
265 to support a platform where these requirements are not fulfilled
266 some alternative implementation has to be used. */
267 for (av
= _dl_auxv
; av
->a_type
!= AT_NULL
; ++av
)
271 const char label
[20];
272 enum { unknown
= 0, dec
, hex
, str
, ignore
} form
;
275 [AT_EXECFD
- 2] = { "AT_EXECFD: ", dec
},
276 [AT_PHDR
- 2] = { "AT_PHDR: 0x", hex
},
277 [AT_PHENT
- 2] = { "AT_PHENT: ", dec
},
278 [AT_PHNUM
- 2] = { "AT_PHNUM: ", dec
},
279 [AT_PAGESZ
- 2] = { "AT_PAGESZ: ", dec
},
280 [AT_BASE
- 2] = { "AT_BASE: 0x", hex
},
281 [AT_FLAGS
- 2] = { "AT_FLAGS: 0x", hex
},
282 [AT_ENTRY
- 2] = { "AT_ENTRY: 0x", hex
},
283 [AT_NOTELF
- 2] = { "AT_NOTELF: ", hex
},
284 [AT_UID
- 2] = { "AT_UID: ", dec
},
285 [AT_EUID
- 2] = { "AT_EUID: ", dec
},
286 [AT_GID
- 2] = { "AT_GID: ", dec
},
287 [AT_EGID
- 2] = { "AT_EGID: ", dec
},
288 [AT_PLATFORM
- 2] = { "AT_PLATFORM: ", str
},
289 [AT_HWCAP
- 2] = { "AT_HWCAP: ", hex
},
290 [AT_CLKTCK
- 2] = { "AT_CLKTCK: ", dec
},
291 [AT_FPUCW
- 2] = { "AT_FPUCW: ", hex
},
292 [AT_DCACHEBSIZE
- 2] = { "AT_DCACHEBSIZE: 0x", hex
},
293 [AT_ICACHEBSIZE
- 2] = { "AT_ICACHEBSIZE: 0x", hex
},
294 [AT_UCACHEBSIZE
- 2] = { "AT_UCACHEBSIZE: 0x", hex
},
295 [AT_IGNOREPPC
- 2] = { "AT_IGNOREPPC", ignore
},
296 [AT_SECURE
- 2] = { "AT_SECURE: ", dec
},
297 [AT_SYSINFO
- 2] = { "AT_SYSINFO: 0x", hex
},
298 [AT_SYSINFO_EHDR
- 2] = { "AT_SYSINFO_EHDR: 0x", hex
},
300 unsigned int idx
= (unsigned int) (av
->a_type
- 2);
302 if ((unsigned int) av
->a_type
< 2u || auxvars
[idx
].form
== ignore
)
305 assert (AT_NULL
== 0);
306 assert (AT_IGNORE
== 1);
308 if (av
->a_type
== AT_HWCAP
)
310 /* This is handled special. */
311 if (_dl_procinfo (av
->a_un
.a_val
) == 0)
315 if (idx
< sizeof (auxvars
) / sizeof (auxvars
[0])
316 && auxvars
[idx
].form
!= unknown
)
318 const char *val
= (char *) av
->a_un
.a_val
;
320 if (__builtin_expect (auxvars
[idx
].form
, dec
) == dec
)
321 val
= _itoa ((unsigned long int) av
->a_un
.a_val
,
322 buf
+ sizeof buf
- 1, 10, 0);
323 else if (__builtin_expect (auxvars
[idx
].form
, hex
) == hex
)
324 val
= _itoa ((unsigned long int) av
->a_un
.a_val
,
325 buf
+ sizeof buf
- 1, 16, 0);
327 _dl_printf ("%s%s\n", auxvars
[idx
].label
, val
);
332 /* Unknown value: print a generic line. */
334 buf
[sizeof (buf2
) - 1] = '\0';
335 const char *val2
= _itoa ((unsigned long int) av
->a_un
.a_val
,
336 buf2
+ sizeof buf2
- 1, 16, 0);
337 const char *val
= _itoa ((unsigned long int) av
->a_type
,
338 buf
+ sizeof buf
- 1, 16, 0);
339 _dl_printf ("AT_??? (0x%s): 0x%s\n", val
, val2
);
344 /* Return an array of useful/necessary hardware capability names. */
345 const struct r_strlenpair
*
347 _dl_important_hwcaps (const char *platform
, size_t platform_len
, size_t *sz
,
348 size_t *max_capstrlen
)
350 /* Determine how many important bits are set. */
351 uint64_t masked
= GLRO(dl_hwcap
) & GLRO(dl_hwcap_mask
);
352 size_t cnt
= platform
!= NULL
;
355 struct r_strlenpair
*temp
;
356 struct r_strlenpair
*result
;
357 struct r_strlenpair
*rp
;
360 /* Count the number of bits set in the masked value. */
361 for (n
= 0; (~((1ULL << n
) - 1) & masked
) != 0; ++n
)
362 if ((masked
& (1ULL << n
)) != 0)
365 #if (defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO) && defined SHARED
366 /* The system-supplied DSO can contain a note of type 2, vendor "GNU".
367 This gives us a list of names to treat as fake hwcap bits. */
369 const char *dsocaps
= NULL
;
370 size_t dsocapslen
= 0;
371 if (GLRO(dl_sysinfo_map
) != NULL
)
373 const ElfW(Phdr
) *const phdr
= GLRO(dl_sysinfo_map
)->l_phdr
;
374 const ElfW(Word
) phnum
= GLRO(dl_sysinfo_map
)->l_phnum
;
375 for (uint_fast16_t i
= 0; i
< phnum
; ++i
)
376 if (phdr
[i
].p_type
== PT_NOTE
)
378 const ElfW(Addr
) start
= (phdr
[i
].p_vaddr
379 + GLRO(dl_sysinfo_map
)->l_addr
);
382 ElfW(Word
) vendorlen
;
385 } *note
= (const void *) start
;
386 while ((ElfW(Addr
)) (note
+ 1) - start
< phdr
[i
].p_memsz
)
388 #define ROUND(len) (((len) + sizeof (ElfW(Word)) - 1) & -sizeof (ElfW(Word)))
390 && note
->vendorlen
== sizeof "GNU"
391 && !memcmp ((note
+ 1), "GNU", sizeof "GNU")
392 && note
->datalen
> 2 * sizeof (ElfW(Word
)) + 2)
394 const ElfW(Word
) *p
= ((const void *) (note
+ 1)
395 + ROUND (sizeof "GNU"));
397 ++p
; /* Skip mask word. */
398 dsocaps
= (const char *) p
;
399 dsocapslen
= note
->datalen
- sizeof *p
* 2;
402 note
= ((const void *) (note
+ 1)
403 + ROUND (note
->vendorlen
) + ROUND (note
->datalen
));
412 /* For TLS enabled builds always add 'tls'. */
415 /* Create temporary data structure to generate result table. */
416 temp
= (struct r_strlenpair
*) alloca (cnt
* sizeof (*temp
));
418 #if defined NEED_DL_SYSINFO || defined NEED_DL_SYSINFO_DSO
421 const ElfW(Word
) mask
= ((const ElfW(Word
) *) dsocaps
)[-1];
422 GLRO(dl_hwcap
) |= (uint64_t) mask
<< _DL_FIRST_EXTRA
;
424 for (const char *p
= dsocaps
; p
< dsocaps
+ dsocapslen
; p
+= len
+ 1)
426 uint_fast8_t bit
= *p
++;
429 /* Skip entries that are not enabled in the mask word. */
430 if (__builtin_expect (mask
& ((ElfW(Word
)) 1 << bit
), 1))
441 for (n
= 0; masked
!= 0; ++n
)
442 if ((masked
& (1ULL << n
)) != 0)
444 temp
[m
].str
= _dl_hwcap_string (n
);
445 temp
[m
].len
= strlen (temp
[m
].str
);
449 if (platform
!= NULL
)
451 temp
[m
].str
= platform
;
452 temp
[m
].len
= platform_len
;
462 /* Determine the total size of all strings together. */
464 total
= temp
[0].len
+ 1;
467 total
= temp
[0].len
+ temp
[cnt
- 1].len
+ 2;
471 for (n
= 1; n
+ 1 < cnt
; ++n
)
472 total
+= temp
[n
].len
+ 1;
474 && (cnt
>= sizeof (size_t) * 8
475 || total
+ (sizeof (*result
) << 3)
476 >= (1UL << (sizeof (size_t) * 8 - cnt
+ 3))))
477 _dl_signal_error (ENOMEM
, NULL
, NULL
,
478 N_("cannot create capability list"));
484 /* The result structure: we use a very compressed way to store the
485 various combinations of capability names. */
487 result
= (struct r_strlenpair
*) malloc (*sz
* sizeof (*result
) + total
);
489 _dl_signal_error (ENOMEM
, NULL
, NULL
,
490 N_("cannot create capability list"));
494 result
[0].str
= (char *) (result
+ *sz
);
495 result
[0].len
= temp
[0].len
+ 1;
496 result
[1].str
= (char *) (result
+ *sz
);
498 cp
= __mempcpy ((char *) (result
+ *sz
), temp
[0].str
, temp
[0].len
);
501 *max_capstrlen
= result
[0].len
;
506 /* Fill in the information. This follows the following scheme
507 (indeces from TEMP for four strings):
508 entry #0: 0, 1, 2, 3 binary: 1111
512 This allows the representation of all possible combinations of
513 capability names in the string. First generate the strings. */
514 result
[1].str
= result
[0].str
= cp
= (char *) (result
+ *sz
);
516 cp = __mempcpy (__mempcpy (cp, temp[idx].str, temp[idx].len), "/", 1);
529 /* We always add the last string. */
532 /* Add the strings which have the bit set in N. */
533 for (m
= cnt
- 2; m
> 0; --m
)
534 if ((n
& (1 << m
)) != 0)
537 /* Always add the first string. */
544 /* Now we are ready to install the string pointers and length. */
545 for (n
= 0; n
< (1UL << cnt
); ++n
)
550 size_t mask
= 1 << --n
;
553 for (m
= 1 << cnt
; m
> 0; ++rp
)
554 if ((--m
& mask
) != 0)
555 rp
->len
+= temp
[n
].len
+ 1;
559 /* The first half of the strings all include the first string. */
562 while (n
!= (1UL << (cnt
- 1)))
565 rp
[0].str
= rp
[-2].str
+ rp
[-2].len
;
567 rp
[0].str
= rp
[-1].str
;
571 /* The second half starts right after the first part of the string of
572 the corresponding entry in the first half. */
575 rp
[0].str
= rp
[-(1 << (cnt
- 1))].str
+ temp
[cnt
- 1].len
+ 1;
580 /* The maximum string length. */
581 *max_capstrlen
= result
[0].len
;