thr_pspinlock.c revision 297138
1144518Sdavidxu/*- 2144518Sdavidxu * Copyright (c) 2003 David Xu <davidxu@freebsd.org> 3297138Skib * Copyright (c) 2016 The FreeBSD Foundation 4144518Sdavidxu * All rights reserved. 5144518Sdavidxu * 6297138Skib * Portions of this software were developed by Konstantin Belousov 7297138Skib * under sponsorship from the FreeBSD Foundation. 8297138Skib * 9144518Sdavidxu * Redistribution and use in source and binary forms, with or without 10144518Sdavidxu * modification, are permitted provided that the following conditions 11144518Sdavidxu * are met: 12144518Sdavidxu * 1. Redistributions of source code must retain the above copyright 13144518Sdavidxu * notice, this list of conditions and the following disclaimer. 14144518Sdavidxu * 2. Redistributions in binary form must reproduce the above copyright 15144518Sdavidxu * notice, this list of conditions and the following disclaimer in the 16144518Sdavidxu * documentation and/or other materials provided with the distribution. 17144518Sdavidxu * 18144518Sdavidxu * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19144518Sdavidxu * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20144518Sdavidxu * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21144518Sdavidxu * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22144518Sdavidxu * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23144518Sdavidxu * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24144518Sdavidxu * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25144518Sdavidxu * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26144518Sdavidxu * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27144518Sdavidxu * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28144518Sdavidxu * SUCH DAMAGE. 29144518Sdavidxu * 30144518Sdavidxu * $FreeBSD: head/lib/libthr/thread/thr_pspinlock.c 297138 2016-03-21 06:40:54Z kib $ 31144518Sdavidxu */ 32144518Sdavidxu 33157457Sdavidxu#include "namespace.h" 34144518Sdavidxu#include <errno.h> 35144518Sdavidxu#include <stdlib.h> 36144518Sdavidxu#include <pthread.h> 37157457Sdavidxu#include "un-namespace.h" 38157457Sdavidxu 39144518Sdavidxu#include "thr_private.h" 40144518Sdavidxu 41144518Sdavidxu#define SPIN_COUNT 100000 42144518Sdavidxu 43144518Sdavidxu__weak_reference(_pthread_spin_init, pthread_spin_init); 44144518Sdavidxu__weak_reference(_pthread_spin_destroy, pthread_spin_destroy); 45144518Sdavidxu__weak_reference(_pthread_spin_trylock, pthread_spin_trylock); 46144518Sdavidxu__weak_reference(_pthread_spin_lock, pthread_spin_lock); 47144518Sdavidxu__weak_reference(_pthread_spin_unlock, pthread_spin_unlock); 48144518Sdavidxu 49144518Sdavidxuint 50144518Sdavidxu_pthread_spin_init(pthread_spinlock_t *lock, int pshared) 51144518Sdavidxu{ 52144518Sdavidxu struct pthread_spinlock *lck; 53144518Sdavidxu 54297138Skib if (lock == NULL) 55297138Skib return (EINVAL); 56297138Skib if (pshared == PTHREAD_PROCESS_PRIVATE) { 57297138Skib lck = malloc(sizeof(struct pthread_spinlock)); 58297138Skib if (lck == NULL) 59297138Skib return (ENOMEM); 60144518Sdavidxu *lock = lck; 61297138Skib } else if (pshared == PTHREAD_PROCESS_SHARED) { 62297138Skib lck = __thr_pshared_offpage(lock, 1); 63297138Skib if (lck == NULL) 64297138Skib return (EFAULT); 65297138Skib *lock = THR_PSHARED_PTR; 66297138Skib } else { 67297138Skib return (EINVAL); 68144518Sdavidxu } 69297138Skib _thr_umutex_init(&lck->s_lock); 70297138Skib return (0); 71144518Sdavidxu} 72144518Sdavidxu 73144518Sdavidxuint 74144518Sdavidxu_pthread_spin_destroy(pthread_spinlock_t *lock) 75144518Sdavidxu{ 76297138Skib void *l; 77144518Sdavidxu int ret; 78144518Sdavidxu 79297138Skib if (lock == NULL || *lock == NULL) { 80144518Sdavidxu ret = EINVAL; 81297138Skib } else if (*lock == THR_PSHARED_PTR) { 82297138Skib l = __thr_pshared_offpage(lock, 0); 83297138Skib if (l != NULL) 84297138Skib __thr_pshared_destroy(l); 85297138Skib ret = 0; 86297138Skib } else { 87144518Sdavidxu free(*lock); 88144518Sdavidxu *lock = NULL; 89144518Sdavidxu ret = 0; 90144518Sdavidxu } 91144518Sdavidxu return (ret); 92144518Sdavidxu} 93144518Sdavidxu 94144518Sdavidxuint 95144518Sdavidxu_pthread_spin_trylock(pthread_spinlock_t *lock) 96144518Sdavidxu{ 97144518Sdavidxu struct pthread_spinlock *lck; 98144518Sdavidxu 99297138Skib if (lock == NULL || *lock == NULL) 100297138Skib return (EINVAL); 101297138Skib lck = *lock == THR_PSHARED_PTR ? __thr_pshared_offpage(lock, 0) : *lock; 102297138Skib if (lck == NULL) 103297138Skib return (EINVAL); 104297138Skib return (THR_UMUTEX_TRYLOCK(_get_curthread(), &lck->s_lock)); 105144518Sdavidxu} 106144518Sdavidxu 107144518Sdavidxuint 108144518Sdavidxu_pthread_spin_lock(pthread_spinlock_t *lock) 109144518Sdavidxu{ 110297138Skib struct pthread *curthread; 111144518Sdavidxu struct pthread_spinlock *lck; 112297138Skib int count; 113144518Sdavidxu 114297138Skib if (lock == NULL) 115297138Skib return (EINVAL); 116297138Skib lck = *lock == THR_PSHARED_PTR ? __thr_pshared_offpage(lock, 0) : *lock; 117297138Skib if (lck == NULL) 118297138Skib return (EINVAL); 119297138Skib 120297138Skib curthread = _get_curthread(); 121297138Skib count = SPIN_COUNT; 122297138Skib while (THR_UMUTEX_TRYLOCK(curthread, &lck->s_lock) != 0) { 123297138Skib while (lck->s_lock.m_owner) { 124297138Skib if (!_thr_is_smp) { 125297138Skib _pthread_yield(); 126297138Skib } else { 127297138Skib CPU_SPINWAIT; 128297138Skib if (--count <= 0) { 129297138Skib count = SPIN_COUNT; 130161068Sdavidxu _pthread_yield(); 131144518Sdavidxu } 132144518Sdavidxu } 133144518Sdavidxu } 134144518Sdavidxu } 135297138Skib return (0); 136144518Sdavidxu} 137144518Sdavidxu 138144518Sdavidxuint 139144518Sdavidxu_pthread_spin_unlock(pthread_spinlock_t *lock) 140144518Sdavidxu{ 141144518Sdavidxu struct pthread_spinlock *lck; 142144518Sdavidxu 143297138Skib if (lock == NULL) 144297138Skib return (EINVAL); 145297138Skib lck = *lock == THR_PSHARED_PTR ? __thr_pshared_offpage(lock, 0) : *lock; 146297138Skib if (lck == NULL) 147297138Skib return (EINVAL); 148297138Skib return (THR_UMUTEX_UNLOCK(_get_curthread(), &lck->s_lock)); 149144518Sdavidxu} 150