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.
4
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.
9
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.
14
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/>. */
18
19#include <errno.h>
20#include <limits.h>
21#include <stdio.h>
22#include <string.h>
23#include <tls.h>
24#include <unistd.h>
25#include <sys/mman.h>
26#include <sys/param.h>
27#include <sys/types.h>
28#include <ldsodefs.h>
29#include <_itoa.h>
30
31#include <assert.h>
32
33/* Minimal `malloc' allocator for use while loading shared libraries.
34 No block is ever freed. */
35
36static void *alloc_ptr, *alloc_end, *alloc_last_block;
37
38/* Declarations of global functions. */
39extern void weak_function free (void *ptr);
40extern void * weak_function realloc (void *ptr, size_t n);
41extern unsigned long int weak_function __strtoul_internal (const char *nptr,
42 char **endptr,
43 int base,
44 int group);
45extern unsigned long int weak_function strtoul (const char *nptr,
46 char **endptr, int base);
47
48
49/* Allocate an aligned memory block. */
50void * weak_function
51__libc_memalign (size_t align, size_t n)
52{
53 if (alloc_end == 0)
54 {
55 /* Consume any unused space in the last page of our data segment. */
56 extern int _end attribute_hidden;
57 alloc_ptr = &_end;
58 alloc_end = (void *) 0 + (((alloc_ptr - (void *) 0)
59 + GLRO(dl_pagesize) - 1)
60 & ~(GLRO(dl_pagesize) - 1));
61 }
62
63 /* Make sure the allocation pointer is ideally aligned. */
64 alloc_ptr = (void *) 0 + (((alloc_ptr - (void *) 0) + align - 1)
65 & ~(align - 1));
66
67 if (alloc_ptr + n >= alloc_end || n >= -(uintptr_t) alloc_ptr)
68 {
69 /* Insufficient space left; allocate another page plus one extra
70 page to reduce number of mmap calls. */
71 caddr_t page;
72 size_t nup = (n + GLRO(dl_pagesize) - 1) & ~(GLRO(dl_pagesize) - 1);
73 if (__glibc_unlikely (nup == 0 && n != 0))
74 return NULL;
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)
79 return NULL;
80 if (page != alloc_end)
81 alloc_ptr = page;
82 alloc_end = page + nup;
83 }
84
85 alloc_last_block = (void *) alloc_ptr;
86 alloc_ptr += n;
87 return alloc_last_block;
88}
89
90void * weak_function
91malloc (size_t n)
92{
93 return __libc_memalign (sizeof (double), n);
94}
95
96/* We use this function occasionally since the real implementation may
97 be optimized when it can assume the memory it returns already is
98 set to NUL. */
99void * weak_function
100calloc (size_t nmemb, size_t size)
101{
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;
106
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)
110 return NULL;
111
112 return malloc (bytes);
113}
114
115/* This will rarely be called. */
116void weak_function
117free (void *ptr)
118{
119 /* We can free only the last block allocated. */
120 if (ptr == alloc_last_block)
121 {
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;
126 }
127}
128
129/* This is only called with the most recent block returned by malloc. */
130void * weak_function
131realloc (void *ptr, size_t n)
132{
133 if (ptr == NULL)
134 return malloc (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;
140}
141
142/* Avoid signal frobnication in setjmp/longjmp. Keeps things smaller. */
143
144#include <setjmp.h>
145
146int weak_function
147__sigjmp_save (sigjmp_buf env, int savemask __attribute__ ((unused)))
148{
149 env[0].__mask_was_saved = 0;
150 return 0;
151}
152
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. */
156
157char * weak_function
158__strerror_r (int errnum, char *buf, size_t buflen)
159{
160 char *msg;
161
162 switch (errnum)
163 {
164 case ENOMEM:
165 msg = (char *) "Cannot allocate memory";
166 break;
167 case EINVAL:
168 msg = (char *) "Invalid argument";
169 break;
170 case ENOENT:
171 msg = (char *) "No such file or directory";
172 break;
173 case EPERM:
174 msg = (char *) "Operation not permitted";
175 break;
176 case EIO:
177 msg = (char *) "Input/output error";
178 break;
179 case EACCES:
180 msg = (char *) "Permission denied";
181 break;
182 default:
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);
189 break;
190 }
191
192 return msg;
193}
194
195void
196__libc_fatal (const char *message)
197{
198 _dl_fatal_printf ("%s", message);
199}
200rtld_hidden_def (__libc_fatal)
201
202void
203__attribute__ ((noreturn))
204__chk_fail (void)
205{
206 _exit (127);
207}
208rtld_hidden_def (__chk_fail)
209
210#ifndef NDEBUG
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. */
214
215void weak_function
216__assert_fail (const char *assertion,
217 const char *file, unsigned int line, const char *function)
218{
219 _dl_fatal_printf ("\
220Inconsistency detected by ld.so: %s: %u: %s%sAssertion `%s' failed!\n",
221 file, line, function ?: "", function ? ": " : "",
222 assertion);
223
224}
225rtld_hidden_weak (__assert_fail)
226
227void weak_function
228__assert_perror_fail (int errnum,
229 const char *file, unsigned int line,
230 const char *function)
231{
232 char errbuf[400];
233 _dl_fatal_printf ("\
234Inconsistency detected by ld.so: %s: %u: %s%sUnexpected error: %s.\n",
235 file, line, function ?: "", function ? ": " : "",
236 __strerror_r (errnum, errbuf, sizeof errbuf));
237
238}
239rtld_hidden_weak (__assert_perror_fail)
240#endif
241
242unsigned long int weak_function
243__strtoul_internal (const char *nptr, char **endptr, int base, int group)
244{
245 unsigned long int result = 0;
246 long int sign = 1;
247 unsigned max_digit;
248
249 while (*nptr == ' ' || *nptr == '\t')
250 ++nptr;
251
252 if (*nptr == '-')
253 {
254 sign = -1;
255 ++nptr;
256 }
257 else if (*nptr == '+')
258 ++nptr;
259
260 if (*nptr < '0' || *nptr > '9')
261 {
262 if (endptr != NULL)
263 *endptr = (char *) nptr;
264 return 0UL;
265 }
266
267 assert (base == 0);
268 base = 10;
269 max_digit = 9;
270 if (*nptr == '0')
271 {
272 if (nptr[1] == 'x' || nptr[1] == 'X')
273 {
274 base = 16;
275 nptr += 2;
276 }
277 else
278 {
279 base = 8;
280 max_digit = 7;
281 }
282 }
283
284 while (1)
285 {
286 unsigned long int digval;
287 if (*nptr >= '0' && *nptr <= '0' + max_digit)
288 digval = *nptr - '0';
289 else if (base == 16)
290 {
291 if (*nptr >= 'a' && *nptr <= 'f')
292 digval = *nptr - 'a' + 10;
293 else if (*nptr >= 'A' && *nptr <= 'F')
294 digval = *nptr - 'A' + 10;
295 else
296 break;
297 }
298 else
299 break;
300
301 if (result > ULONG_MAX / base
302 || (result == ULONG_MAX / base && digval > ULONG_MAX % base))
303 {
304 errno = ERANGE;
305 if (endptr != NULL)
306 *endptr = (char *) nptr;
307 return ULONG_MAX;
308 }
309 result *= base;
310 result += digval;
311 ++nptr;
312 }
313
314 if (endptr != NULL)
315 *endptr = (char *) nptr;
316 return result * sign;
317}
318
319
320#undef _itoa
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. */
324char *
325_itoa (unsigned long long int value, char *buflim, unsigned int base,
326 int upper_case)
327{
328 assert (! upper_case);
329
330 do
331 *--buflim = _itoa_lower_digits[value % base];
332 while ((value /= base) != 0);
333
334 return buflim;
335}
336
337/* The '_itoa_lower_digits' variable in libc.so is able to handle bases
338 up to 36. We don't need this here. */
339const char _itoa_lower_digits[16] = "0123456789abcdef";
340rtld_hidden_data_def (_itoa_lower_digits)
341
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. */
345#undef strsep
346#undef __strsep
347char *
348__strsep (char **stringp, const char *delim)
349{
350 char *begin;
351
352 assert (delim[0] != '\0');
353
354 begin = *stringp;
355 if (begin != NULL)
356 {
357 char *end = begin;
358
359 while (*end != '\0' || (end = NULL))
360 {
361 const char *dp = delim;
362
363 do
364 if (*dp == *end)
365 break;
366 while (*++dp != '\0');
367
368 if (*dp != '\0')
369 {
370 *end++ = '\0';
371 break;
372 }
373
374 ++end;
375 }
376
377 *stringp = end;
378 }
379
380 return begin;
381}
382weak_alias (__strsep, strsep)
383strong_alias (__strsep, __strsep_g)
384