locale stuff should use libc safe lmalloc.  Other fixes from tests.

          --- old/usr/src/lib/libc/port/locale/localeimpl.h
          +++ new/usr/src/lib/libc/port/locale/localeimpl.h

   1    1  /*
   2    2   * This file and its contents are supplied under the terms of the
   3    3   * Common Development and Distribution License ("CDDL"), version 1.0.
   4    4   * You may only use this file in accordance with the terms of version
   5    5   * 1.0 of the CDDL.
   6    6   *
   7    7   * A full copy of the text of the CDDL should have accompanied this
   8    8   * source.  A copy of the CDDL is also available via the Internet at
   9    9   * http://www.illumos.org/license/CDDL.
  10   10   */
  11   11  
  12   12  /*
  13   13   * Copyright 2014 Garrett D'Amore <garrett@damore.org>
  14   14   */
  15   15  
  16   16  /*
  17   17   * This file implements the 2008 newlocale and friends handling. It is
  18   18   * private to libc.
  19   19   */
  20   20  #ifndef _LOCALEIMPL_H_
  21   21  #define _LOCALEIMPL_H_
  22   22  
  23   23  #ifndef _LCONV_C99
  24   24  #define _LCONV_C99      /* so we get all the extensions */
  25   25  #endif
  26   26  
  27   27  #include <sys/types.h>
  28   28  #include <locale.h>
  29   29  #include <xlocale.h>
  30   30  #include "setlocale.h"
  31   31  #include "runetype.h"
  32   32  
  33   33  /* private locale structures */
  34   34  
  35   35  /*
  36   36   * Because some locale data is rather ahem.. large, we would like to keep
  37   37   * reference counts on it.  We create an abstract header (locdata) structure
  38   38   * which keeps a point to the opaque per-category data, along with a reference
  39   39   * count to it.  To be threadsafe, we will use atomics when holding it or
  40   40   * freeing it.  (This only occurs when locale objects are created or destroyed,
  41   41   * so there should be no performance impact on hot code paths.  If your code
  42   42   * uses locale_t creation/destruction on a hot code path, its broken.  But
  43   43   * even so, the atomic and reference counting will probably *greatly* improve

  44   44   * your life as bootstrapping locale data from files is quite expensive.
  45   45   */
  46   46  
  47   47  #define NLOCDATA        4
  48   48  struct locdata {
  49   49          char            l_lname[ENCODING_LEN+1];        /* locale name */
  50   50          void            *l_data[NLOCDATA];              /* storage area */
  51   51          void            *l_map;                         /* mapped file */
  52   52          size_t          l_map_len;
  53   53          struct locdata  *l_next;                        /* link cached list */
       54 +        int             l_cached;                       /* nonzero if cached */
  54   55  };
  55   56  
  56   57  
  57   58  struct locale {
  58   59          struct locdata  *locdata[LC_ALL];
  59   60          struct locale   *next;
  60   61          int             on_list;        /* on linked list */
  61   62          char            locname[(ENCODING_LEN+1)*NLOCDATA + 1];
  62   63  
  63   64          /*

  64   65           * Convenience pointers.
  65   66           */
  66   67          const struct lc_ctype           *ctype;
  67   68          const struct lc_collate         *collate;
  68   69          const struct lc_messages        *messages;
  69   70          const struct lc_monetary        *monetary;
  70   71          const struct lc_numeric         *numeric;
  71   72          const struct lc_time            *time;
  72   73          const _RuneLocale               *runelocale;
  73   74  
  74   75          /*
  75   76           * The loaded value is used for localeconv.  In paticular, when
  76   77           * when we change the value of one of the above categories, we will
  77   78           * also need to update the lconv structure.  The loaded bit indicates
  78   79           * that the lconv structure is "current" for that category.  It's
  79   80           * sort of an "inverse dirty" bit.
  80   81           */
  81   82          int             loaded[LC_ALL];
  82   83          struct lconv    lconv;
  83   84  };
  84   85  
  85   86  
  86   87  struct locdata *__locdata_alloc(const char *, size_t);
  87   88  void __locdata_free(struct locdata *);
  88   89  struct locdata *__locdata_get_cache(int, const char *);
  89   90  void __locdata_set_cache(int, struct locdata *);
  90   91  
  91   92  struct locdata *__lc_numeric_load(const char *name);
  92   93  struct locdata *__lc_monetary_load(const char *name);
  93   94  struct locdata *__lc_messages_load(const char *name);
  94   95  struct locdata *__lc_time_load(const char *name);
  95   96  struct locdata *__lc_ctype_load(const char *name);
  96   97  struct locdata *__lc_collate_load(const char *name);
  97   98  
  98   99  extern struct locdata   __posix_numeric_locdata;
  99  100  extern struct locdata   __posix_monetary_locdata;
 100  101  extern struct locdata   __posix_messages_locdata;
 101  102  extern struct locdata   __posix_time_locdata;
 102  103  extern struct locdata   __posix_ctype_locdata;
 103  104  extern struct locdata   __posix_collate_locdata;
 104  105  extern locale_t ___global_locale;
 105  106  
 106  107  #endif  /* _LOCALEIMPL_H_ */

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX