X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/d9a64523371fa019c4575bb400cbbc3a50ac9903..2a1bd2d3eef5c7a7bb14f4bb9fdbca9a96ee4752:/osfmk/kern/simple_lock.h diff --git a/osfmk/kern/simple_lock.h b/osfmk/kern/simple_lock.h index b66313f7f..67eb28971 100644 --- a/osfmk/kern/simple_lock.h +++ b/osfmk/kern/simple_lock.h @@ -2,7 +2,7 @@ * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved. * * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ - * + * * This file contains Original Code and/or Modifications of Original Code * as defined in and that are subject to the Apple Public Source License * Version 2.0 (the 'License'). You may not use this file except in @@ -11,10 +11,10 @@ * unlawful or unlicensed copies of an Apple operating system, or to * circumvent, violate, or enable the circumvention or violation of, any * terms of an Apple operating system software license agreement. - * + * * Please obtain a copy of the License at * http://www.opensource.apple.com/apsl/ and read it before using this file. - * + * * The Original Code and all software distributed under the License are * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, @@ -22,10 +22,10 @@ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. * Please see the License for the specific language governing rights and * limitations under the License. - * + * * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ -/* +/* * Copyright (C) 1998 Apple Computer * All Rights Reserved */ @@ -36,24 +36,24 @@ * Mach Operating System * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University * All Rights Reserved. - * + * * Permission to use, copy, modify and distribute this software and its * documentation is hereby granted, provided that both the copyright * notice and this permission notice appear in all copies of the * software, derivative works or modified versions, and any portions * thereof, and that both notices appear in supporting documentation. - * + * * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. - * + * * Carnegie Mellon requests users of this software to return to - * + * * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU * School of Computer Science * Carnegie Mellon University * Pittsburgh PA 15213-3890 - * + * * any improvements or extensions that they make and grant Carnegie Mellon * the rights to redistribute these changes. */ @@ -65,123 +65,182 @@ * Atomic primitives and Simple Locking primitives definitions */ -#ifdef KERNEL_PRIVATE +#ifdef KERNEL_PRIVATE -#ifndef _KERN_SIMPLE_LOCK_H_ -#define _KERN_SIMPLE_LOCK_H_ +#ifndef _KERN_SIMPLE_LOCK_H_ +#define _KERN_SIMPLE_LOCK_H_ #include #include #include +#include #include -#ifdef MACH_KERNEL_PRIVATE +#ifdef MACH_KERNEL_PRIVATE +#include #include -extern void hw_lock_init( - hw_lock_t); +extern void hw_lock_init( + hw_lock_t); + +#if LOCK_STATS +extern void hw_lock_lock( + hw_lock_t, + lck_grp_t*); + +extern void hw_lock_lock_nopreempt( + hw_lock_t, + lck_grp_t*); + +extern unsigned int hw_lock_to( + hw_lock_t, + uint64_t, + lck_grp_t*); + +extern unsigned int hw_lock_try( + hw_lock_t, + lck_grp_t*); + +extern unsigned int hw_lock_try_nopreempt( + hw_lock_t, + lck_grp_t*); + +#else + +extern void hw_lock_lock( + hw_lock_t); + +#define hw_lock_lock(lck, grp) hw_lock_lock(lck) + +extern void hw_lock_lock_nopreempt( + hw_lock_t); +#define hw_lock_lock_nopreempt(lck, grp) hw_lock_lock_nopreempt(lck) + +extern unsigned int hw_lock_to( + hw_lock_t, + uint64_t); +#define hw_lock_to(lck, timeout, grp) hw_lock_to(lck, timeout) + + +extern unsigned int hw_lock_try( + hw_lock_t); +#define hw_lock_try(lck, grp) hw_lock_try(lck) + +extern unsigned int hw_lock_try_nopreempt( + hw_lock_t); +#define hw_lock_try_nopreempt(lck, grp) hw_lock_try_nopreempt(lck) -extern void hw_lock_lock( - hw_lock_t); -extern void hw_lock_lock_nopreempt( - hw_lock_t); +#endif /* LOCK_STATS */ -extern void hw_lock_unlock( - hw_lock_t); +extern void hw_lock_unlock( + hw_lock_t); -extern void hw_lock_unlock_nopreempt( - hw_lock_t); +extern void hw_lock_unlock_nopreempt( + hw_lock_t); -extern unsigned int hw_lock_to( - hw_lock_t, - uint64_t); +extern unsigned int hw_lock_held( + hw_lock_t); -extern unsigned int hw_lock_try( - hw_lock_t); +extern boolean_t hw_atomic_test_and_set32( + uint32_t *target, + uint32_t test_mask, + uint32_t set_mask, + enum memory_order ord, + boolean_t wait); -extern unsigned int hw_lock_try_nopreempt( - hw_lock_t); +#endif /* MACH_KERNEL_PRIVATE */ +#if XNU_KERNEL_PRIVATE -extern unsigned int hw_lock_held( - hw_lock_t); +struct usimple_lock_startup_spec { + usimple_lock_t lck; + unsigned short lck_init_arg; +}; -#endif /* MACH_KERNEL_PRIVATE */ +extern void usimple_lock_startup_init( + struct usimple_lock_startup_spec *spec); + +#define SIMPLE_LOCK_DECLARE(var, arg) \ + decl_simple_lock_data(, var); \ + static __startup_data struct usimple_lock_startup_spec \ + __startup_usimple_lock_spec_ ## var = { &var, arg }; \ + STARTUP_ARG(LOCKS_EARLY, STARTUP_RANK_FOURTH, usimple_lock_startup_init, \ + &__startup_usimple_lock_spec_ ## var) + +#endif /* XNU_KERNEL_PRIVATE */ __BEGIN_DECLS -extern uint32_t hw_atomic_add( - volatile uint32_t *dest, - uint32_t delt); +extern void * hw_wait_while_equals( + void **address, + void *current); -extern uint32_t hw_atomic_sub( - volatile uint32_t *dest, - uint32_t delt); +extern void usimple_lock_init( + usimple_lock_t, + unsigned short); -extern uint32_t hw_atomic_or( - volatile uint32_t *dest, - uint32_t mask); +#if LOCK_STATS +extern void usimple_lock( + usimple_lock_t, + lck_grp_t*); -extern uint32_t hw_atomic_and( - volatile uint32_t *dest, - uint32_t mask); +extern unsigned int usimple_lock_try( + usimple_lock_t, + lck_grp_t*); -/* - * Variant of hw_atomic_or which doesn't return a value; potentially - * more efficient on some platforms. - */ -extern void hw_atomic_or_noret( - volatile uint32_t *dest, - uint32_t mask); -/* - * Variant of hw_atomic_and which doesn't return a value; potentially - * more efficient on some platforms. - */ +extern void usimple_lock_try_lock_loop( + usimple_lock_t, + lck_grp_t*); -extern void hw_atomic_and_noret( - volatile uint32_t *dest, - uint32_t mask); +#if defined(__x86_64__) +extern unsigned int usimple_lock_try_lock_mp_signal_safe_loop_deadline( + usimple_lock_t, + uint64_t, + lck_grp_t*); -extern uint32_t hw_compare_and_store( - uint32_t oldval, - uint32_t newval, - volatile uint32_t *dest); +extern unsigned int usimple_lock_try_lock_mp_signal_safe_loop_duration( + usimple_lock_t, + uint64_t, + lck_grp_t*); +#endif -extern void hw_queue_atomic( - unsigned int *anchor, - unsigned int *elem, - unsigned int disp); +#else +extern void usimple_lock( + usimple_lock_t); +#define usimple_lock(lck, grp) usimple_lock(lck) -extern void hw_queue_atomic_list( - unsigned int *anchor, - unsigned int *first, - unsigned int *last, - unsigned int disp); -extern unsigned int *hw_dequeue_atomic( - unsigned int *anchor, - unsigned int disp); +extern unsigned int usimple_lock_try( + usimple_lock_t); -extern void usimple_lock_init( - usimple_lock_t, - unsigned short); +#define usimple_lock_try(lck, grp) usimple_lock_try(lck) -extern void usimple_lock( - usimple_lock_t); +extern void usimple_lock_try_lock_loop( + usimple_lock_t); +#define usimple_lock_try_lock_loop(lck, grp) usimple_lock_try_lock_loop(lck) -extern void usimple_unlock( - usimple_lock_t); +#if defined(__x86_64__) +extern unsigned int usimple_lock_try_lock_mp_signal_safe_loop_deadline( + usimple_lock_t, + uint64_t); +#define usimple_lock_try_lock_mp_signal_safe_loop_deadline(lck, ddl, grp) usimple_lock_try_lock_mp_signal_safe_loop_deadline(lck, ddl) -extern unsigned int usimple_lock_try( - usimple_lock_t); +extern unsigned int usimple_lock_try_lock_mp_signal_safe_loop_duration( + usimple_lock_t, + uint64_t); +#define usimple_lock_try_lock_mp_signal_safe_loop_duration(lck, dur, grp) usimple_lock_try_lock_mp_signal_safe_loop_duration(lck, dur) +#endif + +#endif /* LOCK_STATS */ + +extern void usimple_unlock( + usimple_lock_t); -extern void usimple_lock_try_lock_loop( - usimple_lock_t); __END_DECLS -#define ETAP_NO_TRACE 0 -#define ETAP_IO_AHA 0 +#define ETAP_NO_TRACE 0 +#define ETAP_IO_AHA 0 /* * If we got to here and we still don't have simple_lock_init @@ -189,14 +248,78 @@ __END_DECLS * running on a true SMP, or need debug. */ #if !defined(simple_lock_init) -#define simple_lock_init(l,t) usimple_lock_init(l,t) -#define simple_lock(l) usimple_lock(l) -#define simple_unlock(l) usimple_unlock(l) -#define simple_lock_try(l) usimple_lock_try(l) -#define simple_lock_try_lock_loop(l) usimple_lock_try_lock_loop(l) -#define simple_lock_addr(l) (&(l)) +#define simple_lock_init(l, t) usimple_lock_init(l,t) +#define simple_lock(l, grp) usimple_lock(l, grp) +#define simple_unlock(l) usimple_unlock(l) +#define simple_lock_try(l, grp) usimple_lock_try(l, grp) +#define simple_lock_try_lock_loop(l, grp) usimple_lock_try_lock_loop(l, grp) +#define simple_lock_try_lock_mp_signal_safe_loop_deadline(l, ddl, grp) usimple_lock_try_lock_mp_signal_safe_loop_deadline(l, ddl, grp) +#define simple_lock_try_lock_mp_signal_safe_loop_duration(l, dur, grp) usimple_lock_try_lock_mp_signal_safe_loop_duration(l, dur, grp) +#define simple_lock_addr(l) (&(l)) #endif /* !defined(simple_lock_init) */ +#ifdef MACH_KERNEL_PRIVATE + +typedef uint32_t hw_lock_bit_t; + +#if LOCK_STATS +extern void hw_lock_bit( + hw_lock_bit_t *, + unsigned int, + lck_grp_t*); + +extern void hw_lock_bit_nopreempt( + hw_lock_bit_t *, + unsigned int, + lck_grp_t*); + +extern unsigned int hw_lock_bit_try( + hw_lock_bit_t *, + unsigned int, + lck_grp_t*); + +extern unsigned int hw_lock_bit_to( + hw_lock_bit_t *, + unsigned int, + uint32_t, + lck_grp_t*); + +#else +extern void hw_lock_bit( + hw_lock_bit_t *, + unsigned int); +#define hw_lock_bit(lck, bit, grp) hw_lock_bit(lck, bit) + +extern void hw_lock_bit_nopreempt( + hw_lock_bit_t *, + unsigned int); +#define hw_lock_bit_nopreempt(lck, bit, grp) hw_lock_bit_nopreempt(lck, bit) + +extern unsigned int hw_lock_bit_try( + hw_lock_bit_t *, + unsigned int); +#define hw_lock_bit_try(lck, bit, grp) hw_lock_bit_try(lck, bit) + +extern unsigned int hw_lock_bit_to( + hw_lock_bit_t *, + unsigned int, + uint32_t); +#define hw_lock_bit_to(lck, bit, timeout, grp) hw_lock_bit_to(lck, bit, timeout) + +#endif /* LOCK_STATS */ + +extern void hw_unlock_bit( + hw_lock_bit_t *, + unsigned int); + +extern void hw_unlock_bit_nopreempt( + hw_lock_bit_t *, + unsigned int); + +#define hw_lock_bit_held(l, b) (((*(l))&(1<