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)
  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       page = __mmap (0, nup, PROT_READ|PROT_WRITE,
  84                      MAP_ANON|MAP_PRIVATE, _dl_zerofd, 0);
  85       assert (page != MAP_FAILED);
  86       if (page != alloc_end)
  87         alloc_ptr = page;
  88       alloc_end = page + nup;
  89     }
  90
  91   alloc_last_block = (void *) alloc_ptr;
  92   alloc_ptr += n;
  93   return alloc_last_block;
  94 }
  95
  96 void * weak_function
  97 malloc (size_t n)
  98 {
  99   return __libc_memalign (sizeof (double), n);
 100 }
 101
 102 /* We use this function occasionally since the real implementation may
 103    be optimized when it can assume the memory it returns already is
 104    set to NUL.  */
 105 void * weak_function
 106 calloc (size_t nmemb, size_t size)
 107 {
 108   /* New memory from the trivial malloc above is always already cleared.
 109      (We make sure that's true in the rare occasion it might not be,
 110      by clearing memory in free, below.)  */
 111   return malloc (nmemb * size);
 112 }
 113
 114 /* This will rarely be called.  */
 115 void weak_function
 116 free (void *ptr)
 117 {
 118   /* We can free only the last block allocated.  */
 119   if (ptr == alloc_last_block)
 120     {
 121       /* Since this is rare, we clear the freed block here
 122          so that calloc can presume malloc returns cleared memory.  */
 123       memset (alloc_last_block, '\0', alloc_ptr - alloc_last_block);
 124       alloc_ptr = alloc_last_block;
 125     }
 126 }
 127
 128 /* This is only called with the most recent block returned by malloc.  */
 129 void * weak_function
 130 realloc (void *ptr, size_t n)
 131 {
 132   if (ptr == NULL)
 133     return malloc (n);
 134   assert (ptr == alloc_last_block);
 135   size_t old_size = alloc_ptr - alloc_last_block;
 136   alloc_ptr = alloc_last_block;
 137   void *new = malloc (n);
 138   return new != ptr ? memcpy (new, ptr, old_size) : new;
 139 }
 140 \f
 141 /* Avoid signal frobnication in setjmp/longjmp.  Keeps things smaller.  */
 142
 143 #include <setjmp.h>
 144
 145 int weak_function
 146 __sigjmp_save (sigjmp_buf env, int savemask __attribute__ ((unused)))
 147 {
 148   env[0].__mask_was_saved = 0;
 149   return 0;
 150 }
 151 \f
 152 /* Define our own version of the internal function used by strerror.  We
 153    only provide the messages for some common errors.  This avoids pulling
 154    in the whole error list.  */
 155
 156 char * weak_function
 157 __strerror_r (int errnum, char *buf, size_t buflen)
 158 {
 159   char *msg;
 160
 161   switch (errnum)
 162     {
 163     case ENOMEM:
 164       msg = (char *) "Cannot allocate memory";
 165       break;
 166     case EINVAL:
 167       msg = (char *) "Invalid argument";
 168       break;
 169     case ENOENT:
 170       msg = (char *) "No such file or directory";
 171       break;
 172     case EPERM:
 173       msg = (char *) "Operation not permitted";
 174       break;
 175     case EIO:
 176       msg = (char *) "Input/output error";
 177       break;
 178     case EACCES:
 179       msg = (char *) "Permission denied";
 180       break;
 181     default:
 182       /* No need to check buffer size, all calls in the dynamic linker
 183          provide enough space.  */
 184       buf[buflen - 1] = '\0';
 185       msg = _itoa (errnum, buf + buflen - 1, 10, 0);
 186       msg = memcpy (msg - (sizeof ("Error ") - 1), "Error ",
 187                     sizeof ("Error ") - 1);
 188       break;
 189     }
 190
 191   return msg;
 192 }
 193 \f
 194 #ifndef NDEBUG
 195
 196 /* Define (weakly) our own assert failure function which doesn't use stdio.
 197    If we are linked into the user program (-ldl), the normal __assert_fail
 198    defn can override this one.  */
 199
 200 void weak_function
 201 __assert_fail (const char *assertion,
 202                const char *file, unsigned int line, const char *function)
 203 {
 204   _dl_fatal_printf ("\
 205 Inconsistency detected by ld.so: %s: %u: %s%sAssertion `%s' failed!\n",
 206                     file, line, function ?: "", function ? ": " : "",
 207                     assertion);
 208
 209 }
 210 rtld_hidden_weak(__assert_fail)
 211
 212 void weak_function
 213 __assert_perror_fail (int errnum,
 214                       const char *file, unsigned int line,
 215                       const char *function)
 216 {
 217   char errbuf[400];
 218   _dl_fatal_printf ("\
 219 Inconsistency detected by ld.so: %s: %u: %s%sUnexpected error: %s.\n",
 220                     file, line, function ?: "", function ? ": " : "",
 221                     __strerror_r (errnum, errbuf, sizeof errbuf));
 222
 223 }
 224 rtld_hidden_weak (__assert_perror_fail)
 225 #endif
 226
 227 unsigned long int weak_function
 228 __strtoul_internal (const char *nptr, char **endptr, int base, int group)
 229 {
 230   unsigned long int result = 0;
 231   long int sign = 1;
 232
 233   while (*nptr == ' ' || *nptr == '\t')
 234     ++nptr;
 235
 236   if (*nptr == '-')
 237     {
 238       sign = -1;
 239       ++nptr;
 240     }
 241   else if (*nptr == '+')
 242     ++nptr;
 243
 244   if (*nptr < '0' || *nptr > '9')
 245     {
 246       if (endptr != NULL)
 247         *endptr = (char *) nptr;
 248       return 0UL;
 249     }
 250
 251   assert (base == 0);
 252   base = 10;
 253   if (*nptr == '0')
 254     {
 255       if (nptr[1] == 'x' || nptr[1] == 'X')
 256         {
 257           base = 16;
 258           nptr += 2;
 259         }
 260       else
 261         base = 8;
 262     }
 263
 264   while (*nptr >= '0' && *nptr <= '9')
 265     {
 266       unsigned long int digval = *nptr - '0';
 267       if (result > LONG_MAX / 10
 268           || (result == ULONG_MAX / 10 && digval > ULONG_MAX % 10))
 269         {
 270           errno = ERANGE;
 271           if (endptr != NULL)
 272             *endptr = (char *) nptr;
 273           return ULONG_MAX;
 274         }
 275       result *= base;
 276       result += digval;
 277       ++nptr;
 278     }
 279
 280   if (endptr != NULL)
 281     *endptr = (char *) nptr;
 282   return result * sign;
 283 }
 284
 285
 286 #undef _itoa
 287 /* We always use _itoa instead of _itoa_word in ld.so since the former
 288    also has to be present and it is never about speed when these
 289    functions are used.  */
 290 char *
 291 _itoa (value, buflim, base, upper_case)
 292      unsigned long long int value;
 293      char *buflim;
 294      unsigned int base;
 295      int upper_case;
 296 {
 297   extern const char INTUSE(_itoa_lower_digits)[] attribute_hidden;
 298
 299   assert (! upper_case);
 300
 301   do
 302     *--buflim = INTUSE(_itoa_lower_digits)[value % base];
 303   while ((value /= base) != 0);
 304
 305   return buflim;
 306 }
 307
 308
 309 /* The following is not a complete strsep implementation.  It cannot
 310    handle empty delimiter strings.  But this isn't necessary for the
 311    execution of ld.so.  */
 312 #undef strsep
 313 #undef __strsep
 314 char *
 315 __strsep (char **stringp, const char *delim)
 316 {
 317   char *begin;
 318
 319   assert (delim[0] != '\0');
 320
 321   begin = *stringp;
 322   if (begin != NULL)
 323     {
 324       char *end = begin;
 325
 326       while (*end != '\0' || (end = NULL))
 327         {
 328           const char *dp = delim;
 329
 330           do
 331             if (*dp == *end)
 332               break;
 333           while (*++dp != '\0');
 334
 335           if (*dp != '\0')
 336             {
 337               *end++ = '\0';
 338               break;
 339             }
 340
 341           ++end;
 342         }
 343
 344       *stringp = end;
 345     }
 346
 347   return begin;
 348 }
 349 weak_alias (__strsep, strsep)
 350 strong_alias (__strsep, __strsep_g)
 351
 352 void
 353 __attribute__ ((noreturn))
 354 __chk_fail (void)
 355 {
 356   _exit (127);
 357 }
 358 rtld_hidden_def (__chk_fail)
 359
 360 /* The '_itoa_lower_digits' variable in libc.so is able to handle bases
 361    up to 36.  We don't need this here.  */
 362 const char INTUSE(_itoa_lower_digits)[16] attribute_hidden
 363   = "0123456789abcdef";