1 /* Minimal replacements for basic facilities used in the dynamic linker.
2 Copyright (C) 1995-2015 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. */
71 size_t nup
= (n
+ GLRO(dl_pagesize
) - 1) & ~(GLRO(dl_pagesize
) - 1);
72 if (__glibc_unlikely (nup
== 0))
76 nup
= GLRO(dl_pagesize
);
78 page
= __mmap (0, nup
, PROT_READ
|PROT_WRITE
,
79 MAP_ANON
|MAP_PRIVATE
, -1, 0);
80 if (page
== MAP_FAILED
)
82 if (page
!= alloc_end
)
84 alloc_end
= page
+ nup
;
87 alloc_last_block
= (void *) alloc_ptr
;
89 return alloc_last_block
;
95 return __libc_memalign (sizeof (double), n
);
98 /* We use this function occasionally since the real implementation may
99 be optimized when it can assume the memory it returns already is
102 calloc (size_t nmemb
, size_t size
)
104 /* New memory from the trivial malloc above is always already cleared.
105 (We make sure that's true in the rare occasion it might not be,
106 by clearing memory in free, below.) */
107 size_t bytes
= nmemb
* size
;
109 #define HALF_SIZE_T (((size_t) 1) << (8 * sizeof (size_t) / 2))
110 if (__builtin_expect ((nmemb
| size
) >= HALF_SIZE_T
, 0)
111 && size
!= 0 && bytes
/ size
!= nmemb
)
114 return malloc (bytes
);
117 /* This will rarely be called. */
121 /* We can free only the last block allocated. */
122 if (ptr
== alloc_last_block
)
124 /* Since this is rare, we clear the freed block here
125 so that calloc can presume malloc returns cleared memory. */
126 memset (alloc_last_block
, '\0', alloc_ptr
- alloc_last_block
);
127 alloc_ptr
= alloc_last_block
;
131 /* This is only called with the most recent block returned by malloc. */
133 realloc (void *ptr
, size_t n
)
137 assert (ptr
== alloc_last_block
);
138 size_t old_size
= alloc_ptr
- alloc_last_block
;
139 alloc_ptr
= alloc_last_block
;
140 void *new = malloc (n
);
141 return new != ptr
? memcpy (new, ptr
, old_size
) : new;
144 /* Avoid signal frobnication in setjmp/longjmp. Keeps things smaller. */
149 __sigjmp_save (sigjmp_buf env
, int savemask
__attribute__ ((unused
)))
151 env
[0].__mask_was_saved
= 0;
155 /* Define our own version of the internal function used by strerror. We
156 only provide the messages for some common errors. This avoids pulling
157 in the whole error list. */
160 __strerror_r (int errnum
, char *buf
, size_t buflen
)
167 msg
= (char *) "Cannot allocate memory";
170 msg
= (char *) "Invalid argument";
173 msg
= (char *) "No such file or directory";
176 msg
= (char *) "Operation not permitted";
179 msg
= (char *) "Input/output error";
182 msg
= (char *) "Permission denied";
185 /* No need to check buffer size, all calls in the dynamic linker
186 provide enough space. */
187 buf
[buflen
- 1] = '\0';
188 msg
= _itoa (errnum
, buf
+ buflen
- 1, 10, 0);
189 msg
= memcpy (msg
- (sizeof ("Error ") - 1), "Error ",
190 sizeof ("Error ") - 1);
198 __libc_fatal (const char *message
)
200 _dl_fatal_printf ("%s", message
);
202 rtld_hidden_def (__libc_fatal
)
205 __attribute__ ((noreturn
))
210 rtld_hidden_def (__chk_fail
)
213 /* Define (weakly) our own assert failure function which doesn't use stdio.
214 If we are linked into the user program (-ldl), the normal __assert_fail
215 defn can override this one. */
218 __assert_fail (const char *assertion
,
219 const char *file
, unsigned int line
, const char *function
)
222 Inconsistency detected by ld.so: %s: %u: %s%sAssertion `%s' failed!\n",
223 file
, line
, function
?: "", function
? ": " : "",
227 rtld_hidden_weak (__assert_fail
)
230 __assert_perror_fail (int errnum
,
231 const char *file
, unsigned int line
,
232 const char *function
)
236 Inconsistency detected by ld.so: %s: %u: %s%sUnexpected error: %s.\n",
237 file
, line
, function
?: "", function
? ": " : "",
238 __strerror_r (errnum
, errbuf
, sizeof errbuf
));
241 rtld_hidden_weak (__assert_perror_fail
)
244 unsigned long int weak_function
245 __strtoul_internal (const char *nptr
, char **endptr
, int base
, int group
)
247 unsigned long int result
= 0;
251 while (*nptr
== ' ' || *nptr
== '\t')
259 else if (*nptr
== '+')
262 if (*nptr
< '0' || *nptr
> '9')
265 *endptr
= (char *) nptr
;
274 if (nptr
[1] == 'x' || nptr
[1] == 'X')
288 unsigned long int digval
;
289 if (*nptr
>= '0' && *nptr
<= '0' + max_digit
)
290 digval
= *nptr
- '0';
293 if (*nptr
>= 'a' && *nptr
<= 'f')
294 digval
= *nptr
- 'a' + 10;
295 else if (*nptr
>= 'A' && *nptr
<= 'F')
296 digval
= *nptr
- 'A' + 10;
303 if (result
> ULONG_MAX
/ base
304 || (result
== ULONG_MAX
/ base
&& digval
> ULONG_MAX
% base
))
308 *endptr
= (char *) nptr
;
317 *endptr
= (char *) nptr
;
318 return result
* sign
;
323 /* We always use _itoa instead of _itoa_word in ld.so since the former
324 also has to be present and it is never about speed when these
325 functions are used. */
327 _itoa (value
, buflim
, base
, upper_case
)
328 unsigned long long int value
;
333 assert (! upper_case
);
336 *--buflim
= _itoa_lower_digits
[value
% base
];
337 while ((value
/= base
) != 0);
342 /* The '_itoa_lower_digits' variable in libc.so is able to handle bases
343 up to 36. We don't need this here. */
344 const char _itoa_lower_digits
[16] = "0123456789abcdef";
345 rtld_hidden_data_def (_itoa_lower_digits
)
347 /* The following is not a complete strsep implementation. It cannot
348 handle empty delimiter strings. But this isn't necessary for the
349 execution of ld.so. */
353 __strsep (char **stringp
, const char *delim
)
357 assert (delim
[0] != '\0');
364 while (*end
!= '\0' || (end
= NULL
))
366 const char *dp
= delim
;
371 while (*++dp
!= '\0');
387 weak_alias (__strsep
, strsep
)
388 strong_alias (__strsep
, __strsep_g
)