lib/libthr/thread/thr_pspinlock.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2003 David Xu <davidxu@freebsd.org>
   5  * Copyright (c) 2016 The FreeBSD Foundation
   6  * All rights reserved.
   7  *
   8  * Portions of this software were developed by Konstantin Belousov
   9  * under sponsorship from the FreeBSD Foundation.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35
  36 #include "namespace.h"
  37 #include <errno.h>
  38 #include <stdlib.h>
  39 #include <pthread.h>
  40 #include "un-namespace.h"
  41
  42 #include "thr_private.h"
  43
  44 _Static_assert(sizeof(struct pthread_spinlock) <= PAGE_SIZE,
  45     "pthread_spinlock is too large for off-page");
  46
  47 #define SPIN_COUNT 100000
  48
  49 __weak_reference(_pthread_spin_init, pthread_spin_init);
  50 __weak_reference(_pthread_spin_destroy, pthread_spin_destroy);
  51 __weak_reference(_pthread_spin_trylock, pthread_spin_trylock);
  52 __weak_reference(_pthread_spin_lock, pthread_spin_lock);
  53 __weak_reference(_pthread_spin_unlock, pthread_spin_unlock);
  54
  55 int
  56 _pthread_spin_init(pthread_spinlock_t *lock, int pshared)
  57 {
  58         struct pthread_spinlock *lck;
  59
  60         if (lock == NULL)
  61                 return (EINVAL);
  62         if (pshared == PTHREAD_PROCESS_PRIVATE) {
  63                 lck = malloc(sizeof(struct pthread_spinlock));
  64                 if (lck == NULL)
  65                         return (ENOMEM);
  66                 *lock = lck;
  67         } else if (pshared == PTHREAD_PROCESS_SHARED) {
  68                 lck = __thr_pshared_offpage(lock, 1);
  69                 if (lck == NULL)
  70                         return (EFAULT);
  71                 *lock = THR_PSHARED_PTR;
  72         } else {
  73                 return (EINVAL);
  74         }
  75         _thr_umutex_init(&lck->s_lock);
  76         return (0);
  77 }
  78
  79 int
  80 _pthread_spin_destroy(pthread_spinlock_t *lock)
  81 {
  82         void *l;
  83         int ret;
  84
  85         if (lock == NULL || *lock == NULL) {
  86                 ret = EINVAL;
  87         } else if (*lock == THR_PSHARED_PTR) {
  88                 l = __thr_pshared_offpage(lock, 0);
  89                 if (l != NULL)
  90                         __thr_pshared_destroy(l);
  91                 ret = 0;
  92         } else {
  93                 free(*lock);
  94                 *lock = NULL;
  95                 ret = 0;
  96         }
  97         return (ret);
  98 }
  99
 100 int
 101 _pthread_spin_trylock(pthread_spinlock_t *lock)
 102 {
 103         struct pthread_spinlock *lck;
 104
 105         if (lock == NULL || *lock == NULL)
 106                 return (EINVAL);
 107         lck = *lock == THR_PSHARED_PTR ? __thr_pshared_offpage(lock, 0) : *lock;
 108         if (lck == NULL)
 109                 return (EINVAL);
 110         return (THR_UMUTEX_TRYLOCK(_get_curthread(), &lck->s_lock));
 111 }
 112
 113 int
 114 _pthread_spin_lock(pthread_spinlock_t *lock)
 115 {
 116         struct pthread *curthread;
 117         struct pthread_spinlock *lck;
 118         int count;
 119
 120         if (lock == NULL)
 121                 return (EINVAL);
 122         lck = *lock == THR_PSHARED_PTR ? __thr_pshared_offpage(lock, 0) : *lock;
 123         if (lck == NULL)
 124                 return (EINVAL);
 125
 126         curthread = _get_curthread();
 127         count = SPIN_COUNT;
 128         while (THR_UMUTEX_TRYLOCK(curthread, &lck->s_lock) != 0) {
 129                 while (lck->s_lock.m_owner) {
 130                         if (!_thr_is_smp) {
 131                                 _pthread_yield();
 132                         } else {
 133                                 CPU_SPINWAIT;
 134                                 if (--count <= 0) {
 135                                         count = SPIN_COUNT;
 136                                         _pthread_yield();
 137                                 }
 138                         }
 139                 }
 140         }
 141         return (0);
 142 }
 143
 144 int
 145 _pthread_spin_unlock(pthread_spinlock_t *lock)
 146 {
 147         struct pthread_spinlock *lck;
 148
 149         if (lock == NULL)
 150                 return (EINVAL);
 151         lck = *lock == THR_PSHARED_PTR ? __thr_pshared_offpage(lock, 0) : *lock;
 152         if (lck == NULL)
 153                 return (EINVAL);
 154         return (THR_UMUTEX_UNLOCK(_get_curthread(), &lck->s_lock));
 155 }