locale/loadarchive.c

   1 /* Code to load locale data from the locale archive file.
   2    Copyright (C) 2002, 2003, 2005 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, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <locale.h>
  21 #include <stddef.h>
  22 #include <stdlib.h>
  23 #include <stdbool.h>
  24 #include <errno.h>
  25 #include <assert.h>
  26 #include <string.h>
  27 #include <fcntl.h>
  28 #include <unistd.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);
 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, O_RDONLY|O_LARGEFILE);
 398               if (fd == -1)
 399                 /* Cannot open the archive, for whatever reason.  */
 400                 return NULL;
 401               /* Now verify we think this is really the same archive file
 402                  we opened before.  If it has been changed we cannot trust
 403                  the header we read previously.  */
 404               if (__fxstat64 (_STAT_VER, fd, &st) < 0
 405                   || st.st_size != archive_stat.st_size
 406                   || st.st_mtime != archive_stat.st_mtime
 407                   || st.st_dev != archive_stat.st_dev
 408                   || st.st_ino != archive_stat.st_ino)
 409                 goto close_and_out;
 410             }
 411
 412           /* Map the range from the archive.  */
 413           addr = __mmap64 (NULL, to - from, PROT_READ, MAP_FILE|MAP_COPY,
 414                            fd, from);
 415           if (addr == MAP_FAILED)
 416             goto close_and_out;
 417
 418           /* Allocate a record for this mapping.  */
 419           newp = (struct archmapped *) malloc (sizeof (struct archmapped));
 420           if (newp == NULL)
 421             {
 422               (void) __munmap (addr, to - from);
 423               goto close_and_out;
 424             }
 425
 426           /* And queue it.  */
 427           newp->ptr = addr;
 428           newp->from = from;
 429           newp->len = to - from;
 430           assert (last->next == mapped);
 431           newp->next = mapped;
 432           last->next = newp;
 433           last = newp;
 434
 435           /* Determine the load addresses for the category data.  */
 436           do
 437             {
 438               assert (ranges[cnt].from >= from);
 439               results[ranges[cnt].category].addr = ((char *) addr
 440                                                     + ranges[cnt].from - from);
 441               results[ranges[cnt].category].len = ranges[cnt].len;
 442             }
 443           while (++cnt < upper);
 444           --cnt;                /* The 'for' will increase 'cnt' again.  */
 445         }
 446     }
 447
 448   /* We don't need the file descriptor any longer.  */
 449   if (fd >= 0)
 450     close_not_cancel_no_status (fd);
 451   fd = -1;
 452
 453   /* We succeeded in mapping all the necessary regions of the archive.
 454      Now we need the expected data structures to point into the data.  */
 455
 456   lia = malloc (sizeof *lia);
 457   if (__builtin_expect (lia == NULL, 0))
 458     return NULL;
 459
 460   lia->name = strdup (*namep);
 461   if (__builtin_expect (lia->name == NULL, 0))
 462     {
 463       free (lia);
 464       return NULL;
 465     }
 466
 467   lia->next = archloaded;
 468   archloaded = lia;
 469
 470   for (cnt = 0; cnt < __LC_LAST; ++cnt)
 471     if (cnt != LC_ALL)
 472       {
 473         lia->data[cnt] = _nl_intern_locale_data (cnt,
 474                                                  results[cnt].addr,
 475                                                  results[cnt].len);
 476         if (__builtin_expect (lia->data[cnt] != NULL, 1))
 477           {
 478             /* _nl_intern_locale_data leaves us these fields to initialize.  */
 479             lia->data[cnt]->alloc = ld_archive;
 480             lia->data[cnt]->name = lia->name;
 481
 482             /* We do this instead of bumping the count each time we return
 483                this data because the mappings stay around forever anyway
 484                and we might as well hold on to a little more memory and not
 485                have to rebuild it on the next lookup of the same thing.
 486                If we were to maintain the usage_count normally and let the
 487                structures be freed, we would have to remove the elements
 488                from archloaded too.  */
 489             lia->data[cnt]->usage_count = UNDELETABLE;
 490           }
 491       }
 492
 493   *namep = lia->name;
 494   return lia->data[category];
 495 }
 496
 497 void __libc_freeres_fn_section
 498 _nl_archive_subfreeres (void)
 499 {
 500   struct locale_in_archive *lia;
 501   struct archmapped *am;
 502
 503   /* Toss out our cached locales.  */
 504   lia = archloaded;
 505   while (lia != NULL)
 506     {
 507       int category;
 508       struct locale_in_archive *dead = lia;
 509       lia = lia->next;
 510
 511       free (dead->name);
 512       for (category = 0; category < __LC_LAST; ++category)
 513         if (category != LC_ALL)
 514           {
 515             /* _nl_unload_locale just does this free for the archive case.  */
 516             if (dead->data[category]->private.cleanup)
 517               (*dead->data[category]->private.cleanup) (dead->data[category]);
 518
 519             free (dead->data[category]);
 520           }
 521       free (dead);
 522     }
 523   archloaded = NULL;
 524
 525   if (archmapped != NULL)
 526     {
 527       /* Now toss all the mapping windows, which we know nothing is using any
 528          more because we just tossed all the locales that point into them.  */
 529
 530       assert (archmapped == &headmap);
 531       archmapped = NULL;
 532       (void) __munmap (headmap.ptr, headmap.len);
 533       am = headmap.next;
 534       while (am != NULL)
 535         {
 536           struct archmapped *dead = am;
 537           am = am->next;
 538           (void) __munmap (dead->ptr, dead->len);
 539           free (dead);
 540         }
 541     }
 542 }