osfmk/kern/locks.h

   1 /*
   2  * Copyright (c) 2003-2005 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_OSREFERENCE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License.  The rights granted to you under the
  10  * License may not be used to create, or enable the creation or
  11  * redistribution of, unlawful or unlicensed copies of an Apple operating
  12  * system, or to circumvent, violate, or enable the circumvention or
  13  * violation of, any terms of an Apple operating system software license
  14  * agreement.
  15  *
  16  * Please obtain a copy of the License at
  17  * http://www.opensource.apple.com/apsl/ and read it before using this
  18  * file.
  19  *
  20  * The Original Code and all software distributed under the License are
  21  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  22  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  23  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  25  * Please see the License for the specific language governing rights and
  26  * limitations under the License.
  27  *
  28  * @APPLE_LICENSE_OSREFERENCE_HEADER_END@
  29  */
  30
  31 #ifndef _KERN_LOCKS_H_
  32 #define _KERN_LOCKS_H_
  33
  34 #include        <sys/cdefs.h>
  35 #include        <sys/appleapiopts.h>
  36 #include        <mach/boolean.h>
  37 #include        <mach/mach_types.h>
  38 #include        <kern/kern_types.h>
  39 #include        <machine/locks.h>
  40
  41 #ifdef  MACH_KERNEL_PRIVATE
  42 #include        <kern/queue.h>
  43
  44 extern void                             lck_mod_init(
  45                                                                 void);
  46
  47 typedef unsigned int    lck_type_t;
  48
  49 #define LCK_TYPE_SPIN   1
  50 #define LCK_TYPE_MTX    2
  51 #define LCK_TYPE_RW             3
  52
  53 #endif
  54
  55 typedef unsigned int            lck_sleep_action_t;
  56
  57 #define LCK_SLEEP_DEFAULT       0x00    /* Release the lock while waiting for the event, then reclaim */
  58                                                                         /* RW locks are returned in the same mode */
  59 #define LCK_SLEEP_UNLOCK        0x01    /* Release the lock and return unheld */
  60 #define LCK_SLEEP_SHARED        0x02    /* Reclaim the lock in shared mode (RW only) */
  61 #define LCK_SLEEP_EXCLUSIVE     0x04    /* Reclaim the lock in exclusive mode (RW only) */
  62
  63 #define LCK_SLEEP_MASK          0x07    /* Valid actions */
  64
  65 #ifdef  MACH_KERNEL_PRIVATE
  66
  67 typedef struct {
  68         uint64_t                        lck_grp_spin_util_cnt;
  69         uint64_t                        lck_grp_spin_held_cnt;
  70         uint64_t                        lck_grp_spin_miss_cnt;
  71         uint64_t                        lck_grp_spin_held_max;
  72         uint64_t                        lck_grp_spin_held_cum;
  73 } lck_grp_spin_stat_t;
  74
  75 typedef struct {
  76         uint64_t                        lck_grp_mtx_util_cnt;
  77         uint64_t                        lck_grp_mtx_held_cnt;
  78         uint64_t                        lck_grp_mtx_miss_cnt;
  79         uint64_t                        lck_grp_mtx_wait_cnt;
  80         uint64_t                        lck_grp_mtx_held_max;
  81         uint64_t                        lck_grp_mtx_held_cum;
  82         uint64_t                        lck_grp_mtx_wait_max;
  83         uint64_t                        lck_grp_mtx_wait_cum;
  84 } lck_grp_mtx_stat_t;
  85
  86 typedef struct {
  87         uint64_t                        lck_grp_rw_util_cnt;
  88         uint64_t                        lck_grp_rw_held_cnt;
  89         uint64_t                        lck_grp_rw_miss_cnt;
  90         uint64_t                        lck_grp_rw_wait_cnt;
  91         uint64_t                        lck_grp_rw_held_max;
  92         uint64_t                        lck_grp_rw_held_cum;
  93         uint64_t                        lck_grp_rw_wait_max;
  94         uint64_t                        lck_grp_rw_wait_cum;
  95 } lck_grp_rw_stat_t;
  96
  97 typedef struct _lck_grp_stat_ {
  98         lck_grp_spin_stat_t     lck_grp_spin_stat;
  99         lck_grp_mtx_stat_t      lck_grp_mtx_stat;
 100         lck_grp_rw_stat_t       lck_grp_rw_stat;
 101 } lck_grp_stat_t;
 102
 103 #define LCK_GRP_MAX_NAME        64
 104
 105 typedef struct _lck_grp_ {
 106         queue_chain_t           lck_grp_link;
 107         unsigned int            lck_grp_refcnt;
 108         unsigned int            lck_grp_spincnt;
 109         unsigned int            lck_grp_mtxcnt;
 110         unsigned int            lck_grp_rwcnt;
 111         unsigned int            lck_grp_attr;
 112         char                            lck_grp_name[LCK_GRP_MAX_NAME];
 113         lck_grp_stat_t          lck_grp_stat;
 114 } lck_grp_t;
 115
 116 #define LCK_GRP_NULL    (lck_grp_t *)0
 117
 118 #else
 119 typedef struct __lck_grp__ lck_grp_t;
 120 #endif
 121
 122 #ifdef  MACH_KERNEL_PRIVATE
 123 typedef struct _lck_grp_attr_ {
 124         unsigned int    grp_attr_val;
 125 } lck_grp_attr_t;
 126
 127 extern lck_grp_attr_t  LockDefaultGroupAttr;
 128
 129 #define LCK_GRP_ATTR_STAT       0x1
 130
 131 #else
 132 typedef struct __lck_grp_attr__ lck_grp_attr_t;
 133 #endif
 134
 135 #define LCK_GRP_ATTR_NULL       (lck_grp_attr_t *)0
 136
 137 __BEGIN_DECLS
 138
 139 extern  lck_grp_attr_t  *lck_grp_attr_alloc_init(
 140                                                                         void);
 141
 142 extern  void                    lck_grp_attr_setdefault(
 143                                                                         lck_grp_attr_t  *attr);
 144
 145 extern  void                    lck_grp_attr_setstat(
 146                                                                         lck_grp_attr_t  *attr);
 147
 148 extern  void                    lck_grp_attr_free(
 149                                                                         lck_grp_attr_t  *attr);
 150
 151 extern  lck_grp_t               *lck_grp_alloc_init(
 152                                                                         const char*             grp_name,
 153                                                                         lck_grp_attr_t  *attr);
 154
 155 __END_DECLS
 156
 157 #ifdef  MACH_KERNEL_PRIVATE
 158 extern  void                    lck_grp_init(
 159                                                                         lck_grp_t               *grp,
 160                                                                         const char*             grp_name,
 161                                                                         lck_grp_attr_t  *attr);
 162
 163 extern  void                    lck_grp_reference(
 164                                                                         lck_grp_t               *grp);
 165
 166 extern  void                    lck_grp_deallocate(
 167                                                                         lck_grp_t                *grp);
 168
 169 extern  void                    lck_grp_lckcnt_incr(
 170                                                                         lck_grp_t               *grp,
 171                                                                         lck_type_t              lck_type);
 172
 173 extern  void                    lck_grp_lckcnt_decr(
 174                                                                         lck_grp_t               *grp,
 175                                                                         lck_type_t              lck_type);
 176 #endif
 177
 178 __BEGIN_DECLS
 179
 180 extern void                             lck_grp_free(
 181                                                                         lck_grp_t               *grp);
 182
 183 __END_DECLS
 184
 185 #ifdef  MACH_KERNEL_PRIVATE
 186 typedef struct _lck_attr_ {
 187         unsigned int    lck_attr_val;
 188 } lck_attr_t;
 189
 190 extern lck_attr_t      LockDefaultLckAttr;
 191
 192 #define         LCK_ATTR_NONE           0
 193 #define LCK_ATTR_DEBUG  0x1
 194
 195 #else
 196 typedef struct __lck_attr__ lck_attr_t;
 197 #endif
 198
 199 #define LCK_ATTR_NULL (lck_attr_t *)0
 200
 201 __BEGIN_DECLS
 202
 203 extern  lck_attr_t              *lck_attr_alloc_init(
 204                                                                         void);
 205
 206 extern  void                    lck_attr_setdefault(
 207                                                                         lck_attr_t              *attr);
 208
 209 extern  void                    lck_attr_setdebug(
 210                                                                         lck_attr_t              *attr);
 211
 212 extern  void                    lck_attr_free(
 213                                                                         lck_attr_t              *attr);
 214
 215 #define decl_lck_spin_data(class,name)     class lck_spin_t name;
 216
 217 extern lck_spin_t               *lck_spin_alloc_init(
 218                                                                         lck_grp_t               *grp,
 219                                                                         lck_attr_t              *attr);
 220
 221 extern void                             lck_spin_init(
 222                                                                         lck_spin_t              *lck,
 223                                                                         lck_grp_t               *grp,
 224                                                                         lck_attr_t              *attr);
 225
 226 extern void                             lck_spin_lock(
 227                                                                         lck_spin_t              *lck);
 228
 229 extern void                             lck_spin_unlock(
 230                                                                         lck_spin_t              *lck);
 231
 232 extern void                             lck_spin_destroy(
 233                                                                         lck_spin_t              *lck,
 234                                                                         lck_grp_t               *grp);
 235
 236 extern void                             lck_spin_free(
 237                                                                         lck_spin_t              *lck,
 238                                                                         lck_grp_t               *grp);
 239
 240 extern wait_result_t    lck_spin_sleep(
 241                                                                         lck_spin_t                      *lck,
 242                                                                         lck_sleep_action_t      lck_sleep_action,
 243                                                                         event_t                         event,
 244                                                                         wait_interrupt_t        interruptible);
 245
 246 extern wait_result_t    lck_spin_sleep_deadline(
 247                                                                         lck_spin_t                      *lck,
 248                                                                         lck_sleep_action_t      lck_sleep_action,
 249                                                                         event_t                         event,
 250                                                                         wait_interrupt_t        interruptible,
 251                                                                         uint64_t                        deadline);
 252
 253 #ifdef  KERNEL_PRIVATE
 254
 255 extern boolean_t                lck_spin_try_lock(
 256                                                                         lck_spin_t              *lck);
 257
 258 #endif
 259
 260
 261 #define decl_lck_mtx_data(class,name)     class lck_mtx_t name;
 262
 263 extern lck_mtx_t                *lck_mtx_alloc_init(
 264                                                                         lck_grp_t               *grp,
 265                                                                         lck_attr_t              *attr);
 266
 267 extern void                             lck_mtx_init(
 268                                                                         lck_mtx_t               *lck,
 269                                                                         lck_grp_t               *grp,
 270                                                                         lck_attr_t              *attr);
 271
 272 extern void                             lck_mtx_lock(
 273                                                                         lck_mtx_t               *lck);
 274
 275 extern void                             lck_mtx_unlock(
 276                                                                         lck_mtx_t               *lck);
 277
 278 extern void                             lck_mtx_destroy(
 279                                                                         lck_mtx_t               *lck,
 280                                                                         lck_grp_t               *grp);
 281
 282 extern void                             lck_mtx_free(
 283                                                                         lck_mtx_t               *lck,
 284                                                                         lck_grp_t               *grp);
 285
 286 extern wait_result_t    lck_mtx_sleep(
 287                                                                         lck_mtx_t                       *lck,
 288                                                                         lck_sleep_action_t      lck_sleep_action,
 289                                                                         event_t                         event,
 290                                                                         wait_interrupt_t        interruptible);
 291
 292 extern wait_result_t    lck_mtx_sleep_deadline(
 293                                                                         lck_mtx_t                       *lck,
 294                                                                         lck_sleep_action_t      lck_sleep_action,
 295                                                                         event_t                         event,
 296                                                                         wait_interrupt_t        interruptible,
 297                                                                         uint64_t                        deadline);
 298
 299 #ifdef  KERNEL_PRIVATE
 300
 301 extern boolean_t                lck_mtx_try_lock(
 302                                                                         lck_mtx_t               *lck);
 303
 304 #endif  /* KERNEL_PRIVATE */
 305
 306 extern void                             lck_mtx_assert(
 307                                                                         lck_mtx_t               *lck,
 308                                                                         unsigned int    type);
 309
 310 __END_DECLS
 311
 312 #define LCK_MTX_ASSERT_OWNED    0x01
 313 #define LCK_MTX_ASSERT_NOTOWNED 0x02
 314
 315 #ifdef  MACH_KERNEL_PRIVATE
 316 extern void                             lck_mtx_lock_wait(
 317                                                                         lck_mtx_t               *lck,
 318                                                                         thread_t                holder);
 319
 320 extern int                              lck_mtx_lock_acquire(
 321                                                                         lck_mtx_t               *lck);
 322
 323 extern void                             lck_mtx_unlock_wakeup(
 324                                                                         lck_mtx_t               *lck,
 325                                                                         thread_t                holder);
 326
 327 extern boolean_t                lck_mtx_ilk_unlock(
 328                                                                         lck_mtx_t               *lck);
 329 #endif
 330
 331 #define decl_lck_rw_data(class,name)     class lck_rw_t name;
 332
 333 typedef unsigned int     lck_rw_type_t;
 334
 335 #define LCK_RW_TYPE_SHARED                      0x01
 336 #define LCK_RW_TYPE_EXCLUSIVE           0x02
 337
 338 __BEGIN_DECLS
 339
 340 extern lck_rw_t                 *lck_rw_alloc_init(
 341                                                                         lck_grp_t               *grp,
 342                                                                         lck_attr_t              *attr);
 343
 344 extern void                             lck_rw_init(
 345                                                                         lck_rw_t                *lck,
 346                                                                         lck_grp_t               *grp,
 347                                                                         lck_attr_t              *attr);
 348
 349 extern void                             lck_rw_lock(
 350                                                                         lck_rw_t                *lck,
 351                                                                         lck_rw_type_t   lck_rw_type);
 352
 353 extern void                             lck_rw_unlock(
 354                                                                         lck_rw_t                *lck,
 355                                                                         lck_rw_type_t   lck_rw_type);
 356
 357 extern void                             lck_rw_lock_shared(
 358                                                                         lck_rw_t                *lck);
 359
 360 extern void                             lck_rw_unlock_shared(
 361                                                                         lck_rw_t                *lck);
 362
 363 extern void                             lck_rw_lock_exclusive(
 364                                                                         lck_rw_t                *lck);
 365
 366 extern void                             lck_rw_unlock_exclusive(
 367                                                                         lck_rw_t                *lck);
 368
 369 #ifdef  KERNEL_PRIVATE
 370
 371 extern lck_rw_type_t    lck_rw_done(
 372                                                                         lck_rw_t                *lck);
 373 #endif
 374
 375 extern void                             lck_rw_destroy(
 376                                                                         lck_rw_t                *lck,
 377                                                                         lck_grp_t               *grp);
 378
 379 extern void                             lck_rw_free(
 380                                                                         lck_rw_t                *lck,
 381                                                                         lck_grp_t               *grp);
 382
 383 extern wait_result_t    lck_rw_sleep(
 384                                                                         lck_rw_t                        *lck,
 385                                                                         lck_sleep_action_t      lck_sleep_action,
 386                                                                         event_t                         event,
 387                                                                         wait_interrupt_t        interruptible);
 388
 389 extern wait_result_t    lck_rw_sleep_deadline(
 390                                                                         lck_rw_t                        *lck,
 391                                                                         lck_sleep_action_t      lck_sleep_action,
 392                                                                         event_t                         event,
 393                                                                         wait_interrupt_t        interruptible,
 394                                                                         uint64_t                        deadline);
 395
 396 #ifdef  KERNEL_PRIVATE
 397
 398 extern boolean_t                lck_rw_lock_shared_to_exclusive(
 399                                                                         lck_rw_t                *lck);
 400
 401 extern void                             lck_rw_lock_exclusive_to_shared(
 402                                                                         lck_rw_t                *lck);
 403
 404 extern boolean_t                lck_rw_try_lock(
 405                                                                         lck_rw_t                *lck,
 406                                                                         lck_rw_type_t   lck_rw_type);
 407
 408 extern boolean_t                lck_rw_try_lock_shared(
 409                                                                         lck_rw_t                *lck);
 410
 411 extern boolean_t                lck_rw_try_lock_exclusive(
 412                                                                         lck_rw_t                *lck);
 413 #endif
 414
 415 __END_DECLS
 416
 417 #endif /* _KERN_LOCKS_H_ */