elf/dl-minimal.c

   1 /* Minimal replacements for basic facilities used in the dynamic linker.
   2    Copyright (C) 1995-1998,2000-2002,2004-2006,2007
   3    Free Software Foundation, Inc.
   4    This file is part of the GNU C Library.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 #include <errno.h>
  22 #include <limits.h>
  23 #include <string.h>
  24 #include <tls.h>
  25 #include <unistd.h>
  26 #include <sys/mman.h>
  27 #include <sys/param.h>
  28 #include <sys/types.h>
  29 #include <ldsodefs.h>
  30 #include <stdio-common/_itoa.h>
  31
  32 #include <assert.h>
  33
  34 /* Minimal `malloc' allocator for use while loading shared libraries.
  35    No block is ever freed.  */
  36
  37 static void *alloc_ptr, *alloc_end, *alloc_last_block;
  38
  39 /* Declarations of global functions.  */
  40 extern void weak_function free (void *ptr);
  41 extern void * weak_function realloc (void *ptr, size_t n);
  42 extern unsigned long int weak_function __strtoul_internal (const char *nptr,
  43                                                            char **endptr,
  44                                                            int base,
  45                                                            int group);
  46 extern unsigned long int weak_function strtoul (const char *nptr,
  47                                                 char **endptr, int base);
  48
  49
  50 /* Allocate an aligned memory block.  */
  51 void * weak_function
  52 __libc_memalign (size_t align, size_t n)
  53 {
  54 #ifdef MAP_ANON
  55 #define _dl_zerofd (-1)
  56 #else
  57   extern int _dl_zerofd;
  58
  59   if (_dl_zerofd == -1)
  60     _dl_zerofd = _dl_sysdep_open_zero_fill ();
  61 #define MAP_ANON 0
  62 #endif
  63
  64   if (alloc_end == 0)
  65     {
  66       /* Consume any unused space in the last page of our data segment.  */
  67       extern int _end attribute_hidden;
  68       alloc_ptr = &_end;
  69       alloc_end = (void *) 0 + (((alloc_ptr - (void *) 0)
  70                                  + GLRO(dl_pagesize) - 1)
  71                                 & ~(GLRO(dl_pagesize) - 1));
  72     }
  73
  74   /* Make sure the allocation pointer is ideally aligned.  */
  75   alloc_ptr = (void *) 0 + (((alloc_ptr - (void *) 0) + align - 1)
  76                             & ~(align - 1));
  77
  78   if (alloc_ptr + n >= alloc_end || n >= -(uintptr_t) alloc_ptr)
  79     {
  80       /* Insufficient space left; allocate another page.  */
  81       caddr_t page;
  82       size_t nup = (n + GLRO(dl_pagesize) - 1) & ~(GLRO(dl_pagesize) - 1);
  83       if (__builtin_expect (nup == 0, 0))
  84         {
  85           if (n)
  86             return NULL;
  87           nup = GLRO(dl_pagesize);
  88         }
  89       page = __mmap (0, nup, PROT_READ|PROT_WRITE,
  90                      MAP_ANON|MAP_PRIVATE, _dl_zerofd, 0);
  91       if (page == MAP_FAILED)
  92         return NULL;
  93       if (page != alloc_end)
  94         alloc_ptr = page;
  95       alloc_end = page + nup;
  96     }
  97
  98   alloc_last_block = (void *) alloc_ptr;
  99   alloc_ptr += n;
 100   return alloc_last_block;
 101 }
 102
 103 void * weak_function
 104 malloc (size_t n)
 105 {
 106   return __libc_memalign (sizeof (double), n);
 107 }
 108
 109 /* We use this function occasionally since the real implementation may
 110    be optimized when it can assume the memory it returns already is
 111    set to NUL.  */
 112 void * weak_function
 113 calloc (size_t nmemb, size_t size)
 114 {
 115   /* New memory from the trivial malloc above is always already cleared.
 116      (We make sure that's true in the rare occasion it might not be,
 117      by clearing memory in free, below.)  */
 118   size_t bytes = nmemb * size;
 119
 120 #define HALF_SIZE_T (((size_t) 1) << (8 * sizeof (size_t) / 2))
 121   if (__builtin_expect ((nmemb | size) >= HALF_SIZE_T, 0)
 122       && size != 0 && bytes / size != nmemb)
 123     return NULL;
 124
 125   return malloc (bytes);
 126 }
 127
 128 /* This will rarely be called.  */
 129 void weak_function
 130 free (void *ptr)
 131 {
 132   /* We can free only the last block allocated.  */
 133   if (ptr == alloc_last_block)
 134     {
 135       /* Since this is rare, we clear the freed block here
 136          so that calloc can presume malloc returns cleared memory.  */
 137       memset (alloc_last_block, '\0', alloc_ptr - alloc_last_block);
 138       alloc_ptr = alloc_last_block;
 139     }
 140 }
 141
 142 /* This is only called with the most recent block returned by malloc.  */
 143 void * weak_function
 144 realloc (void *ptr, size_t n)
 145 {
 146   if (ptr == NULL)
 147     return malloc (n);
 148   assert (ptr == alloc_last_block);
 149   size_t old_size = alloc_ptr - alloc_last_block;
 150   alloc_ptr = alloc_last_block;
 151   void *new = malloc (n);
 152   return new != ptr ? memcpy (new, ptr, old_size) : new;
 153 }
 154 \f
 155 /* Avoid signal frobnication in setjmp/longjmp.  Keeps things smaller.  */
 156
 157 #include <setjmp.h>
 158
 159 int weak_function
 160 __sigjmp_save (sigjmp_buf env, int savemask __attribute__ ((unused)))
 161 {
 162   env[0].__mask_was_saved = 0;
 163   return 0;
 164 }
 165 \f
 166 /* Define our own version of the internal function used by strerror.  We
 167    only provide the messages for some common errors.  This avoids pulling
 168    in the whole error list.  */
 169
 170 char * weak_function
 171 __strerror_r (int errnum, char *buf, size_t buflen)
 172 {
 173   char *msg;
 174
 175   switch (errnum)
 176     {
 177     case ENOMEM:
 178       msg = (char *) "Cannot allocate memory";
 179       break;
 180     case EINVAL:
 181       msg = (char *) "Invalid argument";
 182       break;
 183     case ENOENT:
 184       msg = (char *) "No such file or directory";
 185       break;
 186     case EPERM:
 187       msg = (char *) "Operation not permitted";
 188       break;
 189     case EIO:
 190       msg = (char *) "Input/output error";
 191       break;
 192     case EACCES:
 193       msg = (char *) "Permission denied";
 194       break;
 195     default:
 196       /* No need to check buffer size, all calls in the dynamic linker
 197          provide enough space.  */
 198       buf[buflen - 1] = '\0';
 199       msg = _itoa (errnum, buf + buflen - 1, 10, 0);
 200       msg = memcpy (msg - (sizeof ("Error ") - 1), "Error ",
 201                     sizeof ("Error ") - 1);
 202       break;
 203     }
 204
 205   return msg;
 206 }
 207 \f
 208 #ifndef NDEBUG
 209
 210 /* Define (weakly) our own assert failure function which doesn't use stdio.
 211    If we are linked into the user program (-ldl), the normal __assert_fail
 212    defn can override this one.  */
 213
 214 void weak_function
 215 __assert_fail (const char *assertion,
 216                const char *file, unsigned int line, const char *function)
 217 {
 218   _dl_fatal_printf ("\
 219 Inconsistency detected by ld.so: %s: %u: %s%sAssertion `%s' failed!\n",
 220                     file, line, function ?: "", function ? ": " : "",
 221                     assertion);
 222
 223 }
 224 rtld_hidden_weak(__assert_fail)
 225
 226 void weak_function
 227 __assert_perror_fail (int errnum,
 228                       const char *file, unsigned int line,
 229                       const char *function)
 230 {
 231   char errbuf[400];
 232   _dl_fatal_printf ("\
 233 Inconsistency detected by ld.so: %s: %u: %s%sUnexpected error: %s.\n",
 234                     file, line, function ?: "", function ? ": " : "",
 235                     __strerror_r (errnum, errbuf, sizeof errbuf));
 236
 237 }
 238 rtld_hidden_weak (__assert_perror_fail)
 239 #endif
 240
 241 unsigned long int weak_function
 242 __strtoul_internal (const char *nptr, char **endptr, int base, int group)
 243 {
 244   unsigned long int result = 0;
 245   long int sign = 1;
 246
 247   while (*nptr == ' ' || *nptr == '\t')
 248     ++nptr;
 249
 250   if (*nptr == '-')
 251     {
 252       sign = -1;
 253       ++nptr;
 254     }
 255   else if (*nptr == '+')
 256     ++nptr;
 257
 258   if (*nptr < '0' || *nptr > '9')
 259     {
 260       if (endptr != NULL)
 261         *endptr = (char *) nptr;
 262       return 0UL;
 263     }
 264
 265   assert (base == 0);
 266   base = 10;
 267   if (*nptr == '0')
 268     {
 269       if (nptr[1] == 'x' || nptr[1] == 'X')
 270         {
 271           base = 16;
 272           nptr += 2;
 273         }
 274       else
 275         base = 8;
 276     }
 277
 278   while (*nptr >= '0' && *nptr <= '9')
 279     {
 280       unsigned long int digval = *nptr - '0';
 281       if (result > ULONG_MAX / 10
 282           || (result == ULONG_MAX / 10 && digval > ULONG_MAX % 10))
 283         {
 284           errno = ERANGE;
 285           if (endptr != NULL)
 286             *endptr = (char *) nptr;
 287           return ULONG_MAX;
 288         }
 289       result *= base;
 290       result += digval;
 291       ++nptr;
 292     }
 293
 294   if (endptr != NULL)
 295     *endptr = (char *) nptr;
 296   return result * sign;
 297 }
 298
 299
 300 #undef _itoa
 301 /* We always use _itoa instead of _itoa_word in ld.so since the former
 302    also has to be present and it is never about speed when these
 303    functions are used.  */
 304 char *
 305 _itoa (value, buflim, base, upper_case)
 306      unsigned long long int value;
 307      char *buflim;
 308      unsigned int base;
 309      int upper_case;
 310 {
 311   extern const char INTUSE(_itoa_lower_digits)[] attribute_hidden;
 312
 313   assert (! upper_case);
 314
 315   do
 316     *--buflim = INTUSE(_itoa_lower_digits)[value % base];
 317   while ((value /= base) != 0);
 318
 319   return buflim;
 320 }
 321
 322
 323 /* The following is not a complete strsep implementation.  It cannot
 324    handle empty delimiter strings.  But this isn't necessary for the
 325    execution of ld.so.  */
 326 #undef strsep
 327 #undef __strsep
 328 char *
 329 __strsep (char **stringp, const char *delim)
 330 {
 331   char *begin;
 332
 333   assert (delim[0] != '\0');
 334
 335   begin = *stringp;
 336   if (begin != NULL)
 337     {
 338       char *end = begin;
 339
 340       while (*end != '\0' || (end = NULL))
 341         {
 342           const char *dp = delim;
 343
 344           do
 345             if (*dp == *end)
 346               break;
 347           while (*++dp != '\0');
 348
 349           if (*dp != '\0')
 350             {
 351               *end++ = '\0';
 352               break;
 353             }
 354
 355           ++end;
 356         }
 357
 358       *stringp = end;
 359     }
 360
 361   return begin;
 362 }
 363 weak_alias (__strsep, strsep)
 364 strong_alias (__strsep, __strsep_g)
 365
 366 void
 367 __attribute__ ((noreturn))
 368 __chk_fail (void)
 369 {
 370   _exit (127);
 371 }
 372 rtld_hidden_def (__chk_fail)
 373
 374 /* The '_itoa_lower_digits' variable in libc.so is able to handle bases
 375    up to 36.  We don't need this here.  */
 376 const char INTUSE(_itoa_lower_digits)[16] attribute_hidden
 377   = "0123456789abcdef";