lib/libthr/thread/thr_mutexattr.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1996 Jeffrey Hsu <hsu@freebsd.org>.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the author nor the names of any co-contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * Copyright (c) 1997 John Birrell <jb@cimlogic.com.au>.
  34  * All rights reserved.
  35  *
  36  * Redistribution and use in source and binary forms, with or without
  37  * modification, are permitted provided that the following conditions
  38  * are met:
  39  * 1. Redistributions of source code must retain the above copyright
  40  *    notice, this list of conditions and the following disclaimer.
  41  * 2. Redistributions in binary form must reproduce the above copyright
  42  *    notice, this list of conditions and the following disclaimer in the
  43  *    documentation and/or other materials provided with the distribution.
  44  * 3. Neither the name of the author nor the names of any co-contributors
  45  *    may be used to endorse or promote products derived from this software
  46  *    without specific prior written permission.
  47  *
  48  * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
  49  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  50  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  51  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  52  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  53  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  54  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  55  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  56  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  57  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  58  * SUCH DAMAGE.
  59  *
  60  */
  61
  62 #include <sys/cdefs.h>
  63 __FBSDID("$FreeBSD$");
  64
  65 #include "namespace.h"
  66 #include <string.h>
  67 #include <stdlib.h>
  68 #include <errno.h>
  69 #include <pthread.h>
  70 #include <pthread_np.h>
  71 #include "un-namespace.h"
  72
  73 #include "thr_private.h"
  74
  75 __weak_reference(_pthread_mutexattr_init, pthread_mutexattr_init);
  76 __weak_reference(_pthread_mutexattr_setkind_np, pthread_mutexattr_setkind_np);
  77 __weak_reference(_pthread_mutexattr_getkind_np, pthread_mutexattr_getkind_np);
  78 __weak_reference(_pthread_mutexattr_gettype, pthread_mutexattr_gettype);
  79 __weak_reference(_pthread_mutexattr_settype, pthread_mutexattr_settype);
  80 __weak_reference(_pthread_mutexattr_destroy, pthread_mutexattr_destroy);
  81 __weak_reference(_pthread_mutexattr_getpshared, pthread_mutexattr_getpshared);
  82 __weak_reference(_pthread_mutexattr_setpshared, pthread_mutexattr_setpshared);
  83 __weak_reference(_pthread_mutexattr_getprotocol, pthread_mutexattr_getprotocol);
  84 __weak_reference(_pthread_mutexattr_setprotocol, pthread_mutexattr_setprotocol);
  85 __weak_reference(_pthread_mutexattr_getprioceiling,
  86     pthread_mutexattr_getprioceiling);
  87 __weak_reference(_pthread_mutexattr_setprioceiling,
  88     pthread_mutexattr_setprioceiling);
  89 __weak_reference(_pthread_mutexattr_getrobust, pthread_mutexattr_getrobust);
  90 __weak_reference(_pthread_mutexattr_setrobust, pthread_mutexattr_setrobust);
  91
  92 int
  93 _pthread_mutexattr_init(pthread_mutexattr_t *attr)
  94 {
  95         int ret;
  96         pthread_mutexattr_t pattr;
  97
  98         if ((pattr = (pthread_mutexattr_t)
  99             malloc(sizeof(struct pthread_mutex_attr))) == NULL) {
 100                 ret = ENOMEM;
 101         } else {
 102                 memcpy(pattr, &_pthread_mutexattr_default,
 103                     sizeof(struct pthread_mutex_attr));
 104                 *attr = pattr;
 105                 ret = 0;
 106         }
 107         return (ret);
 108 }
 109
 110 int
 111 _pthread_mutexattr_setkind_np(pthread_mutexattr_t *attr, int kind)
 112 {
 113         int     ret;
 114         if (attr == NULL || *attr == NULL) {
 115                 errno = EINVAL;
 116                 ret = -1;
 117         } else {
 118                 (*attr)->m_type = kind;
 119                 ret = 0;
 120         }
 121         return(ret);
 122 }
 123
 124 int
 125 _pthread_mutexattr_getkind_np(pthread_mutexattr_t attr)
 126 {
 127         int     ret;
 128
 129         if (attr == NULL) {
 130                 errno = EINVAL;
 131                 ret = -1;
 132         } else {
 133                 ret = attr->m_type;
 134         }
 135         return (ret);
 136 }
 137
 138 int
 139 _pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type)
 140 {
 141         int     ret;
 142
 143         if (attr == NULL || *attr == NULL || type >= PTHREAD_MUTEX_TYPE_MAX) {
 144                 ret = EINVAL;
 145         } else {
 146                 (*attr)->m_type = type;
 147                 ret = 0;
 148         }
 149         return (ret);
 150 }
 151
 152 int
 153 _pthread_mutexattr_gettype(pthread_mutexattr_t *attr, int *type)
 154 {
 155         int     ret;
 156
 157         if (attr == NULL || *attr == NULL || (*attr)->m_type >=
 158             PTHREAD_MUTEX_TYPE_MAX) {
 159                 ret = EINVAL;
 160         } else {
 161                 *type = (*attr)->m_type;
 162                 ret = 0;
 163         }
 164         return (ret);
 165 }
 166
 167 int
 168 _pthread_mutexattr_destroy(pthread_mutexattr_t *attr)
 169 {
 170         int     ret;
 171         if (attr == NULL || *attr == NULL) {
 172                 ret = EINVAL;
 173         } else {
 174                 free(*attr);
 175                 *attr = NULL;
 176                 ret = 0;
 177         }
 178         return (ret);
 179 }
 180
 181 int
 182 _pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr,
 183         int *pshared)
 184 {
 185
 186         if (attr == NULL || *attr == NULL)
 187                 return (EINVAL);
 188         *pshared = (*attr)->m_pshared;
 189         return (0);
 190 }
 191
 192 int
 193 _pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared)
 194 {
 195
 196         if (attr == NULL || *attr == NULL ||
 197             (pshared != PTHREAD_PROCESS_PRIVATE &&
 198             pshared != PTHREAD_PROCESS_SHARED))
 199                 return (EINVAL);
 200         (*attr)->m_pshared = pshared;
 201         return (0);
 202 }
 203
 204 int
 205 _pthread_mutexattr_getprotocol(pthread_mutexattr_t *mattr, int *protocol)
 206 {
 207         int ret = 0;
 208
 209         if (mattr == NULL || *mattr == NULL)
 210                 ret = EINVAL;
 211         else
 212                 *protocol = (*mattr)->m_protocol;
 213
 214         return (ret);
 215 }
 216
 217 int
 218 _pthread_mutexattr_setprotocol(pthread_mutexattr_t *mattr, int protocol)
 219 {
 220         int ret = 0;
 221
 222         if (mattr == NULL || *mattr == NULL ||
 223             protocol < PTHREAD_PRIO_NONE || protocol > PTHREAD_PRIO_PROTECT)
 224                 ret = EINVAL;
 225         else {
 226                 (*mattr)->m_protocol = protocol;
 227                 (*mattr)->m_ceiling = THR_MAX_RR_PRIORITY;
 228         }
 229         return (ret);
 230 }
 231
 232 int
 233 _pthread_mutexattr_getprioceiling(pthread_mutexattr_t *mattr, int *prioceiling)
 234 {
 235         int ret = 0;
 236
 237         if (mattr == NULL || *mattr == NULL)
 238                 ret = EINVAL;
 239         else if ((*mattr)->m_protocol != PTHREAD_PRIO_PROTECT)
 240                 ret = EINVAL;
 241         else
 242                 *prioceiling = (*mattr)->m_ceiling;
 243
 244         return (ret);
 245 }
 246
 247 int
 248 _pthread_mutexattr_setprioceiling(pthread_mutexattr_t *mattr, int prioceiling)
 249 {
 250         int ret = 0;
 251
 252         if (mattr == NULL || *mattr == NULL)
 253                 ret = EINVAL;
 254         else if ((*mattr)->m_protocol != PTHREAD_PRIO_PROTECT)
 255                 ret = EINVAL;
 256         else
 257                 (*mattr)->m_ceiling = prioceiling;
 258
 259         return (ret);
 260 }
 261
 262 int
 263 _pthread_mutexattr_getrobust(pthread_mutexattr_t *mattr, int *robust)
 264 {
 265         int ret;
 266
 267         if (mattr == NULL || *mattr == NULL) {
 268                 ret = EINVAL;
 269         } else {
 270                 ret = 0;
 271                 *robust = (*mattr)->m_robust;
 272         }
 273         return (ret);
 274 }
 275
 276 int
 277 _pthread_mutexattr_setrobust(pthread_mutexattr_t *mattr, int robust)
 278 {
 279         int ret;
 280
 281         if (mattr == NULL || *mattr == NULL) {
 282                 ret = EINVAL;
 283         } else if (robust != PTHREAD_MUTEX_STALLED &&
 284             robust != PTHREAD_MUTEX_ROBUST) {
 285                 ret = EINVAL;
 286         } else {
 287                 ret = 0;
 288                 (*mattr)->m_robust = robust;
 289         }
 290         return (ret);
 291 }
 292