1 /* Minimal replacements for basic facilities used in the dynamic linker.
2 Copyright (C) 1995-2016 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, see
17 <http://www.gnu.org/licenses/>. */
26 #include <sys/param.h>
27 #include <sys/types.h>
33 /* Minimal `malloc' allocator for use while loading shared libraries.
34 No block is ever freed. */
36 static void *alloc_ptr
, *alloc_end
, *alloc_last_block
;
38 /* Declarations of global functions. */
39 extern void weak_function
free (void *ptr
);
40 extern void * weak_function
realloc (void *ptr
, size_t n
);
41 extern unsigned long int weak_function
__strtoul_internal (const char *nptr
,
45 extern unsigned long int weak_function
strtoul (const char *nptr
,
46 char **endptr
, int base
);
49 /* Allocate an aligned memory block. */
51 __libc_memalign (size_t align
, size_t n
)
55 /* Consume any unused space in the last page of our data segment. */
56 extern int _end attribute_hidden
;
58 alloc_end
= (void *) 0 + (((alloc_ptr
- (void *) 0)
59 + GLRO(dl_pagesize
) - 1)
60 & ~(GLRO(dl_pagesize
) - 1));
63 /* Make sure the allocation pointer is ideally aligned. */
64 alloc_ptr
= (void *) 0 + (((alloc_ptr
- (void *) 0) + align
- 1)
67 if (alloc_ptr
+ n
>= alloc_end
|| n
>= -(uintptr_t) alloc_ptr
)
69 /* Insufficient space left; allocate another page plus one extra
70 page to reduce number of mmap calls. */
72 size_t nup
= (n
+ GLRO(dl_pagesize
) - 1) & ~(GLRO(dl_pagesize
) - 1);
73 if (__glibc_unlikely (nup
== 0 && n
!= 0))
75 nup
+= GLRO(dl_pagesize
);
76 page
= __mmap (0, nup
, PROT_READ
|PROT_WRITE
,
77 MAP_ANON
|MAP_PRIVATE
, -1, 0);
78 if (page
== MAP_FAILED
)
80 if (page
!= alloc_end
)
82 alloc_end
= page
+ nup
;
85 alloc_last_block
= (void *) alloc_ptr
;
87 return alloc_last_block
;
93 return __libc_memalign (sizeof (double), n
);
96 /* We use this function occasionally since the real implementation may
97 be optimized when it can assume the memory it returns already is
100 calloc (size_t nmemb
, size_t size
)
102 /* New memory from the trivial malloc above is always already cleared.
103 (We make sure that's true in the rare occasion it might not be,
104 by clearing memory in free, below.) */
105 size_t bytes
= nmemb
* size
;
107 #define HALF_SIZE_T (((size_t) 1) << (8 * sizeof (size_t) / 2))
108 if (__builtin_expect ((nmemb
| size
) >= HALF_SIZE_T
, 0)
109 && size
!= 0 && bytes
/ size
!= nmemb
)
112 return malloc (bytes
);
115 /* This will rarely be called. */
119 /* We can free only the last block allocated. */
120 if (ptr
== alloc_last_block
)
122 /* Since this is rare, we clear the freed block here
123 so that calloc can presume malloc returns cleared memory. */
124 memset (alloc_last_block
, '\0', alloc_ptr
- alloc_last_block
);
125 alloc_ptr
= alloc_last_block
;
129 /* This is only called with the most recent block returned by malloc. */
131 realloc (void *ptr
, size_t n
)
135 assert (ptr
== alloc_last_block
);
136 size_t old_size
= alloc_ptr
- alloc_last_block
;
137 alloc_ptr
= alloc_last_block
;
138 void *new = malloc (n
);
139 return new != ptr
? memcpy (new, ptr
, old_size
) : new;
142 /* Avoid signal frobnication in setjmp/longjmp. Keeps things smaller. */
147 __sigjmp_save (sigjmp_buf env
, int savemask
__attribute__ ((unused
)))
149 env
[0].__mask_was_saved
= 0;
153 /* Define our own version of the internal function used by strerror. We
154 only provide the messages for some common errors. This avoids pulling
155 in the whole error list. */
158 __strerror_r (int errnum
, char *buf
, size_t buflen
)
165 msg
= (char *) "Cannot allocate memory";
168 msg
= (char *) "Invalid argument";
171 msg
= (char *) "No such file or directory";
174 msg
= (char *) "Operation not permitted";
177 msg
= (char *) "Input/output error";
180 msg
= (char *) "Permission denied";
183 /* No need to check buffer size, all calls in the dynamic linker
184 provide enough space. */
185 buf
[buflen
- 1] = '\0';
186 msg
= _itoa (errnum
, buf
+ buflen
- 1, 10, 0);
187 msg
= memcpy (msg
- (sizeof ("Error ") - 1), "Error ",
188 sizeof ("Error ") - 1);
196 __libc_fatal (const char *message
)
198 _dl_fatal_printf ("%s", message
);
200 rtld_hidden_def (__libc_fatal
)
203 __attribute__ ((noreturn
))
208 rtld_hidden_def (__chk_fail
)
211 /* Define (weakly) our own assert failure function which doesn't use stdio.
212 If we are linked into the user program (-ldl), the normal __assert_fail
213 defn can override this one. */
216 __assert_fail (const char *assertion
,
217 const char *file
, unsigned int line
, const char *function
)
220 Inconsistency detected by ld.so: %s: %u: %s%sAssertion `%s' failed!\n",
221 file
, line
, function
?: "", function
? ": " : "",
225 rtld_hidden_weak (__assert_fail
)
228 __assert_perror_fail (int errnum
,
229 const char *file
, unsigned int line
,
230 const char *function
)
234 Inconsistency detected by ld.so: %s: %u: %s%sUnexpected error: %s.\n",
235 file
, line
, function
?: "", function
? ": " : "",
236 __strerror_r (errnum
, errbuf
, sizeof errbuf
));
239 rtld_hidden_weak (__assert_perror_fail
)
242 unsigned long int weak_function
243 __strtoul_internal (const char *nptr
, char **endptr
, int base
, int group
)
245 unsigned long int result
= 0;
249 while (*nptr
== ' ' || *nptr
== '\t')
257 else if (*nptr
== '+')
260 if (*nptr
< '0' || *nptr
> '9')
263 *endptr
= (char *) nptr
;
272 if (nptr
[1] == 'x' || nptr
[1] == 'X')
286 unsigned long int digval
;
287 if (*nptr
>= '0' && *nptr
<= '0' + max_digit
)
288 digval
= *nptr
- '0';
291 if (*nptr
>= 'a' && *nptr
<= 'f')
292 digval
= *nptr
- 'a' + 10;
293 else if (*nptr
>= 'A' && *nptr
<= 'F')
294 digval
= *nptr
- 'A' + 10;
301 if (result
> ULONG_MAX
/ base
302 || (result
== ULONG_MAX
/ base
&& digval
> ULONG_MAX
% base
))
306 *endptr
= (char *) nptr
;
315 *endptr
= (char *) nptr
;
316 return result
* sign
;
321 /* We always use _itoa instead of _itoa_word in ld.so since the former
322 also has to be present and it is never about speed when these
323 functions are used. */
325 _itoa (unsigned long long int value
, char *buflim
, unsigned int base
,
328 assert (! upper_case
);
331 *--buflim
= _itoa_lower_digits
[value
% base
];
332 while ((value
/= base
) != 0);
337 /* The '_itoa_lower_digits' variable in libc.so is able to handle bases
338 up to 36. We don't need this here. */
339 const char _itoa_lower_digits
[16] = "0123456789abcdef";
340 rtld_hidden_data_def (_itoa_lower_digits
)
342 /* The following is not a complete strsep implementation. It cannot
343 handle empty delimiter strings. But this isn't necessary for the
344 execution of ld.so. */
348 __strsep (char **stringp
, const char *delim
)
352 assert (delim
[0] != '\0');
359 while (*end
!= '\0' || (end
= NULL
))
361 const char *dp
= delim
;
366 while (*++dp
!= '\0');
382 weak_alias (__strsep
, strsep
)
383 strong_alias (__strsep
, __strsep_g
)