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(_thr_mutexattr_init, pthread_mutexattr_init);
76__weak_reference(_thr_mutexattr_init, _pthread_mutexattr_init);
77__weak_reference(_pthread_mutexattr_setkind_np, pthread_mutexattr_setkind_np);
78__weak_reference(_pthread_mutexattr_getkind_np, pthread_mutexattr_getkind_np);
79__weak_reference(_pthread_mutexattr_gettype, pthread_mutexattr_gettype);
80__weak_reference(_thr_mutexattr_settype, pthread_mutexattr_settype);
81__weak_reference(_thr_mutexattr_settype, _pthread_mutexattr_settype);
82__weak_reference(_thr_mutexattr_destroy, pthread_mutexattr_destroy);
83__weak_reference(_thr_mutexattr_destroy, _pthread_mutexattr_destroy);
84__weak_reference(_pthread_mutexattr_getpshared, pthread_mutexattr_getpshared);
85__weak_reference(_pthread_mutexattr_setpshared, pthread_mutexattr_setpshared);
86__weak_reference(_pthread_mutexattr_getprotocol, pthread_mutexattr_getprotocol);
87__weak_reference(_pthread_mutexattr_setprotocol, pthread_mutexattr_setprotocol);
88__weak_reference(_pthread_mutexattr_getprioceiling,
89    pthread_mutexattr_getprioceiling);
90__weak_reference(_pthread_mutexattr_setprioceiling,
91    pthread_mutexattr_setprioceiling);
92__weak_reference(_thr_mutexattr_getrobust, pthread_mutexattr_getrobust);
93__weak_reference(_thr_mutexattr_getrobust, _pthread_mutexattr_getrobust);
94__weak_reference(_thr_mutexattr_setrobust, pthread_mutexattr_setrobust);
95__weak_reference(_thr_mutexattr_setrobust, _pthread_mutexattr_setrobust);
96
97int
98_thr_mutexattr_init(pthread_mutexattr_t *attr)
99{
100	int ret;
101	pthread_mutexattr_t pattr;
102
103	if ((pattr = (pthread_mutexattr_t)
104	    malloc(sizeof(struct pthread_mutex_attr))) == NULL) {
105		ret = ENOMEM;
106	} else {
107		memcpy(pattr, &_pthread_mutexattr_default,
108		    sizeof(struct pthread_mutex_attr));
109		*attr = pattr;
110		ret = 0;
111	}
112	return (ret);
113}
114
115int
116_pthread_mutexattr_setkind_np(pthread_mutexattr_t *attr, int kind)
117{
118	int	ret;
119	if (attr == NULL || *attr == NULL) {
120		errno = EINVAL;
121		ret = -1;
122	} else {
123		(*attr)->m_type = kind;
124		ret = 0;
125	}
126	return(ret);
127}
128
129int
130_pthread_mutexattr_getkind_np(pthread_mutexattr_t attr)
131{
132	int	ret;
133
134	if (attr == NULL) {
135		errno = EINVAL;
136		ret = -1;
137	} else {
138		ret = attr->m_type;
139	}
140	return (ret);
141}
142
143int
144_thr_mutexattr_settype(pthread_mutexattr_t *attr, int type)
145{
146	int	ret;
147
148	if (attr == NULL || *attr == NULL || type >= PTHREAD_MUTEX_TYPE_MAX) {
149		ret = EINVAL;
150	} else {
151		(*attr)->m_type = type;
152		ret = 0;
153	}
154	return (ret);
155}
156
157int
158_pthread_mutexattr_gettype(const pthread_mutexattr_t * __restrict attr,
159    int * __restrict type)
160{
161	int	ret;
162
163	if (attr == NULL || *attr == NULL || (*attr)->m_type >=
164	    PTHREAD_MUTEX_TYPE_MAX) {
165		ret = EINVAL;
166	} else {
167		*type = (*attr)->m_type;
168		ret = 0;
169	}
170	return (ret);
171}
172
173int
174_thr_mutexattr_destroy(pthread_mutexattr_t *attr)
175{
176	int	ret;
177	if (attr == NULL || *attr == NULL) {
178		ret = EINVAL;
179	} else {
180		free(*attr);
181		*attr = NULL;
182		ret = 0;
183	}
184	return (ret);
185}
186
187int
188_pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr,
189	int *pshared)
190{
191
192	if (attr == NULL || *attr == NULL)
193		return (EINVAL);
194	*pshared = (*attr)->m_pshared;
195	return (0);
196}
197
198int
199_pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared)
200{
201
202	if (attr == NULL || *attr == NULL ||
203	    (pshared != PTHREAD_PROCESS_PRIVATE &&
204	    pshared != PTHREAD_PROCESS_SHARED))
205		return (EINVAL);
206	(*attr)->m_pshared = pshared;
207	return (0);
208}
209
210int
211_pthread_mutexattr_getprotocol(const pthread_mutexattr_t * __restrict mattr,
212    int * __restrict protocol)
213{
214	int ret = 0;
215
216	if (mattr == NULL || *mattr == NULL)
217		ret = EINVAL;
218	else
219		*protocol = (*mattr)->m_protocol;
220
221	return (ret);
222}
223
224int
225_pthread_mutexattr_setprotocol(pthread_mutexattr_t *mattr, int protocol)
226{
227	int ret = 0;
228
229	if (mattr == NULL || *mattr == NULL ||
230	    protocol < PTHREAD_PRIO_NONE || protocol > PTHREAD_PRIO_PROTECT)
231		ret = EINVAL;
232	else {
233		(*mattr)->m_protocol = protocol;
234		(*mattr)->m_ceiling = THR_MAX_RR_PRIORITY;
235	}
236	return (ret);
237}
238
239int
240_pthread_mutexattr_getprioceiling(const pthread_mutexattr_t * __restrict mattr,
241    int * __restrict prioceiling)
242{
243	int ret = 0;
244
245	if (mattr == NULL || *mattr == NULL)
246		ret = EINVAL;
247	else if ((*mattr)->m_protocol != PTHREAD_PRIO_PROTECT)
248		ret = EINVAL;
249	else
250		*prioceiling = (*mattr)->m_ceiling;
251
252	return (ret);
253}
254
255int
256_pthread_mutexattr_setprioceiling(pthread_mutexattr_t *mattr, int prioceiling)
257{
258	int ret = 0;
259
260	if (mattr == NULL || *mattr == NULL)
261		ret = EINVAL;
262	else if ((*mattr)->m_protocol != PTHREAD_PRIO_PROTECT)
263		ret = EINVAL;
264	else
265		(*mattr)->m_ceiling = prioceiling;
266
267	return (ret);
268}
269
270int
271_thr_mutexattr_getrobust(pthread_mutexattr_t *mattr, int *robust)
272{
273	int ret;
274
275	if (mattr == NULL || *mattr == NULL) {
276		ret = EINVAL;
277	} else {
278		ret = 0;
279		*robust = (*mattr)->m_robust;
280	}
281	return (ret);
282}
283
284int
285_thr_mutexattr_setrobust(pthread_mutexattr_t *mattr, int robust)
286{
287	int ret;
288
289	if (mattr == NULL || *mattr == NULL) {
290		ret = EINVAL;
291	} else if (robust != PTHREAD_MUTEX_STALLED &&
292	    robust != PTHREAD_MUTEX_ROBUST) {
293		ret = EINVAL;
294	} else {
295		ret = 0;
296		(*mattr)->m_robust = robust;
297	}
298	return (ret);
299}
300
301