OS-6363 system went to dark side of moon for ~467 seconds OS-6404 ARC reclaim should throttle its calls to arc_kmem_reap_now() Reviewed by: Bryan Cantrill <bryan@joyent.com> Reviewed by: Dan McDonald <danmcd@joyent.com>

          --- old/usr/src/lib/libfakekernel/common/kmem.c
          +++ new/usr/src/lib/libfakekernel/common/kmem.c

   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 2013 Nexenta Systems, Inc.  All rights reserved.
       14 + * Copyright (c) 2017, Joyent, Inc.
  14   15   */
  15   16  
  16   17  #include <sys/kmem.h>
  17   18  
  18   19  #include <sys/debug.h>
  19   20  #include <sys/ksynch.h>
  20   21  #include <sys/systm.h>
  21   22  
  22   23  #include <umem.h>
  23   24  

  24   25  void    abort(void) __NORETURN;
  25   26  
  26   27  static int
  27   28  kmem_failed_cb(void)
  28   29  {
  29   30          abort();
  30   31          return (UMEM_CALLBACK_RETRY);
  31   32  }
  32   33  
  33   34  #pragma init(_kmem_init)
  34   35  static int
  35   36  _kmem_init(void)
  36   37  {
  37   38          umem_nofail_callback(kmem_failed_cb);
  38   39          return (0);
  39   40  }
  40   41  
  41   42  static int
  42   43  kmem2umem_flags(int kmflags)
  43   44  {
  44   45          int umflags = UMEM_NOFAIL;
  45   46          if (kmflags & KM_NOSLEEP)
  46   47                  umflags = UMEM_DEFAULT;
  47   48          return (umflags);
  48   49  }
  49   50  
  50   51  int
  51   52  kmem_debugging(void)
  52   53  {
  53   54          return (0);
  54   55  }
  55   56  
  56   57  void *
  57   58  kmem_alloc(size_t size, int kmflags)
  58   59  {
  59   60          return (umem_alloc(size, kmem2umem_flags(kmflags)));
  60   61  }
  61   62  
  62   63  void *
  63   64  kmem_zalloc(size_t size, int kmflags)
  64   65  {
  65   66          return (umem_zalloc(size, kmem2umem_flags(kmflags)));
  66   67  }
  67   68  
  68   69  
  69   70  void
  70   71  kmem_free(void *buf, size_t size)
  71   72  {
  72   73          umem_free(buf, size);
  73   74  }
  74   75  
  75   76  /* void *kmem_alloc_tryhard(size_t size, size_t *alloc_size, int kmflags); */
  76   77  
  77   78  kmem_cache_t *
  78   79  kmem_cache_create(
  79   80          char *name,             /* descriptive name for this cache */
  80   81          size_t bufsize,         /* size of the objects it manages */
  81   82          size_t align,           /* required object alignment */
  82   83          int (*constructor)(void *, void *, int), /* object constructor */
  83   84          void (*destructor)(void *, void *),     /* object destructor */
  84   85          void (*reclaim)(void *), /* memory reclaim callback */
  85   86          void *private,          /* pass-thru arg for constr/destr/reclaim */
  86   87          vmem_t *vmp,            /* vmem source for slab allocation */
  87   88          int kcflags)            /* cache creation flags */
  88   89  {
  89   90          umem_cache_t *uc;
  90   91          int ucflags = 0;
  91   92  
  92   93          /* Ignore KMC_NOTOUCH - not needed for userland caches */
  93   94          if (kcflags & KMC_NODEBUG)
  94   95                  ucflags |= UMC_NODEBUG;
  95   96          if (kcflags & KMC_NOMAGAZINE)
  96   97                  ucflags |= UMC_NOMAGAZINE;
  97   98          if (kcflags & KMC_NOHASH)
  98   99                  ucflags |= UMC_NOHASH;
  99  100  
 100  101          uc = umem_cache_create(name, bufsize, align,
 101  102              constructor, destructor, reclaim,
 102  103              private, vmp, ucflags);
 103  104          return ((kmem_cache_t *)uc);
 104  105  }
 105  106  
 106  107  void
 107  108  kmem_cache_destroy(kmem_cache_t *kc)
 108  109  {
 109  110          umem_cache_destroy((umem_cache_t *)kc);
 110  111  }
 111  112  
 112  113  void *
 113  114  kmem_cache_alloc(kmem_cache_t *kc, int kmflags)
 114  115  {
 115  116          return (umem_cache_alloc((umem_cache_t *)kc,
 116  117              kmem2umem_flags(kmflags)));
 117  118  }
 118  119  
 119  120  void
 120  121  kmem_cache_free(kmem_cache_t *kc, void *p)

 121  122  {
 122  123          umem_cache_free((umem_cache_t *)kc, p);
 123  124  }
 124  125  
 125  126  /* ARGSUSED */
 126  127  void
 127  128  kmem_cache_set_move(kmem_cache_t *kc,
 128  129          kmem_cbrc_t (*fun)(void *, void *, size_t, void *))
 129  130  {
 130  131  }
      132 +
      133 +boolean_t
      134 +kmem_cache_reap_active(void)
      135 +{
      136 +        return (B_FALSE);
      137 +}
      138 +
      139 +/* ARGSUSED */
      140 +void
      141 +kmem_cache_reap_soon(kmem_cache_t *kc)
      142 +{
      143 +}
 131  144  
 132  145  /* ARGSUSED */
 133  146  void
 134  147  kmem_cache_reap_now(kmem_cache_t *kc)
 135  148  {
 136  149  }
 137  150  
 138  151  /* uint64_t kmem_cache_stat(kmem_cache_t *, char *); */
 139  152  
 140  153  /* ARGSUSED */

 141  154  void
 142  155  vmem_qcache_reap(struct  vmem *vmp)
 143  156  {
 144  157  }
 145  158  
 146  159  void
 147  160  strfree(char *str)
 148  161  {
 149  162          ASSERT(str != NULL);
 150  163          kmem_free(str, strlen(str) + 1);
 151  164  }

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX