? macppc/conf/DEBUG.MP ? macppc/pci/htb.c Index: powerpc/conf/files.powerpc =================================================================== RCS file: /cvs/src/sys/arch/powerpc/conf/files.powerpc,v retrieving revision 1.50 diff -u -p -r1.50 files.powerpc --- powerpc/conf/files.powerpc 20 Jan 2015 18:34:00 -0000 1.50 +++ powerpc/conf/files.powerpc 24 Jun 2015 00:17:00 -0000 @@ -13,7 +13,8 @@ file arch/powerpc/powerpc/process_machde file arch/powerpc/powerpc/sys_machdep.c file arch/powerpc/powerpc/trap.c file arch/powerpc/powerpc/vm_machdep.c -file arch/powerpc/powerpc/mutex.S +file arch/powerpc/powerpc/mutex.c +file arch/powerpc/powerpc/lock_machdep.c multiprocessor file arch/powerpc/powerpc/intr.c file arch/powerpc/powerpc/softintr.c Index: powerpc/include/lock.h =================================================================== RCS file: /cvs/src/sys/arch/powerpc/include/lock.h,v retrieving revision 1.5 diff -u -p -r1.5 lock.h --- powerpc/include/lock.h 11 Feb 2015 00:14:11 -0000 1.5 +++ powerpc/include/lock.h 24 Jun 2015 00:17:00 -0000 @@ -37,24 +37,6 @@ #ifndef _POWERPC_LOCK_H_ #define _POWERPC_LOCK_H_ -static __inline int -__cpu_cas(volatile unsigned long *addr, unsigned long old, unsigned long new) -{ - int success, scratch; - __asm volatile( - "1: lwarx %0, 0, %4 \n" - " cmpw 0, %0, %2 \n" - " li %1, 1 \n" - " bne 0,2f \n" - " stwcx. %3, 0, %4 \n" - " li %1, 0 \n" - " bne- 1b \n" - "2: \n" - : "=&r" (scratch), "=&r" (success) - : "r" (old), "r" (new), "r" (addr) - : "memory"); +#define SPINLOCK_SPIN_HOOK do { } while (0) - return success; -} - #endif /* _POWERPC_LOCK_H_ */ Index: powerpc/include/mplock.h =================================================================== RCS file: powerpc/include/mplock.h diff -N powerpc/include/mplock.h --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ powerpc/include/mplock.h 24 Jun 2015 00:17:00 -0000 @@ -0,0 +1,52 @@ +/* $OpenBSD: mplock.h,v 1.2 2009/09/07 19:29:33 miod Exp $ */ + +/* + * Copyright (c) 2004 Niklas Hallqvist. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _POWERPC_MPLOCK_H_ +#define _POWERPC_MPLOCK_H_ + +/* + * Really simple spinlock implementation with recursive capabilities. + * Correctness is paramount, no fancyness allowed. + */ + +struct __mp_lock { + volatile struct cpu_info *mpl_cpu; + volatile long mpl_count; +}; + +#ifndef _LOCORE + +void __mp_lock_init(struct __mp_lock *); +void __mp_lock(struct __mp_lock *); +void __mp_unlock(struct __mp_lock *); +int __mp_release_all(struct __mp_lock *); +int __mp_release_all_but_one(struct __mp_lock *); +void __mp_acquire_count(struct __mp_lock *, int); +int __mp_lock_held(struct __mp_lock *); + +#endif + +#endif /* !_POWERPC_MPLOCK_H */ Index: powerpc/include/mutex.h =================================================================== RCS file: /cvs/src/sys/arch/powerpc/include/mutex.h,v retrieving revision 1.4 diff -u -p -r1.4 mutex.h --- powerpc/include/mutex.h 29 Mar 2014 18:09:30 -0000 1.4 +++ powerpc/include/mutex.h 24 Jun 2015 00:17:00 -0000 @@ -28,9 +28,9 @@ #define _POWERPC_MUTEX_H_ struct mutex { - int mtx_wantipl; - int mtx_oldcpl; volatile void *mtx_owner; + int mtx_wantipl; + int mtx_oldipl; }; /* @@ -47,7 +47,7 @@ struct mutex { #define __MUTEX_IPL(ipl) (ipl) #endif -#define MUTEX_INITIALIZER(ipl) { __MUTEX_IPL((ipl)), 0, NULL } +#define MUTEX_INITIALIZER(ipl) { NULL, __MUTEX_IPL(ipl), IPL_NONE } void __mtx_init(struct mutex *, int); #define mtx_init(mtx, ipl) __mtx_init((mtx), __MUTEX_IPL((ipl))) @@ -67,6 +67,6 @@ void __mtx_init(struct mutex *, int); #define MUTEX_ASSERT_UNLOCKED(mtx) do { } while (0) #endif -#define MUTEX_OLDIPL(mtx) (mtx)->mtx_oldcpl +#define MUTEX_OLDIPL(mtx) ((mtx)->mtx_oldipl) #endif Index: powerpc/powerpc/lock_machdep.c =================================================================== RCS file: powerpc/powerpc/lock_machdep.c diff -N powerpc/powerpc/lock_machdep.c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ powerpc/powerpc/lock_machdep.c 24 Jun 2015 00:17:00 -0000 @@ -0,0 +1,162 @@ +/* $OpenBSD: lock_machdep.c,v 1.6 2015/04/07 09:52:27 mpi Exp $ */ + +/* + * Copyright (c) 2007 Artur Grabowski + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + + +#include +#include +#include + +#include +#include + +#include + +void +__mp_lock_init(struct __mp_lock *lock) +{ + lock->mpl_cpu = NULL; + lock->mpl_count = 0; +} + +static inline void +__mp_lock_spin(struct __mp_lock *mpl) +{ +#if defined(MP_LOCKDEBUG) + int target = ppc_mftbl() + __mftbl_per_sec() * 8; +#endif + + while (mpl->mpl_count != 0) { + SPINLOCK_SPIN_HOOK; + +#if defined(MP_LOCKDEBUG) + if ((int)ppc_mftbl() - target > 0) { + db_printf("%s: %p spun out", __func__, mpl); + Debugger(); + } +#endif + } +} + +void +__mp_lock(struct __mp_lock *mpl) +{ + /* + * Please notice that mpl_count gets incremented twice for the + * first lock. This is on purpose. The way we release the lock + * in mp_unlock is to decrement the mpl_count and then check if + * the lock should be released. Since mpl_count is what we're + * spinning on, decrementing it in mpl_unlock to 0 means that + * we can't clear mpl_cpu, because we're no longer holding the + * lock. In theory mpl_cpu doesn't need to be cleared, but it's + * safer to clear it and besides, setting mpl_count to 2 on the + * first lock makes most of this code much simpler. + */ + + while (1) { + int s; + + s = ppc_intr_disable(); + if (atomic_cas_ulong(&mpl->mpl_count, 0, 1) == 0) { + membar_enter(); + mpl->mpl_cpu = curcpu(); + } + + if (mpl->mpl_cpu == curcpu()) { + mpl->mpl_count++; + ppc_intr_enable(s); + break; + } + ppc_intr_enable(s); + + __mp_lock_spin(mpl); + } +} + +void +__mp_unlock(struct __mp_lock *mpl) +{ + int s; + +#ifdef MP_LOCKDEBUG + if (mpl->mpl_cpu != curcpu()) { + db_printf("__mp_unlock(%p): not held lock\n", mpl); + Debugger(); + } +#endif + + s = ppc_intr_disable(); + if (--mpl->mpl_count == 1) { + mpl->mpl_cpu = NULL; + membar_exit(); + mpl->mpl_count = 0; + } + ppc_intr_enable(s); +} + +int +__mp_release_all(struct __mp_lock *mpl) +{ + int count; + int s; + +#ifdef MP_LOCKDEBUG + if (mpl->mpl_cpu != curcpu()) { + db_printf("__mp_release_all(%p): not held lock\n", mpl); + Debugger(); + } +#endif + + s = ppc_intr_disable(); + count = mpl->mpl_count; + mpl->mpl_cpu = NULL; + membar_exit(); + mpl->mpl_count = 0; + ppc_intr_enable(s); + + return (count - 1); +} + +int +__mp_release_all_but_one(struct __mp_lock *mpl) +{ + int rv = mpl->mpl_count - 2; + +#ifdef MP_LOCKDEBUG + if (mpl->mpl_cpu != curcpu()) { + db_printf("__mp_release_all_but_one(%p): not held lock\n", mpl); + Debugger(); + } +#endif + + mpl->mpl_count = 2; + + return (rv); +} + +void +__mp_acquire_count(struct __mp_lock *mpl, int count) +{ + while (count--) + __mp_lock(mpl); +} + +int +__mp_lock_held(struct __mp_lock *mpl) +{ + return (mpl->mpl_cpu == curcpu()); +} Index: powerpc/powerpc/mutex.S =================================================================== RCS file: powerpc/powerpc/mutex.S diff -N powerpc/powerpc/mutex.S --- powerpc/powerpc/mutex.S 18 Jun 2014 18:42:29 -0000 1.16 +++ /dev/null 1 Jan 1970 00:00:00 -0000 @@ -1,182 +0,0 @@ -/* $OpenBSD: mutex.S,v 1.16 2014/06/18 18:42:29 kettenis Exp $ */ - -/* - * Copyright (c) 2007 Dale Rahn - * Copyright (c) 2007 Mark Kettenis - * - * Permission to use, copy, modify, and distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "assym.h" - -#include - -/* XXX */ -#define GET_CPUINFO(r) mfsprg r,0 - -ENTRY(__mtx_init) - li %r5,0 - stw %r4,MTX_WANTIPL(%r3) - stw %r5,MTX_OLDCPL(%r3) - stw %r5,MTX_OWNER(%r3) - blr - - -ENTRY(mtx_enter) - stwu %r1,-16(%r1) # reserve stack - mflr %r0 - stw %r0,20(%r1) # save return address -.L_retry: - stw %r3, 12(%r1) - lwz %r3,MTX_WANTIPL(%r3) # load new ipl - bl _C_LABEL(splraise) - mr %r7, %r3 - GET_CPUINFO(%r4) - lwz %r3,12(%r1) - li %r5,MTX_OWNER # load offset constant - lwarx %r6,%r5,%r3 # load reserve owner - cmpwi 0,%r6,0 # test owner == 0 - beq+ 0,.L_mutex_free # if owner == 0 branch free -.L_mutex_locked: -#ifdef DIAGNOSTIC - cmpl 0,%r4,%r6 - beq- .L_mutex_selflocked -#endif - stw %r3,12(%r1) # save mtx during lcsplx - la %r4,12(%r1) - stwcx. %r3,0,%r4 # unreserve owner - mr %r3,%r7 # move old cpl to arg0 - bl _C_LABEL(lcsplx) # call splx on old cpl - lwz %r3,12(%r1) - b .L_retry - -.L_mutex_free: - stwcx. %r4,%r5,%r3 # old owner was 0 cond store - bne- .L_mutex_locked # branch if reserve cancelled - isync # memory barrier -#ifdef DIAGNOSTIC - lwz %r6,CI_MUTEX_LEVEL(%r4) - addi %r6,%r6,1 # curpcu->ci_mutex_level++ - stw %r6,CI_MUTEX_LEVEL(%r4) -#endif - stw %r7,MTX_OLDCPL(%r3) # save old ipl - lwz %r0,20(%r1) # load return address - mtlr %r0 - addi %r1,%r1,16 # restore stack - blr - -#ifdef DIAGNOSTIC -.L_mutex_selflocked: - mr %r5, %r3 - lis %r3,.L_paniclocked@ha - la %r3,.L_paniclocked@l(%r3) - bl panic -.L_paniclocked: - .string "mtx_enter: recursed %x %x\n" -#endif - - -ENTRY(mtx_enter_try) - stwu %r1,-16(%r1) # reserve stack - mflr %r0 - stw %r0,20(%r1) # save return address - stw %r3, 12(%r1) - lwz %r3,MTX_WANTIPL(%r3) # load new ipl - bl _C_LABEL(splraise) - mr %r7, %r3 - GET_CPUINFO(%r4) - lwz %r3,12(%r1) - li %r5,MTX_OWNER # load offset constant - lwarx %r6,%r5,%r3 # load reserve owner - cmpwi 0,%r6,0 # test owner == 0 - beq+ 0,.L_mutex_try_free # if owner == 0 branch free -.L_mutex_try_locked: -#ifdef DIAGNOSTIC - cmpl 0,%r4,%r6 - beq- .L_mutex_try_selflocked -#endif - stw %r3,12(%r1) # save mtx during lcsplx - la %r4,12(%r1) - stwcx. %r3,0,%r4 # unreserve owner - mr %r3,%r7 # move old cpl to arg0 - bl _C_LABEL(lcsplx) # call splx on old cpl - - lwz %r0,20(%r1) # load return address - mtlr %r0 - addi %r1,%r1,16 # restore stack - li %r3,0 # return zero - blr - -.L_mutex_try_free: - stwcx. %r4,%r5,%r3 # old owner was 0 cond store - bne- .L_mutex_try_locked # branch if reserve cancelled - isync # memory barrier -#ifdef DIAGNOSTIC - lwz %r6,CI_MUTEX_LEVEL(%r4) - addi %r6,%r6,1 # curpcu->ci_mutex_level++ - stw %r6,CI_MUTEX_LEVEL(%r4) -#endif - stw %r7,MTX_OLDCPL(%r3) # save old ipl - lwz %r0,20(%r1) # load return address - mtlr %r0 - addi %r1,%r1,16 # restore stack - li %r3,1 # return nonzero - blr - -#ifdef DIAGNOSTIC -.L_mutex_try_selflocked: - mr %r5, %r3 - lis %r3,.L_panictrylocked@ha - la %r3,.L_panictrylocked@l(%r3) - bl panic -.L_panictrylocked: - .string "mtx_enter_try: recursed %x %x\n" -#endif - - -ENTRY(mtx_leave) -#ifdef DIAGNOSTIC - lwz %r6,MTX_OWNER(%r3) - cmpwi 0,%r6,0 # test owner == 0 - - beq- .L_mutex_notlocked -#endif - li %r4,0 - lwz %r5,MTX_OLDCPL(%r3) - stw %r4,MTX_OLDCPL(%r3) - sync # memory barrier - stw %r4,MTX_OWNER(%r3) - GET_CPUINFO(%r4) -#ifdef DIAGNOSTIC - lwz %r6,CI_MUTEX_LEVEL(%r4) - addi %r6,%r6,-1 # curpcu->ci_mutex_level-- - stw %r6,CI_MUTEX_LEVEL(%r4) -#endif - mr %r3,%r5 - lwz %r5,CI_CPL(%r4) - cmpl 0,%r3,%r5 - beq 1f - b _C_LABEL(lcsplx) -1: - blr - -#ifdef DIAGNOSTIC -.L_mutex_notlocked: - GET_CPUINFO(%r4) - mr %r5, %r3 - lis %r3,.L_panicnotlocked@ha - la %r3,.L_panicnotlocked@l(%r3) - bl panic -.L_panicnotlocked: - .string "mtx_leave: not locked %x %x\n" -#endif Index: powerpc/powerpc/mutex.c =================================================================== RCS file: powerpc/powerpc/mutex.c diff -N powerpc/powerpc/mutex.c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ powerpc/powerpc/mutex.c 24 Jun 2015 00:17:00 -0000 @@ -0,0 +1,141 @@ +/* $OpenBSD: mutex.c,v 1.14 2015/04/17 12:38:54 dlg Exp $ */ + +/* + * Copyright (c) 2004 Artur Grabowski + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL + * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include + +#include +#include + +#include + +void +__mtx_init(struct mutex *mtx, int ipl) +{ + mtx->mtx_owner = NULL; + mtx->mtx_wantipl = ipl; + mtx->mtx_oldipl = IPL_NONE; +} + +#ifdef MULTIPROCESSOR +void +mtx_enter(struct mutex *mtx) +{ +#if defined(MP_LOCKDEBUG) + int target = ppc_mftbl() + __mftbl_per_sec() * 8; +#endif + + while (mtx_enter_try(mtx) == 0) { + SPINLOCK_SPIN_HOOK; + +#if defined(MP_LOCKDEBUG) + if ((int)ppc_mftbl() - target > 0) { + db_printf("%s: %p lock spun out", __func__, mtx); + Debugger(); + } +#endif + } +} + +int +mtx_enter_try(struct mutex *mtx) +{ + struct cpu_info *owner, *ci = curcpu(); + int s; + + if (mtx->mtx_wantipl != IPL_NONE) + s = splraise(mtx->mtx_wantipl); + + owner = atomic_cas_ptr(&mtx->mtx_owner, NULL, ci); +#ifdef DIAGNOSTIC + if (__predict_false(owner == ci)) + panic("mtx %p: locking against myself", mtx); +#endif + if (owner == NULL) { + if (mtx->mtx_wantipl != IPL_NONE) + mtx->mtx_oldipl = s; +#ifdef DIAGNOSTIC + ci->ci_mutex_level++; +#endif + membar_enter(); + return (1); + } + + if (mtx->mtx_wantipl != IPL_NONE) + splx(s); + + return (0); +} +#else +void +mtx_enter(struct mutex *mtx) +{ + struct cpu_info *ci = curcpu(); + +#ifdef DIAGNOSTIC + if (__predict_false(mtx->mtx_owner == ci)) + panic("mtx %p: locking against myself", mtx); +#endif + if (mtx->mtx_wantipl != IPL_NONE) + mtx->mtx_oldipl = splraise(mtx->mtx_wantipl); + + mtx->mtx_owner = ci; + +#ifdef DIAGNOSTIC + ci->ci_mutex_level++; +#endif +} + +int +mtx_enter_try(struct mutex *mtx) +{ + mtx_enter(mtx); + return (1); +} +#endif + +void +mtx_leave(struct mutex *mtx) +{ + int s; + + MUTEX_ASSERT_LOCKED(mtx); + +#ifdef MULTIPROCESSOR + membar_exit(); +#endif +#ifdef DIAGNOSTIC + curcpu()->ci_mutex_level--; +#endif + + s = mtx->mtx_oldipl; + mtx->mtx_owner = NULL; + if (mtx->mtx_wantipl != IPL_NONE) + splx(s); +} Index: macppc/conf/files.macppc =================================================================== RCS file: /cvs/src/sys/arch/macppc/conf/files.macppc,v retrieving revision 1.82 diff -u -p -r1.82 files.macppc --- macppc/conf/files.macppc 2 Jun 2015 13:53:43 -0000 1.82 +++ macppc/conf/files.macppc 24 Jun 2015 00:17:00 -0000 @@ -11,7 +11,6 @@ file arch/macppc/macppc/autoconf.c file arch/macppc/macppc/clock.c file arch/macppc/macppc/conf.c file arch/macppc/macppc/disksubr.c disk -file arch/macppc/macppc/lock_machdep.c multiprocessor file arch/macppc/macppc/machdep.c file arch/macppc/macppc/wscons_machdep.c file arch/macppc/macppc/mem.c Index: macppc/include/lock.h =================================================================== RCS file: /cvs/src/sys/arch/macppc/include/lock.h,v retrieving revision 1.1 diff -u -p -r1.1 lock.h --- macppc/include/lock.h 20 Mar 2007 20:59:53 -0000 1.1 +++ macppc/include/lock.h 24 Jun 2015 00:17:00 -0000 @@ -1,3 +1,5 @@ /* $OpenBSD: lock.h,v 1.1 2007/03/20 20:59:53 kettenis Exp $ */ #include + +u_int32_t __mftbl_per_sec(void); Index: macppc/include/mplock.h =================================================================== RCS file: /cvs/src/sys/arch/macppc/include/mplock.h,v retrieving revision 1.2 diff -u -p -r1.2 mplock.h --- macppc/include/mplock.h 7 Sep 2009 19:29:33 -0000 1.2 +++ macppc/include/mplock.h 24 Jun 2015 00:17:00 -0000 @@ -1,52 +1,3 @@ /* $OpenBSD: mplock.h,v 1.2 2009/09/07 19:29:33 miod Exp $ */ -/* - * Copyright (c) 2004 Niklas Hallqvist. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef _MACHINE_MPLOCK_H_ -#define _MACHINE_MPLOCK_H_ - -/* - * Really simple spinlock implementation with recursive capabilities. - * Correctness is paramount, no fancyness allowed. - */ - -struct __mp_lock { - volatile struct cpu_info *mpl_cpu; - volatile long mpl_count; -}; - -#ifndef _LOCORE - -void __mp_lock_init(struct __mp_lock *); -void __mp_lock(struct __mp_lock *); -void __mp_unlock(struct __mp_lock *); -int __mp_release_all(struct __mp_lock *); -int __mp_release_all_but_one(struct __mp_lock *); -void __mp_acquire_count(struct __mp_lock *, int); -int __mp_lock_held(struct __mp_lock *); - -#endif - -#endif /* !_MACHINE_MPLOCK_H */ +#include Index: macppc/macppc/clock.c =================================================================== RCS file: /cvs/src/sys/arch/macppc/macppc/clock.c,v retrieving revision 1.40 diff -u -p -r1.40 clock.c --- macppc/macppc/clock.c 13 Jun 2015 07:16:36 -0000 1.40 +++ macppc/macppc/clock.c 24 Jun 2015 00:17:00 -0000 @@ -324,6 +324,12 @@ cpu_initclocks() ppc_intr_enable(intrstate); } +u_int32_t +__mftbl_per_sec(void) +{ + return (tb_timecounter.tc_frequency); +} + void cpu_startclock() { Index: macppc/macppc/genassym.cf =================================================================== RCS file: /cvs/src/sys/arch/macppc/macppc/genassym.cf,v retrieving revision 1.24 diff -u -p -r1.24 genassym.cf --- macppc/macppc/genassym.cf 6 Sep 2014 10:45:29 -0000 1.24 +++ macppc/macppc/genassym.cf 24 Jun 2015 00:17:00 -0000 @@ -85,6 +85,7 @@ struct cpu_info member ci_curproc member ci_curpcb member ci_curpm +member ci_cpuid member ci_want_resched member ci_cpl member ci_flags @@ -97,8 +98,3 @@ member ci_disisave ifdef DIAGNOSTIC member ci_mutex_level endif - -struct mutex -member mtx_wantipl -member mtx_oldcpl -member mtx_owner Index: macppc/macppc/lock_machdep.c =================================================================== RCS file: macppc/macppc/lock_machdep.c diff -N macppc/macppc/lock_machdep.c --- macppc/macppc/lock_machdep.c 7 Apr 2015 09:52:27 -0000 1.6 +++ /dev/null 1 Jan 1970 00:00:00 -0000 @@ -1,172 +0,0 @@ -/* $OpenBSD: lock_machdep.c,v 1.6 2015/04/07 09:52:27 mpi Exp $ */ - -/* - * Copyright (c) 2007 Artur Grabowski - * - * Permission to use, copy, modify, and distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - - -#include -#include -#include - -#include -#include - -#include - -void -__mp_lock_init(struct __mp_lock *lock) -{ - lock->mpl_cpu = NULL; - lock->mpl_count = 0; -} - -#if defined(MP_LOCKDEBUG) -#ifndef DDB -#error "MP_LOCKDEBUG requires DDB" -#endif - -/* CPU-dependent timing, needs this to be settable from ddb. */ -extern int __mp_lock_spinout; -#endif - -#define SPINLOCK_SPIN_HOOK /**/ - -static __inline void -__mp_lock_spin(struct __mp_lock *mpl) -{ -#ifndef MP_LOCKDEBUG - while (mpl->mpl_count != 0) - SPINLOCK_SPIN_HOOK; -#else - int ticks = __mp_lock_spinout; - - while (mpl->mpl_count != 0 && --ticks > 0) - SPINLOCK_SPIN_HOOK; - - if (ticks == 0) { - db_printf("__mp_lock(%p): lock spun out", mpl); - Debugger(); - } -#endif -} - -void -__mp_lock(struct __mp_lock *mpl) -{ - /* - * Please notice that mpl_count gets incremented twice for the - * first lock. This is on purpose. The way we release the lock - * in mp_unlock is to decrement the mpl_count and then check if - * the lock should be released. Since mpl_count is what we're - * spinning on, decrementing it in mpl_unlock to 0 means that - * we can't clear mpl_cpu, because we're no longer holding the - * lock. In theory mpl_cpu doesn't need to be cleared, but it's - * safer to clear it and besides, setting mpl_count to 2 on the - * first lock makes most of this code much simpler. - */ - - while (1) { - int s; - - s = ppc_intr_disable(); - if (__cpu_cas(&mpl->mpl_count, 0, 1) == 0) { - membar_enter(); - mpl->mpl_cpu = curcpu(); - } - - if (mpl->mpl_cpu == curcpu()) { - mpl->mpl_count++; - ppc_intr_enable(s); - break; - } - ppc_intr_enable(s); - - __mp_lock_spin(mpl); - } -} - -void -__mp_unlock(struct __mp_lock *mpl) -{ - int s; - -#ifdef MP_LOCKDEBUG - if (mpl->mpl_cpu != curcpu()) { - db_printf("__mp_unlock(%p): not held lock\n", mpl); - Debugger(); - } -#endif - - s = ppc_intr_disable(); - if (--mpl->mpl_count == 1) { - mpl->mpl_cpu = NULL; - membar_exit(); - mpl->mpl_count = 0; - } - ppc_intr_enable(s); -} - -int -__mp_release_all(struct __mp_lock *mpl) -{ - int rv = mpl->mpl_count - 1; - int s; - -#ifdef MP_LOCKDEBUG - if (mpl->mpl_cpu != curcpu()) { - db_printf("__mp_release_all(%p): not held lock\n", mpl); - Debugger(); - } -#endif - - s = ppc_intr_disable(); - mpl->mpl_cpu = NULL; - membar_exit(); - mpl->mpl_count = 0; - ppc_intr_enable(s); - - return (rv); -} - -int -__mp_release_all_but_one(struct __mp_lock *mpl) -{ - int rv = mpl->mpl_count - 2; - -#ifdef MP_LOCKDEBUG - if (mpl->mpl_cpu != curcpu()) { - db_printf("__mp_release_all_but_one(%p): not held lock\n", mpl); - Debugger(); - } -#endif - - mpl->mpl_count = 2; - - return (rv); -} - -void -__mp_acquire_count(struct __mp_lock *mpl, int count) -{ - while (count--) - __mp_lock(mpl); -} - -int -__mp_lock_held(struct __mp_lock *mpl) -{ - return mpl->mpl_cpu == curcpu(); -}