osfmk/mach/flipc_locks.h

   1 /*
   2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * The contents of this file constitute Original Code as defined in and
   7  * are subject to the Apple Public Source License Version 1.1 (the
   8  * "License").  You may not use this file except in compliance with the
   9  * License.  Please obtain a copy of the License at
  10  * http://www.apple.com/publicsource and read it before using this file.
  11  *
  12  * This Original Code and all software distributed under the License are
  13  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17  * License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * @APPLE_LICENSE_HEADER_END@
  21  */
  22 /*
  23  * @OSF_COPYRIGHT@
  24  *
  25  */
  26 /*
  27  * HISTORY
  28  *
  29  * Revision 1.1.1.1  1998/09/22 21:05:30  wsanchez
  30  * Import of Mac OS X kernel (~semeria)
  31  *
  32  * Revision 1.1.1.1  1998/03/07 02:25:45  wsanchez
  33  * Import of OSF Mach kernel (~mburg)
  34  *
  35  * Revision 1.1.4.1  1995/06/13  18:20:29  sjs
  36  *      Merged from flipc_shared.
  37  *      [95/06/07            sjs]
  38  *
  39  * Revision 1.1.2.3  1995/03/09  19:42:30  rwd
  40  *      Move yield function out of macro and prototype.
  41  *      [1995/03/09  19:36:25  rwd]
  42  *
  43  * Revision 1.1.2.2  1995/02/21  17:23:11  randys
  44  *      Re-indented code to four space indentation
  45  *      [1995/02/21  16:25:39  randys]
  46  *
  47  * Revision 1.1.2.1  1994/12/20  19:02:06  randys
  48  *      Moved definition of flipc_simple_lock to flipc_cb.h
  49  *      [1994/12/20  17:34:44  randys]
  50  *
  51  *      Separated the lock macros out into machine dependent and independent files;
  52  *      this is the machine independent file.
  53  *      [1994/12/20  16:43:38  randys]
  54  *
  55  * $EndLog$
  56  */
  57
  58 /*
  59  * mach/flipc_locks.h
  60  *
  61  * The machine independent part of the flipc_simple_locks definitions.
  62  * Most of the locks definitions is in flipc_dep.h, but what isn't
  63  * dependent on the platform being used is here.
  64  */
  65
  66 /*
  67  * Note that the locks defined in this file and in flipc_dep.h are only
  68  * for use by user level code.  The reason why this file is visible to
  69  * the kernel is that the kernel section of flipc needs to initialize
  70  * these locks.
  71  */
  72
  73 #ifndef _MACH_FLIPC_LOCKS_H_
  74 #define _MACH_FLIPC_LOCKS_H_
  75
  76 /* Get the simple lock type.  */
  77 #include <mach/flipc_cb.h>
  78
  79 /*
  80  * Lock function prototypes.  This needs to be before any lock definitions
  81  * that happen to be macros.
  82  */
  83
  84 /* Initializes lock.  Always a macro (so that kernel code can use it without
  85    library assistance).  */
  86 void flipc_simple_lock_init(flipc_simple_lock *lock);
  87
  88 /* Returns 1 if lock gained, 0 otherwise.  */
  89 int flipc_simple_lock_try(flipc_simple_lock *lock);
  90
  91 /* Returns 1 if lock is locked, 0 otherwise.  */
  92 int flipc_simple_lock_locked(flipc_simple_lock *lock);
  93
  94 /* Releases the lock.  */
  95 void flipc_simple_lock_release(flipc_simple_lock *lock);
  96
  97 /* Take the lock.  */
  98 void flipc_simple_lock_acquire(flipc_simple_lock *lock);
  99
 100 /* Take two locks.  Does not hold one while spinning on the
 101    other.  */
 102 void flipc_simple_lock_acquire_2(flipc_simple_lock *lock1,
 103                            flipc_simple_lock *lock2);
 104
 105 /* Get the machine dependent stuff.  The things that need to be
 106  * defined in a machine dependent fashion are:
 107  *
 108  *   flipc_simple_lock_init     (must be a macro)
 109  *   flipc_simple_lock_try
 110  *   flipc_simple_lock_locked
 111  *   flipc_simple_lock_release
 112  *
 113  * These last three don't necessarily have to be macros, but if they
 114  * aren't definitions must be included in the machine dependent
 115  * part of the user level library code.
 116  */
 117 #include <mach/machine/flipc_dep.h>
 118
 119 /*
 120  * Set at flipc initialization time to thread_yield argument to
 121  * FLIPC_domain_init
 122  */
 123
 124 extern void (*flipc_simple_lock_yield_fn)(void);
 125
 126 /*
 127  * Machine independent definitions; defined in terms of above routines.
 128  */
 129
 130 /* Take the lock.  Assumes an external define saying how long to
 131    spin, and an external function to call when we've spun too long.  */
 132 #define flipc_simple_lock_acquire(lock)         \
 133 do {                                            \
 134   int __spin_count = 0;                         \
 135                                                 \
 136   while (flipc_simple_lock_locked(lock)         \
 137          || !flipc_simple_lock_try(lock))       \
 138     if (++__spin_count > LOCK_SPIN_LIMIT) {     \
 139       (*flipc_simple_lock_yield_fn)();          \
 140       __spin_count = 0;                         \
 141     }                                           \
 142 } while (0)
 143
 144 /* Take two locks.  Hold neither while spinning on the other.  */
 145 #define flipc_simple_lock_acquire_2(lock1, lock2)       \
 146 do {                                                    \
 147   int __spin_count = 0;                                 \
 148                                                         \
 149   while (1) {                                           \
 150     while (flipc_simple_lock_locked(lock1)              \
 151            || !flipc_simple_lock_try(lock1))            \
 152       if (++__spin_count > LOCK_SPIN_LIMIT) {           \
 153         (*flipc_simple_lock_yield_fn)();                \
 154         __spin_count = 0;                               \
 155       }                                                 \
 156                                                         \
 157     if (flipc_simple_lock_try(lock2))                   \
 158       break;                                            \
 159     flipc_simple_lock_release(lock1);                   \
 160                                                         \
 161     while (flipc_simple_lock_locked(lock2)              \
 162            || !flipc_simple_lock_try(lock2))            \
 163       if (++__spin_count > LOCK_SPIN_LIMIT) {           \
 164         (*flipc_simple_lock_yield_fn)();                \
 165         __spin_count = 0;                               \
 166       }                                                 \
 167                                                         \
 168     if (flipc_simple_lock_try(lock1))                   \
 169       break;                                            \
 170     flipc_simple_lock_release(lock2);                   \
 171   }                                                     \
 172 } while (0)
 173
 174 #endif  /* _MACH_FLIPC_LOCKS_H_ */