1 /* Minimal replacements for basic facilities used in the dynamic linker.
2 Copyright (C) 1995-2012 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/>. */
25 #include <sys/param.h>
26 #include <sys/types.h>
32 /* Minimal `malloc' allocator for use while loading shared libraries.
33 No block is ever freed. */
35 static void *alloc_ptr, *alloc_end, *alloc_last_block;
37 /* Declarations of global functions. */
38 extern void weak_function free (void *ptr);
39 extern void * weak_function realloc (void *ptr, size_t n);
40 extern unsigned long int weak_function __strtoul_internal (const char *nptr,
44 extern unsigned long int weak_function strtoul (const char *nptr,
45 char **endptr, int base);
48 /* Allocate an aligned memory block. */
50 __libc_memalign (size_t align, size_t n)
54 /* Consume any unused space in the last page of our data segment. */
55 extern int _end attribute_hidden;
57 alloc_end = (void *) 0 + (((alloc_ptr - (void *) 0)
58 + GLRO(dl_pagesize) - 1)
59 & ~(GLRO(dl_pagesize) - 1));
62 /* Make sure the allocation pointer is ideally aligned. */
63 alloc_ptr = (void *) 0 + (((alloc_ptr - (void *) 0) + align - 1)
66 if (alloc_ptr + n >= alloc_end || n >= -(uintptr_t) alloc_ptr)
68 /* Insufficient space left; allocate another page. */
70 size_t nup = (n + GLRO(dl_pagesize) - 1) & ~(GLRO(dl_pagesize) - 1);
71 if (__builtin_expect (nup == 0, 0))
75 nup = GLRO(dl_pagesize);
77 page = __mmap (0, nup, PROT_READ|PROT_WRITE,
78 MAP_ANON|MAP_PRIVATE, -1, 0);
79 if (page == MAP_FAILED)
81 if (page != alloc_end)
83 alloc_end = page + nup;
86 alloc_last_block = (void *) alloc_ptr;
88 return alloc_last_block;
94 return __libc_memalign (sizeof (double), n);
97 /* We use this function occasionally since the real implementation may
98 be optimized when it can assume the memory it returns already is
101 calloc (size_t nmemb, size_t size)
103 /* New memory from the trivial malloc above is always already cleared.
104 (We make sure that's true in the rare occasion it might not be,
105 by clearing memory in free, below.) */
106 size_t bytes = nmemb * size;
108 #define HALF_SIZE_T (((size_t) 1) << (8 * sizeof (size_t) / 2))
109 if (__builtin_expect ((nmemb | size) >= HALF_SIZE_T, 0)
110 && size != 0 && bytes / size != nmemb)
113 return malloc (bytes);
116 /* This will rarely be called. */
120 /* We can free only the last block allocated. */
121 if (ptr == alloc_last_block)
123 /* Since this is rare, we clear the freed block here
124 so that calloc can presume malloc returns cleared memory. */
125 memset (alloc_last_block, '\0', alloc_ptr - alloc_last_block);
126 alloc_ptr = alloc_last_block;
130 /* This is only called with the most recent block returned by malloc. */
132 realloc (void *ptr, size_t n)
136 assert (ptr == alloc_last_block);
137 size_t old_size = alloc_ptr - alloc_last_block;
138 alloc_ptr = alloc_last_block;
139 void *new = malloc (n);
140 return new != ptr ? memcpy (new, ptr, old_size) : new;
143 /* Avoid signal frobnication in setjmp/longjmp. Keeps things smaller. */
148 __sigjmp_save (sigjmp_buf env, int savemask __attribute__ ((unused)))
150 env[0].__mask_was_saved = 0;
154 /* Define our own version of the internal function used by strerror. We
155 only provide the messages for some common errors. This avoids pulling
156 in the whole error list. */
159 __strerror_r (int errnum, char *buf, size_t buflen)
166 msg = (char *) "Cannot allocate memory";
169 msg = (char *) "Invalid argument";
172 msg = (char *) "No such file or directory";
175 msg = (char *) "Operation not permitted";
178 msg = (char *) "Input/output error";
181 msg = (char *) "Permission denied";
184 /* No need to check buffer size, all calls in the dynamic linker
185 provide enough space. */
186 buf[buflen - 1] = '\0';
187 msg = _itoa (errnum, buf + buflen - 1, 10, 0);
188 msg = memcpy (msg - (sizeof ("Error ") - 1), "Error ",
189 sizeof ("Error ") - 1);
198 /* Define (weakly) our own assert failure function which doesn't use stdio.
199 If we are linked into the user program (-ldl), the normal __assert_fail
200 defn can override this one. */
203 __assert_fail (const char *assertion,
204 const char *file, unsigned int line, const char *function)
207 Inconsistency detected by ld.so: %s: %u: %s%sAssertion `%s' failed!\n",
208 file, line, function ?: "", function ? ": " : "",
212 rtld_hidden_weak(__assert_fail)
215 __assert_perror_fail (int errnum,
216 const char *file, unsigned int line,
217 const char *function)
221 Inconsistency detected by ld.so: %s: %u: %s%sUnexpected error: %s.\n",
222 file, line, function ?: "", function ? ": " : "",
223 __strerror_r (errnum, errbuf, sizeof errbuf));
226 rtld_hidden_weak (__assert_perror_fail)
229 unsigned long int weak_function
230 __strtoul_internal (const char *nptr, char **endptr, int base, int group)
232 unsigned long int result = 0;
236 while (*nptr == ' ' || *nptr == '\t')
244 else if (*nptr == '+')
247 if (*nptr < '0' || *nptr > '9')
250 *endptr = (char *) nptr;
259 if (nptr[1] == 'x' || nptr[1] == 'X')
273 unsigned long int digval;
274 if (*nptr >= '0' && *nptr <= '0' + max_digit)
275 digval = *nptr - '0';
278 if (*nptr >= 'a' && *nptr <= 'f')
279 digval = *nptr - 'a' + 10;
280 else if (*nptr >= 'A' && *nptr <= 'F')
281 digval = *nptr - 'A' + 10;
288 if (result > ULONG_MAX / base
289 || (result == ULONG_MAX / base && digval > ULONG_MAX % base))
293 *endptr = (char *) nptr;
302 *endptr = (char *) nptr;
303 return result * sign;
308 /* We always use _itoa instead of _itoa_word in ld.so since the former
309 also has to be present and it is never about speed when these
310 functions are used. */
312 _itoa (value, buflim, base, upper_case)
313 unsigned long long int value;
318 assert (! upper_case);
321 *--buflim = _itoa_lower_digits[value % base];
322 while ((value /= base) != 0);
328 /* The following is not a complete strsep implementation. It cannot
329 handle empty delimiter strings. But this isn't necessary for the
330 execution of ld.so. */
334 __strsep (char **stringp, const char *delim)
338 assert (delim[0] != '\0');
345 while (*end != '\0' || (end = NULL))
347 const char *dp = delim;
352 while (*++dp != '\0');
368 weak_alias (__strsep, strsep)
369 strong_alias (__strsep, __strsep_g)
372 __attribute__ ((noreturn))
377 rtld_hidden_def (__chk_fail)
379 /* The '_itoa_lower_digits' variable in libc.so is able to handle bases
380 up to 36. We don't need this here. */
381 const char _itoa_lower_digits[16] = "0123456789abcdef";
382 rtld_hidden_data_def (_itoa_lower_digits)