usr/src/lib/libfakekernel/common/mutex.c

          --- old/usr/src/lib/libfakekernel/common/mutex.c
          +++ new/usr/src/lib/libfakekernel/common/mutex.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      - * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
       13 + * Copyright 2018 Nexenta Systems, Inc.  All rights reserved.
  14   14   * Copyright 2017 RackTop Systems.
  15   15   */
  16   16  
  17   17  /*
  18   18   * mutex(9f)
  19   19   */
  20   20  
  21   21  /* This is the API we're emulating */
  22   22  #include <sys/mutex.h>
  23   23  
  24   24  #include <sys/errno.h>
  25   25  #include <sys/debug.h>
  26   26  #include <sys/thread.h>
  27   27  
  28   28  int     _lwp_mutex_lock(lwp_mutex_t *);
  29   29  int     _lwp_mutex_unlock(lwp_mutex_t *);
  30   30  int     _lwp_mutex_trylock(lwp_mutex_t *);
  31   31  
  32   32  extern clock_t ddi_get_lbolt(void);
  33   33  
       34 +/* See: head/synch.h ERRORCHECKMUTEX */
  34   35  static const lwp_mutex_t default_mutex =
  35      -        {{0, 0, 0, {USYNC_THREAD}, _MUTEX_MAGIC},
       36 +        {{0, 0, 0, {USYNC_THREAD|LOCK_ERRORCHECK}, _MUTEX_MAGIC},
  36   37          {{{0, 0, 0, 0, 0, 0, 0, 0}}}, 0};
  37   38  
  38   39  /* ARGSUSED */
  39   40  void
  40   41  kmutex_init(kmutex_t *mp, char *name, kmutex_type_t typ, void *arg)
  41   42  {
  42   43          mp->m_lock = default_mutex;
  43   44          mp->m_owner = _KTHREAD_INVALID;
  44   45  }
  45   46  
  46   47  /* ARGSUSED */
  47   48  void
  48   49  kmutex_destroy(kmutex_t *mp)
  49   50  {
  50   51          mp->m_owner = _KTHREAD_INVALID;
  51   52  }
  52   53  
  53   54  void
  54   55  kmutex_enter(kmutex_t *mp)
  55   56  {
       57 +        kthread_t *t = _curthread();
       58 +
       59 +        VERIFY(mp->m_owner != t);
  56   60          VERIFY(0 == _lwp_mutex_lock(&mp->m_lock));
  57      -        mp->m_owner = _curthread();
       61 +        mp->m_owner = t;
  58   62  }
  59   63  
  60   64  int
  61   65  mutex_tryenter(kmutex_t *mp)
  62   66  {
  63   67          int rc;
  64   68  
  65   69          rc = _lwp_mutex_trylock(&mp->m_lock);
  66   70          if (rc == 0) {
  67   71                  mp->m_owner = _curthread();

  68   72                  return (1);
  69   73          }
  70   74          return (0);
  71   75  }
  72   76  
  73   77  void
  74   78  kmutex_exit(kmutex_t *mp)
  75   79  {
  76   80          ASSERT(mp->m_owner == _curthread());
  77   81          mp->m_owner = _KTHREAD_INVALID;
  78   82          (void) _lwp_mutex_unlock(&mp->m_lock);
  79   83  }
  80   84  
  81   85  /*
  82   86   * Returns the kthread_t * of the owner.
  83   87   */
  84   88  void *
  85   89  mutex_owner(const kmutex_t *mp)
  86   90  {
  87   91          return (mp->m_owner);
  88   92  }
  89   93  
  90   94  int
  91   95  mutex_owned(const kmutex_t *mp)
  92   96  {
  93   97          void *t = _curthread();
  94   98          return (t == mp->m_owner);
  95   99  }

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX