/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #pragma ident "%Z%%M% %I% %E% SMI" #if defined(lint) #include #include #include #else /* lint */ #include "assym.h" #endif /* lint */ #include #include #include #include #include #include #include #include /* #define DEBUG */ #ifdef DEBUG #include #endif /* DEBUG */ /************************************************************************ * ATOMIC OPERATIONS */ /* * uint8_t ldstub(uint8_t *cp) * * Store 0xFF at the specified location, and return its previous content. */ #if defined(lint) uint8_t ldstub(uint8_t *cp) { uint8_t rv; rv = *cp; *cp = 0xFF; return rv; } #else /* lint */ ENTRY(ldstub) retl ldstub [%o0], %o0 SET_SIZE(ldstub) #endif /* lint */ /************************************************************************ * MEMORY BARRIERS -- see atomic.h for full descriptions. */ #if defined(lint) void membar_enter(void) {} void membar_exit(void) {} void membar_producer(void) {} void membar_consumer(void) {} #else /* lint */ #ifdef SF_ERRATA_51 .align 32 ENTRY(membar_return) retl nop SET_SIZE(membar_return) #define MEMBAR_RETURN ba,pt %icc, membar_return #else #define MEMBAR_RETURN retl #endif ENTRY(membar_enter) MEMBAR_RETURN membar #StoreLoad|#StoreStore SET_SIZE(membar_enter) ENTRY(membar_exit) MEMBAR_RETURN membar #LoadStore|#StoreStore SET_SIZE(membar_exit) ENTRY(membar_producer) MEMBAR_RETURN membar #StoreStore SET_SIZE(membar_producer) ENTRY(membar_consumer) MEMBAR_RETURN membar #LoadLoad SET_SIZE(membar_consumer) #endif /* lint */ /************************************************************************ * MINIMUM LOCKS */ #if defined(lint) /* * lock_try(lp), ulock_try(lp) * - returns non-zero on success. * - doesn't block interrupts so don't use this to spin on a lock. * - uses "0xFF is busy, anything else is free" model. * * ulock_try() is for a lock in the user address space. * For all V7/V8 sparc systems they are same since the kernel and * user are mapped in a user' context. * For V9 platforms the lock_try and ulock_try are different impl. */ int lock_try(lock_t *lp) { return (0xFF ^ ldstub(lp)); } int lock_spin_try(lock_t *lp) { return (0xFF ^ ldstub(lp)); } void lock_set(lock_t *lp) { extern void lock_set_spin(lock_t *); if (!lock_try(lp)) lock_set_spin(lp); membar_enter(); } void lock_clear(lock_t *lp) { membar_exit(); *lp = 0; } int ulock_try(lock_t *lp) { return (0xFF ^ ldstub(lp)); } void ulock_clear(lock_t *lp) { membar_exit(); *lp = 0; } #else /* lint */ .align 32 ENTRY(lock_try) ldstub [%o0], %o1 ! try to set lock, get value in %o1 brnz,pn %o1, 1f membar #LoadLoad .lock_try_lockstat_patch_point: retl or %o0, 1, %o0 ! ensure lo32 != 0 1: retl clr %o0 SET_SIZE(lock_try) .align 32 ENTRY(lock_spin_try) ldstub [%o0], %o1 ! try to set lock, get value in %o1 brnz,pn %o1, 1f membar #LoadLoad retl or %o0, 1, %o0 ! ensure lo32 != 0 1: retl clr %o0 SET_SIZE(lock_spin_try) .align 32 ENTRY(lock_set) ldstub [%o0], %o1 brnz,pn %o1, 1f ! go to C for the hard case membar #LoadLoad .lock_set_lockstat_patch_point: retl nop 1: sethi %hi(lock_set_spin), %o2 ! load up for jump to C jmp %o2 + %lo(lock_set_spin) nop ! delay: do nothing SET_SIZE(lock_set) ENTRY(lock_clear) membar #LoadStore|#StoreStore .lock_clear_lockstat_patch_point: retl clrb [%o0] SET_SIZE(lock_clear) .align 32 ENTRY(ulock_try) ldstuba [%o0]ASI_USER, %o1 ! try to set lock, get value in %o1 xor %o1, 0xff, %o0 ! delay - return non-zero if success retl membar #LoadLoad SET_SIZE(ulock_try) ENTRY(ulock_clear) membar #LoadStore|#StoreStore retl stba %g0, [%o0]ASI_USER ! clear lock SET_SIZE(ulock_clear) #endif /* lint */ /* * lock_set_spl(lp, new_pil, *old_pil_addr) * Sets pil to new_pil, grabs lp, stores old pil in *old_pil_addr. */ #if defined(lint) /* ARGSUSED */ void lock_set_spl(lock_t *lp, int new_pil, u_short *old_pil_addr) { extern int splr(int); extern void lock_set_spl_spin(lock_t *, int, u_short *, int); int old_pil; old_pil = splr(new_pil); if (!lock_try(lp)) { lock_set_spl_spin(lp, new_pil, old_pil_addr, old_pil); } else { *old_pil_addr = (u_short)old_pil; membar_enter(); } } #else /* lint */ ENTRY(lock_set_spl) rdpr %pil, %o3 ! %o3 = current pil cmp %o3, %o1 ! is current pil high enough? bl,a,pt %icc, 1f ! if not, write %pil in delay wrpr %g0, %o1, %pil 1: ldstub [%o0], %o4 ! try the lock brnz,pn %o4, 2f ! go to C for the miss case membar #LoadLoad .lock_set_spl_lockstat_patch_point: retl sth %o3, [%o2] ! delay - save original pil 2: sethi %hi(lock_set_spl_spin), %o5 ! load up jmp to C jmp %o5 + %lo(lock_set_spl_spin) ! jmp to lock_set_spl_spin nop ! delay: do nothing SET_SIZE(lock_set_spl) #endif /* lint */ /* * lock_clear_splx(lp, s) */ #if defined(lint) void lock_clear_splx(lock_t *lp, int s) { extern void splx(int); lock_clear(lp); splx(s); } #else /* lint */ ENTRY(lock_clear_splx) ldn [THREAD_REG + T_CPU], %o2 ! get CPU pointer membar #LoadStore|#StoreStore ld [%o2 + CPU_BASE_SPL], %o2 clrb [%o0] ! clear lock cmp %o2, %o1 ! compare new to base movl %xcc, %o1, %o2 ! use new pri if base is less .lock_clear_splx_lockstat_patch_point: retl wrpr %g0, %o2, %pil SET_SIZE(lock_clear_splx) #endif /* lint */ /* * mutex_enter() and mutex_exit(). * * These routines handle the simple cases of mutex_enter() (adaptive * lock, not held) and mutex_exit() (adaptive lock, held, no waiters). * If anything complicated is going on we punt to mutex_vector_enter(). * * mutex_tryenter() is similar to mutex_enter() but returns zero if * the lock cannot be acquired, nonzero on success. * * If mutex_exit() gets preempted in the window between checking waiters * and clearing the lock, we can miss wakeups. Disabling preemption * in the mutex code is prohibitively expensive, so instead we detect * mutex preemption by examining the trapped PC in the interrupt path. * If we interrupt a thread in mutex_exit() that has not yet cleared * the lock, pil_interrupt() resets its PC back to the beginning of * mutex_exit() so it will check again for waiters when it resumes. * * The lockstat code below is activated when the lockstat driver * calls lockstat_hot_patch() to hot-patch the kernel mutex code. * Note that we don't need to test lockstat_event_mask here -- we won't * patch this code in unless we're gathering ADAPTIVE_HOLD lockstats. */ #if defined (lint) /* ARGSUSED */ void mutex_enter(kmutex_t *lp) {} /* ARGSUSED */ int mutex_tryenter(kmutex_t *lp) { return (0); } /* ARGSUSED */ void mutex_exit(kmutex_t *lp) {} /* ARGSUSED */ void * mutex_owner_running(mutex_impl_t *lp) { return (NULL); } #else .align 32 ENTRY(mutex_enter) mov THREAD_REG, %o1 casx [%o0], %g0, %o1 ! try to acquire as adaptive brnz,pn %o1, 1f ! locked or wrong type membar #LoadLoad .mutex_enter_lockstat_patch_point: retl nop 1: sethi %hi(mutex_vector_enter), %o2 ! load up for jump to C jmp %o2 + %lo(mutex_vector_enter) nop SET_SIZE(mutex_enter) ENTRY(mutex_tryenter) mov THREAD_REG, %o1 casx [%o0], %g0, %o1 ! try to acquire as adaptive brnz,pn %o1, 1f ! locked or wrong type continue membar #LoadLoad .mutex_tryenter_lockstat_patch_point: retl or %o0, 1, %o0 ! ensure lo32 != 0 1: sethi %hi(mutex_vector_tryenter), %o2 ! hi bits jmp %o2 + %lo(mutex_vector_tryenter) ! go to C nop SET_SIZE(mutex_tryenter) ENTRY(mutex_adaptive_tryenter) mov THREAD_REG, %o1 casx [%o0], %g0, %o1 ! try to acquire as adaptive brnz,pn %o1, 0f ! locked or wrong type membar #LoadLoad retl or %o0, 1, %o0 ! ensure lo32 != 0 0: retl mov %g0, %o0 SET_SIZE(mutex_adaptive_tryenter) ! these need to be together and cache aligned for performance. .align 64 .global mutex_exit_critical_size .global mutex_exit_critical_start .global mutex_owner_running_critical_size .global mutex_owner_running_critical_start mutex_exit_critical_size = .mutex_exit_critical_end - mutex_exit_critical_start .align 32 ENTRY(mutex_exit) mutex_exit_critical_start: ! If we are interrupted, restart here ldn [%o0], %o1 ! get the owner field membar #LoadStore|#StoreStore cmp THREAD_REG, %o1 ! do we own lock with no waiters? be,a,pt %ncc, 1f ! if so, drive on ... stn %g0, [%o0] ! delay: clear lock if we owned it .mutex_exit_critical_end: ! for pil_interrupt() hook ba,a,pt %xcc, mutex_vector_exit ! go to C for the hard cases 1: .mutex_exit_lockstat_patch_point: retl nop SET_SIZE(mutex_exit) mutex_owner_running_critical_size = .mutex_owner_running_critical_end - mutex_owner_running_critical_start .align 32 ENTRY(mutex_owner_running) mutex_owner_running_critical_start: ! If interrupted restart here ldn [%o0], %o1 ! get the owner field and %o1, MUTEX_THREAD, %o1 ! remove the waiters bit if any brz,pn %o1, 1f ! if so, drive on ... nop ldn [%o1+T_CPU], %o2 ! get owner->t_cpu ldn [%o2+CPU_THREAD], %o3 ! get owner->t_cpu->cpu_thread .mutex_owner_running_critical_end: ! for pil_interrupt() hook cmp %o1, %o3 ! owner == running thread? be,a,pt %xcc, 2f ! yes, go return cpu nop 1: retl mov %g0, %o0 ! return 0 (owner not running) 2: retl mov %o2, %o0 ! owner running, return cpu SET_SIZE(mutex_owner_running) #endif /* lint */ /* * rw_enter() and rw_exit(). * * These routines handle the simple cases of rw_enter (write-locking an unheld * lock or read-locking a lock that's neither write-locked nor write-wanted) * and rw_exit (no waiters or not the last reader). If anything complicated * is going on we punt to rw_enter_sleep() and rw_exit_wakeup(), respectively. */ #if defined(lint) /* ARGSUSED */ void rw_enter(krwlock_t *lp, krw_t rw) {} /* ARGSUSED */ void rw_exit(krwlock_t *lp) {} #else .align 16 ENTRY(rw_enter) cmp %o1, RW_WRITER ! entering as writer? be,a,pn %icc, 2f ! if so, go do it ... or THREAD_REG, RW_WRITE_LOCKED, %o5 ! delay: %o5 = owner ldn [%o0], %o4 ! %o4 = old lock value 1: andcc %o4, RW_WRITE_CLAIMED, %g0 ! write-locked or write-wanted? bz,pt %xcc, 3f ! if so, prepare to block add %o4, RW_READ_LOCK, %o5 ! delay: increment hold count sethi %hi(rw_enter_sleep), %o2 ! load up jump jmp %o2 + %lo(rw_enter_sleep) ! jmp to rw_enter_sleep nop ! delay: do nothing 3: casx [%o0], %o4, %o5 ! try to grab read lock cmp %o4, %o5 ! did we get it? #ifdef sun4v be,a,pt %xcc, 0f membar #LoadLoad sethi %hi(rw_enter_sleep), %o2 ! load up jump jmp %o2 + %lo(rw_enter_sleep) ! jmp to rw_enter_sleep nop ! delay: do nothing 0: #else /* sun4v */ bne,pn %xcc, 1b ! if not, try again mov %o5, %o4 ! delay: %o4 = old lock value membar #LoadLoad #endif /* sun4v */ .rw_read_enter_lockstat_patch_point: retl nop 2: casx [%o0], %g0, %o5 ! try to grab write lock brz,pt %o5, 4f ! branch around if we got it membar #LoadLoad ! done regardless of where we go sethi %hi(rw_enter_sleep), %o2 jmp %o2 + %lo(rw_enter_sleep) ! jump to rw_enter_sleep if not nop ! delay: do nothing 4: .rw_write_enter_lockstat_patch_point: retl nop SET_SIZE(rw_enter) .align 16 ENTRY(rw_exit) ldn [%o0], %o4 ! %o4 = old lock value membar #LoadStore|#StoreStore ! membar_exit() subcc %o4, RW_READ_LOCK, %o5 ! %o5 = new lock value if reader bnz,pn %xcc, 2f ! single reader, no waiters? clr %o1 1: srl %o4, RW_HOLD_COUNT_SHIFT, %o3 ! %o3 = hold count (lockstat) casx [%o0], %o4, %o5 ! try to drop lock cmp %o4, %o5 ! did we succeed? bne,pn %xcc, rw_exit_wakeup ! if not, go to C nop ! delay: do nothing .rw_read_exit_lockstat_patch_point: retl nop ! delay: do nothing 2: andcc %o4, RW_WRITE_LOCKED, %g0 ! are we a writer? bnz,a,pt %xcc, 3f or THREAD_REG, RW_WRITE_LOCKED, %o4 ! delay: %o4 = owner cmp %o5, RW_READ_LOCK ! would lock still be held? bge,pt %xcc, 1b ! if so, go ahead and drop it nop ba,pt %xcc, rw_exit_wakeup ! otherwise, wake waiters nop 3: casx [%o0], %o4, %o1 ! try to drop write lock cmp %o4, %o1 ! did we succeed? bne,pn %xcc, rw_exit_wakeup ! if not, go to C nop .rw_write_exit_lockstat_patch_point: retl nop SET_SIZE(rw_exit) #endif #if defined(lint) void lockstat_hot_patch(void) {} #else #define RETL 0x81c3e008 #define NOP 0x01000000 #define BA 0x10800000 #define DISP22 ((1 << 22) - 1) #define ANNUL 0x20000000 #define HOT_PATCH_COMMON(addr, event, normal_instr, annul, rs) \ ba 1f; \ rd %pc, %o0; \ save %sp, -SA(MINFRAME), %sp; \ set lockstat_probemap, %l1; \ ld [%l1 + (event * DTRACE_IDSIZE)], %o0; \ brz,pn %o0, 0f; \ ldub [THREAD_REG + T_LOCKSTAT], %l0; \ add %l0, 1, %l2; \ stub %l2, [THREAD_REG + T_LOCKSTAT]; \ set lockstat_probe, %g1; \ ld [%l1 + (event * DTRACE_IDSIZE)], %o0; \ brz,a,pn %o0, 0f; \ stub %l0, [THREAD_REG + T_LOCKSTAT]; \ ldn [%g1], %g2; \ mov rs, %o2; \ jmpl %g2, %o7; \ mov %i0, %o1; \ stub %l0, [THREAD_REG + T_LOCKSTAT]; \ 0: ret; \ restore %g0, 1, %o0; /* for mutex_tryenter / lock_try */ \ 1: set addr, %o1; \ sub %o0, %o1, %o0; \ srl %o0, 2, %o0; \ inc %o0; \ set DISP22, %o1; \ and %o1, %o0, %o0; \ set BA, %o1; \ or %o1, %o0, %o0; \ sethi %hi(annul), %o2; \ add %o0, %o2, %o2; \ set addr, %o0; \ set normal_instr, %o1; \ ld [%i0 + (event * DTRACE_IDSIZE)], %o3; \ tst %o3; \ movnz %icc, %o2, %o1; \ call hot_patch_kernel_text; \ mov 4, %o2; \ membar #Sync #define HOT_PATCH(addr, event, normal_instr) \ HOT_PATCH_COMMON(addr, event, normal_instr, 0, %i1) #define HOT_PATCH_ARG(addr, event, normal_instr, arg) \ HOT_PATCH_COMMON(addr, event, normal_instr, 0, arg) #define HOT_PATCH_ANNULLED(addr, event, normal_instr) \ HOT_PATCH_COMMON(addr, event, normal_instr, ANNUL, %i1) ENTRY(lockstat_hot_patch) save %sp, -SA(MINFRAME), %sp set lockstat_probemap, %i0 HOT_PATCH(.mutex_enter_lockstat_patch_point, LS_MUTEX_ENTER_ACQUIRE, RETL) HOT_PATCH_ANNULLED(.mutex_tryenter_lockstat_patch_point, LS_MUTEX_TRYENTER_ACQUIRE, RETL) HOT_PATCH(.mutex_exit_lockstat_patch_point, LS_MUTEX_EXIT_RELEASE, RETL) HOT_PATCH(.rw_write_enter_lockstat_patch_point, LS_RW_ENTER_ACQUIRE, RETL) HOT_PATCH(.rw_read_enter_lockstat_patch_point, LS_RW_ENTER_ACQUIRE, RETL) HOT_PATCH_ARG(.rw_write_exit_lockstat_patch_point, LS_RW_EXIT_RELEASE, RETL, RW_WRITER) HOT_PATCH_ARG(.rw_read_exit_lockstat_patch_point, LS_RW_EXIT_RELEASE, RETL, RW_READER) HOT_PATCH(.lock_set_lockstat_patch_point, LS_LOCK_SET_ACQUIRE, RETL) HOT_PATCH_ANNULLED(.lock_try_lockstat_patch_point, LS_LOCK_TRY_ACQUIRE, RETL) HOT_PATCH(.lock_clear_lockstat_patch_point, LS_LOCK_CLEAR_RELEASE, RETL) HOT_PATCH(.lock_set_spl_lockstat_patch_point, LS_LOCK_SET_SPL_ACQUIRE, RETL) HOT_PATCH(.lock_clear_splx_lockstat_patch_point, LS_LOCK_CLEAR_SPLX_RELEASE, RETL) ret restore SET_SIZE(lockstat_hot_patch) #endif /* lint */ /* * asm_mutex_spin_enter(mutex_t *) * * For use by assembly interrupt handler only. * Does not change spl, since the interrupt handler is assumed to be * running at high level already. * Traps may be off, so cannot panic. * Does not keep statistics on the lock. * * Entry: %l6 - points to mutex * %l7 - address of call (returns to %l7+8) * Uses: %l6, %l5 */ #ifndef lint .align 16 ENTRY_NP(asm_mutex_spin_enter) ldstub [%l6 + M_SPINLOCK], %l5 ! try to set lock, get value in %l5 1: tst %l5 bnz 3f ! lock already held - go spin nop 2: jmp %l7 + 8 ! return membar #LoadLoad ! ! Spin on lock without using an atomic operation to prevent the caches ! from unnecessarily moving ownership of the line around. ! 3: ldub [%l6 + M_SPINLOCK], %l5 4: tst %l5 bz,a 1b ! lock appears to be free, try again ldstub [%l6 + M_SPINLOCK], %l5 ! delay slot - try to set lock sethi %hi(panicstr) , %l5 ldn [%l5 + %lo(panicstr)], %l5 tst %l5 bnz 2b ! after panic, feign success nop b 4b ldub [%l6 + M_SPINLOCK], %l5 ! delay - reload lock SET_SIZE(asm_mutex_spin_enter) #endif /* lint */ /* * asm_mutex_spin_exit(mutex_t *) * * For use by assembly interrupt handler only. * Does not change spl, since the interrupt handler is assumed to be * running at high level already. * * Entry: %l6 - points to mutex * %l7 - address of call (returns to %l7+8) * Uses: none */ #ifndef lint ENTRY_NP(asm_mutex_spin_exit) membar #LoadStore|#StoreStore jmp %l7 + 8 ! return clrb [%l6 + M_SPINLOCK] ! delay - clear lock SET_SIZE(asm_mutex_spin_exit) #endif /* lint */ /* * thread_onproc() * Set thread in onproc state for the specified CPU. * Also set the thread lock pointer to the CPU's onproc lock. * Since the new lock isn't held, the store ordering is important. * If not done in assembler, the compiler could reorder the stores. */ #if defined(lint) void thread_onproc(kthread_id_t t, cpu_t *cp) { t->t_state = TS_ONPROC; t->t_lockp = &cp->cpu_thread_lock; } #else /* lint */ ENTRY(thread_onproc) set TS_ONPROC, %o2 ! TS_ONPROC state st %o2, [%o0 + T_STATE] ! store state add %o1, CPU_THREAD_LOCK, %o3 ! pointer to disp_lock while running retl ! return stn %o3, [%o0 + T_LOCKP] ! delay - store new lock pointer SET_SIZE(thread_onproc) #endif /* lint */ /* delay function used in some mutex code - just do 3 nop cas ops */ #if defined(lint) /* ARGSUSED */ void cas_delay(void *addr) {} #else /* lint */ ENTRY(cas_delay) casx [%o0], %g0, %g0 casx [%o0], %g0, %g0 retl casx [%o0], %g0, %g0 SET_SIZE(cas_delay) #endif /* lint */ #if defined(lint) /* * alternative delay function for some niagara processors. The rd * instruction uses less resources than casx on those cpus. */ /* ARGSUSED */ void rdccr_delay(void) {} #else /* lint */ ENTRY(rdccr_delay) rd %ccr, %g0 rd %ccr, %g0 retl rd %ccr, %g0 SET_SIZE(rdccr_delay) #endif /* lint */ /* * mutex_delay_default(void) * Spins for approx a few hundred processor cycles and returns to caller. */ #if defined(lint) void mutex_delay_default(void) {} #else /* lint */ ENTRY(mutex_delay_default) mov 72,%o0 1: brgz %o0, 1b dec %o0 retl nop SET_SIZE(mutex_delay_default) #endif /* lint */