elf/dl-misc.c

   1 /* Miscellaneous support functions for dynamic linker
   2    Copyright (C) 1997-2024 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    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <_itoa.h>
  20 #include <fcntl.h>
  21 #include <ldsodefs.h>
  22 #include <link.h>
  23 #include <not-cancel.h>
  24 #include <stdint.h>
  25 #include <stdlib.h>
  26 #include <sys/mman.h>
  27 #include <sys/stat.h>
  28 #include <unistd.h>
  29
  30 /* Read the whole contents of FILE into new mmap'd space with given
  31    protections.  *SIZEP gets the size of the file.  On error MAP_FAILED
  32    is returned.  */
  33
  34 void *
  35 _dl_sysdep_read_whole_file (const char *file, size_t *sizep, int prot)
  36 {
  37   void *result = MAP_FAILED;
  38   struct __stat64_t64 st;
  39   int fd = __open64_nocancel (file, O_RDONLY | O_CLOEXEC);
  40   if (fd >= 0)
  41     {
  42       if (__fstat64_time64 (fd, &st) >= 0)
  43         {
  44           *sizep = st.st_size;
  45
  46           /* No need to map the file if it is empty.  */
  47           if (*sizep != 0)
  48             /* Map a copy of the file contents.  */
  49             result = __mmap (NULL, *sizep, prot,
  50 #ifdef MAP_COPY
  51                              MAP_COPY
  52 #else
  53                              MAP_PRIVATE
  54 #endif
  55 #ifdef MAP_FILE
  56                              | MAP_FILE
  57 #endif
  58                              , fd, 0);
  59         }
  60       __close_nocancel (fd);
  61     }
  62   return result;
  63 }
  64
  65 /* Test whether given NAME matches any of the names of the given object.  */
  66 int
  67 _dl_name_match_p (const char *name, const struct link_map *map)
  68 {
  69   if (strcmp (name, map->l_name) == 0)
  70     return 1;
  71
  72   struct libname_list *runp = map->l_libname;
  73
  74   while (runp != NULL)
  75     if (strcmp (name, runp->name) == 0)
  76       return 1;
  77     else
  78       /* Synchronize with the release MO store in add_name_to_object.
  79          See CONCURRENCY NOTES in add_name_to_object in dl-load.c.  */
  80       runp = atomic_load_acquire (&runp->next);
  81
  82   return 0;
  83 }
  84
  85 unsigned long int
  86 _dl_higher_prime_number (unsigned long int n)
  87 {
  88   /* These are primes that are near, but slightly smaller than, a
  89      power of two.  */
  90   static const uint32_t primes[] = {
  91     UINT32_C (7),
  92     UINT32_C (13),
  93     UINT32_C (31),
  94     UINT32_C (61),
  95     UINT32_C (127),
  96     UINT32_C (251),
  97     UINT32_C (509),
  98     UINT32_C (1021),
  99     UINT32_C (2039),
 100     UINT32_C (4093),
 101     UINT32_C (8191),
 102     UINT32_C (16381),
 103     UINT32_C (32749),
 104     UINT32_C (65521),
 105     UINT32_C (131071),
 106     UINT32_C (262139),
 107     UINT32_C (524287),
 108     UINT32_C (1048573),
 109     UINT32_C (2097143),
 110     UINT32_C (4194301),
 111     UINT32_C (8388593),
 112     UINT32_C (16777213),
 113     UINT32_C (33554393),
 114     UINT32_C (67108859),
 115     UINT32_C (134217689),
 116     UINT32_C (268435399),
 117     UINT32_C (536870909),
 118     UINT32_C (1073741789),
 119     UINT32_C (2147483647),
 120                                        /* 4294967291L */
 121     UINT32_C (2147483647) + UINT32_C (2147483644)
 122   };
 123
 124   const uint32_t *low = &primes[0];
 125   const uint32_t *high = &primes[sizeof (primes) / sizeof (primes[0])];
 126
 127   while (low != high)
 128     {
 129       const uint32_t *mid = low + (high - low) / 2;
 130       if (n > *mid)
 131        low = mid + 1;
 132       else
 133        high = mid;
 134     }
 135
 136 #if 0
 137   /* If we've run out of primes, abort.  */
 138   if (n > *low)
 139     {
 140       fprintf (stderr, "Cannot find prime bigger than %lu\n", n);
 141       abort ();
 142     }
 143 #endif
 144
 145   return *low;
 146 }
 147
 148 /* A stripped down strtoul-like implementation for very early use.  It
 149    does not set errno if the result is outside bounds because it may get
 150    called before errno may have been set up.  */
 151
 152 uint64_t
 153 _dl_strtoul (const char *nptr, char **endptr)
 154 {
 155   uint64_t result = 0;
 156   bool positive = true;
 157   unsigned max_digit;
 158
 159   while (*nptr == ' ' || *nptr == '\t')
 160     ++nptr;
 161
 162   if (*nptr == '-')
 163     {
 164       positive = false;
 165       ++nptr;
 166     }
 167   else if (*nptr == '+')
 168     ++nptr;
 169
 170   if (*nptr < '0' || *nptr > '9')
 171     {
 172       if (endptr != NULL)
 173         *endptr = (char *) nptr;
 174       return 0UL;
 175     }
 176
 177   uint64_t cutoff = (UINT64_MAX * 2UL + 1UL) / 10;
 178   uint64_t cutlim = (UINT64_MAX * 2UL + 1UL) % 10;
 179
 180   int base = 10;
 181   max_digit = 9;
 182   if (*nptr == '0')
 183     {
 184       if (nptr[1] == 'x' || nptr[1] == 'X')
 185         {
 186           base = 16;
 187           nptr += 2;
 188           cutoff = (UINT64_MAX * 2UL + 1UL) / 16;
 189           cutlim = (UINT64_MAX * 2UL + 1UL) % 16;
 190         }
 191       else
 192         {
 193           base = 8;
 194           max_digit = 7;
 195           cutoff = (UINT64_MAX * 2UL + 1UL) / 8;
 196           cutlim = (UINT64_MAX * 2UL + 1UL) % 8;
 197         }
 198     }
 199
 200   while (1)
 201     {
 202       int digval;
 203       if (*nptr >= '0' && *nptr <= '0' + max_digit)
 204         digval = *nptr - '0';
 205       else if (base == 16)
 206         {
 207           if (*nptr >= 'a' && *nptr <= 'f')
 208             digval = *nptr - 'a' + 10;
 209           else if (*nptr >= 'A' && *nptr <= 'F')
 210             digval = *nptr - 'A' + 10;
 211           else
 212             break;
 213         }
 214       else
 215         break;
 216
 217       if (result > cutoff || (result == cutoff && digval > cutlim))
 218         {
 219           if (endptr != NULL)
 220             *endptr = (char *) nptr;
 221           return UINT64_MAX;
 222         }
 223       result *= base;
 224       result += digval;
 225       ++nptr;
 226     }
 227
 228   if (endptr != NULL)
 229     *endptr = (char *) nptr;
 230
 231   /* Avoid 64-bit multiplication.  */
 232   if (!positive)
 233     result = -result;
 234
 235   return result;
 236 }