sys/sys/sx.h

   1 /*
   2  * Copyright (C) 2001 Jason Evans <jasone@freebsd.org>.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice(s), this list of conditions and the following disclaimer as
   9  *    the first lines of this file unmodified other than the possible
  10  *    addition of one or more copyright notices.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice(s), this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
  16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  18  * DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY
  19  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  20  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  21  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  22  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  25  * DAMAGE.
  26  *
  27  * $FreeBSD$
  28  */
  29
  30 #ifndef _SYS_SX_H_
  31 #define _SYS_SX_H_
  32
  33 #ifndef LOCORE
  34 #include <sys/lock.h>           /* XXX */
  35 #include <sys/mutex.h>          /* XXX */
  36 #include <sys/condvar.h>        /* XXX */
  37
  38 struct lock_object;
  39
  40 struct sx {
  41         struct lock_object sx_object;   /* Common lock properties. */
  42         struct mtx      sx_lock;        /* General protection lock. */
  43         int             sx_cnt;         /* -1: xlock, > 0: slock count. */
  44         struct cv       sx_shrd_cv;     /* slock waiters. */
  45         int             sx_shrd_wcnt;   /* Number of slock waiters. */
  46         struct cv       sx_excl_cv;     /* xlock waiters. */
  47         int             sx_excl_wcnt;   /* Number of xlock waiters. */
  48         struct proc     *sx_xholder;    /* Thread presently holding xlock. */
  49 };
  50
  51 #ifdef _KERNEL
  52 void    sx_init(struct sx *sx, const char *description);
  53 void    sx_destroy(struct sx *sx);
  54 void    _sx_slock(struct sx *sx, const char *file, int line);
  55 void    _sx_xlock(struct sx *sx, const char *file, int line);
  56 void    _sx_sunlock(struct sx *sx, const char *file, int line);
  57 void    _sx_xunlock(struct sx *sx, const char *file, int line);
  58
  59 #define sx_slock(sx)    _sx_slock((sx), __FILE__, __LINE__)
  60 #define sx_xlock(sx)    _sx_xlock((sx), __FILE__, __LINE__)
  61 #define sx_sunlock(sx)  _sx_sunlock((sx), __FILE__, __LINE__)
  62 #define sx_xunlock(sx)  _sx_xunlock((sx), __FILE__, __LINE__)
  63
  64 #ifdef INVARIANTS
  65 /*
  66  * SX_ASSERT_SLOCKED() can only detect that at least *some* thread owns an
  67  * slock, but it cannot guarantee that *this* thread owns an slock.
  68  */
  69 #define SX_ASSERT_SLOCKED(sx) do {                                      \
  70         mtx_lock(&(sx)->sx_lock);                                       \
  71         _SX_ASSERT_SLOCKED((sx));                                       \
  72         mtx_unlock(&(sx)->sx_lock);                                     \
  73 } while (0)
  74 #define _SX_ASSERT_SLOCKED(sx) do {                                     \
  75         KASSERT(((sx)->sx_cnt > 0), ("%s: lacking slock %s\n",          \
  76             __FUNCTION__, (sx)->sx_object.lo_name));                    \
  77 } while (0)
  78
  79 /*
  80  * SX_ASSERT_XLOCKED() detects and guarantees that *we* own the xlock.
  81  */
  82 #define SX_ASSERT_XLOCKED(sx) do {                                      \
  83         mtx_lock(&(sx)->sx_lock);                                       \
  84         _SX_ASSERT_XLOCKED((sx));                                       \
  85         mtx_unlock(&(sx)->sx_lock);                                     \
  86 } while (0)
  87 #define _SX_ASSERT_XLOCKED(sx) do {                                     \
  88         KASSERT(((sx)->sx_xholder == curproc),                          \
  89             ("%s: thread %p lacking xlock %s\n", __FUNCTION__,          \
  90             curproc, (sx)->sx_object.lo_name));                         \
  91 } while (0)
  92
  93 #else   /* INVARIANTS */
  94 #define SX_ASSERT_SLOCKED(sx)
  95 #define SX_ASSERT_XLOCKED(sx)
  96 #define _SX_ASSERT_SLOCKED(sx)
  97 #define _SX_ASSERT_XLOCKED(sx)
  98 #endif  /* INVARIANTS */
  99
 100 #endif  /* _KERNEL */
 101 #endif  /* !LOCORE */
 102 #endif  /* _SYS_SX_H_ */