locale/loadarchive.c

   1 /* Code to load locale data from the locale archive file.
   2    Copyright (C) 2002-2013 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 <locale.h>
  20 #include <stddef.h>
  21 #include <stdlib.h>
  22 #include <stdbool.h>
  23 #include <errno.h>
  24 #include <assert.h>
  25 #include <string.h>
  26 #include <fcntl.h>
  27 #include <unistd.h>
  28 #include <stdint.h>
  29 #include <sys/mman.h>
  30 #include <sys/stat.h>
  31 #include <sys/param.h>
  32
  33 #include "localeinfo.h"
  34 #include "locarchive.h"
  35 #include <not-cancel.h>
  36
  37 /* Define the hash function.  We define the function as static inline.  */
  38 #define compute_hashval static inline compute_hashval
  39 #define hashval_t uint32_t
  40 #include "hashval.h"
  41 #undef compute_hashval
  42
  43
  44 /* Name of the locale archive file.  */
  45 static const char archfname[] = LOCALEDIR "/locale-archive";
  46
  47 /* Size of initial mapping window, optimal if large enough to
  48    cover the header plus the initial locale.  */
  49 #define ARCHIVE_MAPPING_WINDOW  (2 * 1024 * 1024)
  50
  51 #ifndef MAP_COPY
  52 /* This is not quite as good as MAP_COPY since unexamined pages
  53    can change out from under us and give us inconsistent data.
  54    But we rely on the user not to diddle the system's live archive.
  55    Even though we only ever use PROT_READ, using MAP_SHARED would
  56    not give the system sufficient freedom to e.g. let the on disk
  57    file go away because it doesn't know we won't call mprotect later.  */
  58 # define MAP_COPY MAP_PRIVATE
  59 #endif
  60 #ifndef MAP_FILE
  61  /* Some systems do not have this flag; it is superfluous.  */
  62 # define MAP_FILE 0
  63 #endif
  64
  65 /* Record of contiguous pages already mapped from the locale archive.  */
  66 struct archmapped
  67 {
  68   void *ptr;
  69   uint32_t from;
  70   uint32_t len;
  71   struct archmapped *next;
  72 };
  73 static struct archmapped *archmapped;
  74
  75 /* This describes the mapping at the beginning of the file that contains
  76    the header data.  There could be data in the following partial page,
  77    so this is searched like any other.  Once the archive has been used,
  78    ARCHMAPPED points to this; if mapping the archive header failed,
  79    then headmap.ptr is null.  */
  80 static struct archmapped headmap;
  81 static struct stat64 archive_stat; /* stat of archive when header mapped.  */
  82
  83 /* Record of locales that we have already loaded from the archive.  */
  84 struct locale_in_archive
  85 {
  86   struct locale_in_archive *next;
  87   char *name;
  88   struct __locale_data *data[__LC_LAST];
  89 };
  90 static struct locale_in_archive *archloaded;
  91
  92
  93 /* Local structure and subroutine of _nl_load_archive, see below.  */
  94 struct range
  95 {
  96   uint32_t from;
  97   uint32_t len;
  98   int category;
  99   void *result;
 100 };
 101
 102 static int
 103 rangecmp (const void *p1, const void *p2)
 104 {
 105   return ((struct range *) p1)->from - ((struct range *) p2)->from;
 106 }
 107
 108
 109 /* Calculate the amount of space needed for all the tables described
 110    by the given header.  Note we do not include the empty table space
 111    that has been preallocated in the file, so our mapping may not be
 112    large enough if localedef adds data to the file in place.  However,
 113    doing that would permute the header fields while we are accessing
 114    them and thus not be safe anyway, so we don't allow for that.  */
 115 static inline off_t
 116 calculate_head_size (const struct locarhead *h)
 117 {
 118   off_t namehash_end = (h->namehash_offset
 119                         + h->namehash_size * sizeof (struct namehashent));
 120   off_t string_end =  h->string_offset + h->string_used;
 121   off_t locrectab_end = (h->locrectab_offset
 122                          + h->locrectab_used * sizeof (struct locrecent));
 123   return MAX (namehash_end, MAX (string_end, locrectab_end));
 124 }
 125
 126
 127 /* Find the locale *NAMEP in the locale archive, and return the
 128    internalized data structure for its CATEGORY data.  If this locale has
 129    already been loaded from the archive, just returns the existing data
 130    structure.  If successful, sets *NAMEP to point directly into the mapped
 131    archive string table; that way, the next call can short-circuit strcmp.  */
 132 struct __locale_data *
 133 internal_function
 134 _nl_load_locale_from_archive (int category, const char **namep)
 135 {
 136   const char *name = *namep;
 137   struct
 138   {
 139     void *addr;
 140     size_t len;
 141   } results[__LC_LAST];
 142   struct locale_in_archive *lia;
 143   struct locarhead *head;
 144   struct namehashent *namehashtab;
 145   struct locrecent *locrec;
 146   struct archmapped *mapped;
 147   struct archmapped *last;
 148   unsigned long int hval;
 149   size_t idx;
 150   size_t incr;
 151   struct range ranges[__LC_LAST - 1];
 152   int nranges;
 153   int cnt;
 154   size_t ps = __sysconf (_SC_PAGE_SIZE);
 155   int fd = -1;
 156
 157   /* Check if we have already loaded this locale from the archive.
 158      If we previously loaded the locale but found bogons in the data,
 159      then we will have stored a null pointer to return here.  */
 160   for (lia = archloaded; lia != NULL; lia = lia->next)
 161     if (name == lia->name || !strcmp (name, lia->name))
 162       {
 163         *namep = lia->name;
 164         return lia->data[category];
 165       }
 166
 167   {
 168     /* If the name contains a codeset, then we normalize the name before
 169        doing the lookup.  */
 170     const char *p = strchr (name, '.');
 171     if (p != NULL && p[1] != '@' && p[1] != '\0')
 172       {
 173         const char *rest = __strchrnul (++p, '@');
 174         const char *normalized_codeset = _nl_normalize_codeset (p, rest - p);
 175         if (normalized_codeset == NULL) /* malloc failure */
 176           return NULL;
 177         if (strncmp (normalized_codeset, p, rest - p) != 0
 178             || normalized_codeset[rest - p] != '\0')
 179           {
 180             /* There is a normalized codeset name that is different from
 181                what was specified; reconstruct a new locale name using it.  */
 182             size_t normlen = strlen (normalized_codeset);
 183             size_t restlen = strlen (rest) + 1;
 184             char *newname = alloca (p - name + normlen + restlen);
 185             memcpy (__mempcpy (__mempcpy (newname, name, p - name),
 186                                normalized_codeset, normlen),
 187                     rest, restlen);
 188             name = newname;
 189           }
 190         free ((char *) normalized_codeset);
 191       }
 192   }
 193
 194   /* Make sure the archive is loaded.  */
 195   if (archmapped == NULL)
 196     {
 197       void *result;
 198       size_t headsize, mapsize;
 199
 200       /* We do this early as a sign that we have tried to open the archive.
 201          If headmap.ptr remains null, that's an indication that we tried
 202          and failed, so we won't try again.  */
 203       archmapped = &headmap;
 204
 205       /* The archive has never been opened.  */
 206       fd = open_not_cancel_2 (archfname, O_RDONLY|O_LARGEFILE|O_CLOEXEC);
 207       if (fd < 0)
 208         /* Cannot open the archive, for whatever reason.  */
 209         return NULL;
 210
 211       if (__fxstat64 (_STAT_VER, fd, &archive_stat) == -1)
 212         {
 213           /* stat failed, very strange.  */
 214         close_and_out:
 215           if (fd >= 0)
 216             close_not_cancel_no_status (fd);
 217           return NULL;
 218         }
 219
 220
 221       /* Map an initial window probably large enough to cover the header
 222          and the first locale's data.  With a large address space, we can
 223          just map the whole file and be sure everything is covered.  */
 224
 225       mapsize = (sizeof (void *) > 4 ? archive_stat.st_size
 226                  : MIN (archive_stat.st_size, ARCHIVE_MAPPING_WINDOW));
 227
 228       result = __mmap64 (NULL, mapsize, PROT_READ, MAP_FILE|MAP_COPY, fd, 0);
 229       if (result == MAP_FAILED)
 230         goto close_and_out;
 231
 232       /* Check whether the file is large enough for the sizes given in
 233          the header.  Theoretically an archive could be so large that
 234          just the header fails to fit in our initial mapping window.  */
 235       headsize = calculate_head_size ((const struct locarhead *) result);
 236       if (headsize > mapsize)
 237         {
 238           (void) __munmap (result, mapsize);
 239           if (sizeof (void *) > 4 || headsize > archive_stat.st_size)
 240             /* The file is not big enough for the header.  Bogus.  */
 241             goto close_and_out;
 242
 243           /* Freakishly long header.  */
 244           /* XXX could use mremap when available */
 245           mapsize = (headsize + ps - 1) & ~(ps - 1);
 246           result = __mmap64 (NULL, mapsize, PROT_READ, MAP_FILE|MAP_COPY,
 247                              fd, 0);
 248           if (result == MAP_FAILED)
 249             goto close_and_out;
 250         }
 251
 252       if (sizeof (void *) > 4 || mapsize >= archive_stat.st_size)
 253         {
 254           /* We've mapped the whole file already, so we can be
 255              sure we won't need this file descriptor later.  */
 256           close_not_cancel_no_status (fd);
 257           fd = -1;
 258         }
 259
 260       headmap.ptr = result;
 261       /* headmap.from already initialized to zero.  */
 262       headmap.len = mapsize;
 263     }
 264
 265   /* If there is no archive or it cannot be loaded for some reason fail.  */
 266   if (__builtin_expect (headmap.ptr == NULL, 0))
 267     goto close_and_out;
 268
 269   /* We have the archive available.  To find the name we first have to
 270      determine its hash value.  */
 271   hval = compute_hashval (name, strlen (name));
 272
 273   head = headmap.ptr;
 274   namehashtab = (struct namehashent *) ((char *) head
 275                                         + head->namehash_offset);
 276
 277   idx = hval % head->namehash_size;
 278   incr = 1 + hval % (head->namehash_size - 2);
 279
 280   /* If the name_offset field is zero this means this is a
 281      deleted entry and therefore no entry can be found.  */
 282   while (1)
 283     {
 284       if (namehashtab[idx].name_offset == 0)
 285         /* Not found.  */
 286         goto close_and_out;
 287
 288       if (namehashtab[idx].hashval == hval
 289           && strcmp (name, headmap.ptr + namehashtab[idx].name_offset) == 0)
 290         /* Found the entry.  */
 291         break;
 292
 293       idx += incr;
 294       if (idx >= head->namehash_size)
 295         idx -= head->namehash_size;
 296     }
 297
 298   /* We found an entry.  It might be a placeholder for a removed one.  */
 299   if (namehashtab[idx].locrec_offset == 0)
 300     goto close_and_out;
 301
 302   locrec = (struct locrecent *) (headmap.ptr + namehashtab[idx].locrec_offset);
 303
 304   if (sizeof (void *) > 4 /* || headmap.len == archive_stat.st_size */)
 305     {
 306       /* We already have the whole locale archive mapped in.  */
 307       assert (headmap.len == archive_stat.st_size);
 308       for (cnt = 0; cnt < __LC_LAST; ++cnt)
 309         if (cnt != LC_ALL)
 310           {
 311             if (locrec->record[cnt].offset + locrec->record[cnt].len
 312                 > headmap.len)
 313               /* The archive locrectab contains bogus offsets.  */
 314               goto close_and_out;
 315             results[cnt].addr = headmap.ptr + locrec->record[cnt].offset;
 316             results[cnt].len = locrec->record[cnt].len;
 317           }
 318     }
 319   else
 320     {
 321       /* Get the offsets of the data files and sort them.  */
 322       for (cnt = nranges = 0; cnt < __LC_LAST; ++cnt)
 323         if (cnt != LC_ALL)
 324           {
 325             ranges[nranges].from = locrec->record[cnt].offset;
 326             ranges[nranges].len = locrec->record[cnt].len;
 327             ranges[nranges].category = cnt;
 328             ranges[nranges].result = NULL;
 329
 330             ++nranges;
 331           }
 332
 333       qsort (ranges, nranges, sizeof (ranges[0]), rangecmp);
 334
 335       /* The information about mmap'd blocks is kept in a list.
 336          Skip over the blocks which are before the data we need.  */
 337       last = mapped = archmapped;
 338       for (cnt = 0; cnt < nranges; ++cnt)
 339         {
 340           int upper;
 341           size_t from;
 342           size_t to;
 343           void *addr;
 344           struct archmapped *newp;
 345
 346           /* Determine whether the appropriate page is already mapped.  */
 347           while (mapped != NULL
 348                  && (mapped->from + mapped->len
 349                      <= ranges[cnt].from + ranges[cnt].len))
 350             {
 351               last = mapped;
 352               mapped = mapped->next;
 353             }
 354
 355           /* Do we have a match?  */
 356           if (mapped != NULL
 357               && mapped->from <= ranges[cnt].from
 358               && (ranges[cnt].from + ranges[cnt].len
 359                   <= mapped->from + mapped->len))
 360             {
 361               /* Yep, already loaded.  */
 362               results[ranges[cnt].category].addr = ((char *) mapped->ptr
 363                                                     + ranges[cnt].from
 364                                                     - mapped->from);
 365               results[ranges[cnt].category].len = ranges[cnt].len;
 366               continue;
 367             }
 368
 369           /* Map the range with the locale data from the file.  We will
 370              try to cover as much of the locale as possible.  I.e., if the
 371              next category (next as in "next offset") is on the current or
 372              immediately following page we use it as well.  */
 373           assert (powerof2 (ps));
 374           from = ranges[cnt].from & ~(ps - 1);
 375           upper = cnt;
 376           do
 377             {
 378               to = ranges[upper].from + ranges[upper].len;
 379               if (to > (size_t) archive_stat.st_size)
 380                 /* The archive locrectab contains bogus offsets.  */
 381                 goto close_and_out;
 382               to = (to + ps - 1) & ~(ps - 1);
 383
 384               /* If a range is already mmaped in, stop.  */
 385               if (mapped != NULL && ranges[upper].from >= mapped->from)
 386                 break;
 387
 388               ++upper;
 389             }
 390           /* Loop while still in contiguous pages. */
 391           while (upper < nranges && ranges[upper].from < to + ps);
 392
 393           /* Open the file if it hasn't happened yet.  */
 394           if (fd == -1)
 395             {
 396               struct stat64 st;
 397               fd = open_not_cancel_2 (archfname,
 398                                       O_RDONLY|O_LARGEFILE|O_CLOEXEC);
 399               if (fd == -1)
 400                 /* Cannot open the archive, for whatever reason.  */
 401                 return NULL;
 402               /* Now verify we think this is really the same archive file
 403                  we opened before.  If it has been changed we cannot trust
 404                  the header we read previously.  */
 405               if (__fxstat64 (_STAT_VER, fd, &st) < 0
 406                   || st.st_size != archive_stat.st_size
 407                   || st.st_mtime != archive_stat.st_mtime
 408                   || st.st_dev != archive_stat.st_dev
 409                   || st.st_ino != archive_stat.st_ino)
 410                 goto close_and_out;
 411             }
 412
 413           /* Map the range from the archive.  */
 414           addr = __mmap64 (NULL, to - from, PROT_READ, MAP_FILE|MAP_COPY,
 415                            fd, from);
 416           if (addr == MAP_FAILED)
 417             goto close_and_out;
 418
 419           /* Allocate a record for this mapping.  */
 420           newp = (struct archmapped *) malloc (sizeof (struct archmapped));
 421           if (newp == NULL)
 422             {
 423               (void) __munmap (addr, to - from);
 424               goto close_and_out;
 425             }
 426
 427           /* And queue it.  */
 428           newp->ptr = addr;
 429           newp->from = from;
 430           newp->len = to - from;
 431           assert (last->next == mapped);
 432           newp->next = mapped;
 433           last->next = newp;
 434           last = newp;
 435
 436           /* Determine the load addresses for the category data.  */
 437           do
 438             {
 439               assert (ranges[cnt].from >= from);
 440               results[ranges[cnt].category].addr = ((char *) addr
 441                                                     + ranges[cnt].from - from);
 442               results[ranges[cnt].category].len = ranges[cnt].len;
 443             }
 444           while (++cnt < upper);
 445           --cnt;                /* The 'for' will increase 'cnt' again.  */
 446         }
 447     }
 448
 449   /* We don't need the file descriptor any longer.  */
 450   if (fd >= 0)
 451     close_not_cancel_no_status (fd);
 452   fd = -1;
 453
 454   /* We succeeded in mapping all the necessary regions of the archive.
 455      Now we need the expected data structures to point into the data.  */
 456
 457   lia = malloc (sizeof *lia);
 458   if (__builtin_expect (lia == NULL, 0))
 459     return NULL;
 460
 461   lia->name = strdup (*namep);
 462   if (__builtin_expect (lia->name == NULL, 0))
 463     {
 464       free (lia);
 465       return NULL;
 466     }
 467
 468   lia->next = archloaded;
 469   archloaded = lia;
 470
 471   for (cnt = 0; cnt < __LC_LAST; ++cnt)
 472     if (cnt != LC_ALL)
 473       {
 474         lia->data[cnt] = _nl_intern_locale_data (cnt,
 475                                                  results[cnt].addr,
 476                                                  results[cnt].len);
 477         if (__builtin_expect (lia->data[cnt] != NULL, 1))
 478           {
 479             /* _nl_intern_locale_data leaves us these fields to initialize.  */
 480             lia->data[cnt]->alloc = ld_archive;
 481             lia->data[cnt]->name = lia->name;
 482
 483             /* We do this instead of bumping the count each time we return
 484                this data because the mappings stay around forever anyway
 485                and we might as well hold on to a little more memory and not
 486                have to rebuild it on the next lookup of the same thing.
 487                If we were to maintain the usage_count normally and let the
 488                structures be freed, we would have to remove the elements
 489                from archloaded too.  */
 490             lia->data[cnt]->usage_count = UNDELETABLE;
 491           }
 492       }
 493
 494   *namep = lia->name;
 495   return lia->data[category];
 496 }
 497
 498 void __libc_freeres_fn_section
 499 _nl_archive_subfreeres (void)
 500 {
 501   struct locale_in_archive *lia;
 502   struct archmapped *am;
 503
 504   /* Toss out our cached locales.  */
 505   lia = archloaded;
 506   while (lia != NULL)
 507     {
 508       int category;
 509       struct locale_in_archive *dead = lia;
 510       lia = lia->next;
 511
 512       free (dead->name);
 513       for (category = 0; category < __LC_LAST; ++category)
 514         if (category != LC_ALL)
 515           {
 516             /* _nl_unload_locale just does this free for the archive case.  */
 517             if (dead->data[category]->private.cleanup)
 518               (*dead->data[category]->private.cleanup) (dead->data[category]);
 519
 520             free (dead->data[category]);
 521           }
 522       free (dead);
 523     }
 524   archloaded = NULL;
 525
 526   if (archmapped != NULL)
 527     {
 528       /* Now toss all the mapping windows, which we know nothing is using any
 529          more because we just tossed all the locales that point into them.  */
 530
 531       assert (archmapped == &headmap);
 532       archmapped = NULL;
 533       (void) __munmap (headmap.ptr, headmap.len);
 534       am = headmap.next;
 535       while (am != NULL)
 536         {
 537           struct archmapped *dead = am;
 538           am = am->next;
 539           (void) __munmap (dead->ptr, dead->len);
 540           free (dead);
 541         }
 542     }
 543 }