1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #include "lint.h"
28 #include "thr_uberdata.h"
29 #include <pthread.h>
30 
31 /*
32  * pthread_mutexattr_init: allocates the mutex attribute object and
33  * initializes it with the default values.
34  */
35 #pragma weak _pthread_mutexattr_init = pthread_mutexattr_init
36 int
pthread_mutexattr_init(pthread_mutexattr_t * attr)37 pthread_mutexattr_init(pthread_mutexattr_t *attr)
38 {
39 	mattr_t	*ap;
40 
41 	if ((ap = lmalloc(sizeof (mattr_t))) == NULL)
42 		return (ENOMEM);
43 	ap->pshared = PTHREAD_PROCESS_PRIVATE;
44 	ap->type = PTHREAD_MUTEX_DEFAULT;
45 	ap->protocol = PTHREAD_PRIO_NONE;
46 	ap->robustness = PTHREAD_MUTEX_STALLED;
47 	attr->__pthread_mutexattrp = ap;
48 	return (0);
49 }
50 
51 /*
52  * pthread_mutexattr_destroy: frees the mutex attribute object and
53  * invalidates it with NULL value.
54  */
55 int
pthread_mutexattr_destroy(pthread_mutexattr_t * attr)56 pthread_mutexattr_destroy(pthread_mutexattr_t *attr)
57 {
58 	if (attr == NULL || attr->__pthread_mutexattrp == NULL)
59 		return (EINVAL);
60 	lfree(attr->__pthread_mutexattrp, sizeof (mattr_t));
61 	attr->__pthread_mutexattrp = NULL;
62 	return (0);
63 }
64 
65 /*
66  * pthread_mutexattr_setpshared: sets the shared attribute
67  * to PTHREAD_PROCESS_PRIVATE or PTHREAD_PROCESS_SHARED.
68  * This is equivalent to setting the USYNC_THREAD/USYNC_PROCESS
69  * flag in mutex_init().
70  */
71 int
pthread_mutexattr_setpshared(pthread_mutexattr_t * attr,int pshared)72 pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared)
73 {
74 	mattr_t	*ap;
75 
76 	if (attr == NULL || (ap = attr->__pthread_mutexattrp) == NULL ||
77 	    (pshared != PTHREAD_PROCESS_PRIVATE &&
78 	    pshared != PTHREAD_PROCESS_SHARED))
79 		return (EINVAL);
80 	ap->pshared = pshared;
81 	return (0);
82 }
83 
84 /*
85  * pthread_mutexattr_getpshared: gets the shared attribute.
86  */
87 #pragma weak _pthread_mutexattr_getpshared = pthread_mutexattr_getpshared
88 int
pthread_mutexattr_getpshared(const pthread_mutexattr_t * attr,int * pshared)89 pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr, int *pshared)
90 {
91 	mattr_t	*ap;
92 
93 	if (attr == NULL || (ap = attr->__pthread_mutexattrp) == NULL ||
94 	    pshared == NULL)
95 		return (EINVAL);
96 	*pshared = ap->pshared;
97 	return (0);
98 }
99 
100 /*
101  * pthread_mutexattr_setprioceiling: sets the prioceiling attribute.
102  */
103 int
pthread_mutexattr_setprioceiling(pthread_mutexattr_t * attr,int prioceiling)104 pthread_mutexattr_setprioceiling(pthread_mutexattr_t *attr, int prioceiling)
105 {
106 	const pcclass_t *pccp = get_info_by_policy(SCHED_FIFO);
107 	mattr_t	*ap;
108 
109 	if (attr == NULL || (ap = attr->__pthread_mutexattrp) == NULL ||
110 	    prioceiling < pccp->pcc_primin || prioceiling > pccp->pcc_primax)
111 		return (EINVAL);
112 	ap->prioceiling = prioceiling;
113 	return (0);
114 }
115 
116 /*
117  * pthread_mutexattr_getprioceiling: gets the prioceiling attribute.
118  */
119 #pragma weak _pthread_mutexattr_getprioceiling = \
120 			pthread_mutexattr_getprioceiling
121 int
pthread_mutexattr_getprioceiling(const pthread_mutexattr_t * attr,int * ceiling)122 pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *attr, int *ceiling)
123 {
124 	mattr_t	*ap;
125 
126 	if (attr == NULL || (ap = attr->__pthread_mutexattrp) == NULL ||
127 	    ceiling == NULL)
128 		return (EINVAL);
129 	*ceiling = ap->prioceiling;
130 	return (0);
131 }
132 
133 /*
134  * pthread_mutexattr_setprotocol: sets the protocol attribute.
135  */
136 int
pthread_mutexattr_setprotocol(pthread_mutexattr_t * attr,int protocol)137 pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr, int protocol)
138 {
139 	mattr_t	*ap;
140 
141 	if (attr == NULL || (ap = attr->__pthread_mutexattrp) == NULL)
142 		return (EINVAL);
143 	if (protocol != PTHREAD_PRIO_NONE &&
144 	    protocol != PTHREAD_PRIO_INHERIT &&
145 	    protocol != PTHREAD_PRIO_PROTECT)
146 		return (ENOTSUP);
147 	ap->protocol = protocol;
148 	return (0);
149 }
150 
151 /*
152  * pthread_mutexattr_getprotocol: gets the protocol attribute.
153  */
154 #pragma weak _pthread_mutexattr_getprotocol = pthread_mutexattr_getprotocol
155 int
pthread_mutexattr_getprotocol(const pthread_mutexattr_t * attr,int * protocol)156 pthread_mutexattr_getprotocol(const pthread_mutexattr_t *attr, int *protocol)
157 {
158 	mattr_t	*ap;
159 
160 	if (attr == NULL || (ap = attr->__pthread_mutexattrp) == NULL ||
161 	    protocol == NULL)
162 		return (EINVAL);
163 	*protocol = ap->protocol;
164 	return (0);
165 }
166 
167 /*
168  * pthread_mutexattr_setrobust: set the mutex robust attribute.
169  * pthread_mutexattr_setrobust_np: the historical name.
170  */
171 #pragma weak pthread_mutexattr_setrobust_np = pthread_mutexattr_setrobust
172 int
pthread_mutexattr_setrobust(pthread_mutexattr_t * attr,int robust)173 pthread_mutexattr_setrobust(pthread_mutexattr_t *attr, int robust)
174 {
175 	mattr_t	*ap;
176 
177 	if (attr == NULL || (ap = attr->__pthread_mutexattrp) == NULL ||
178 	    (robust != PTHREAD_MUTEX_ROBUST && robust != PTHREAD_MUTEX_STALLED))
179 		return (EINVAL);
180 	ap->robustness = robust;
181 	return (0);
182 }
183 
184 /*
185  * pthread_mutexattr_getrobust: get the mutex robust attribute.
186  * pthread_mutexattr_getrobust_np: the historical name.
187  */
188 #pragma weak pthread_mutexattr_getrobust_np = pthread_mutexattr_getrobust
189 int
pthread_mutexattr_getrobust(const pthread_mutexattr_t * attr,int * robust)190 pthread_mutexattr_getrobust(const pthread_mutexattr_t *attr, int *robust)
191 {
192 	mattr_t	*ap;
193 
194 	if (attr == NULL || (ap = attr->__pthread_mutexattrp) == NULL ||
195 	    robust == NULL)
196 		return (EINVAL);
197 	*robust = ap->robustness;
198 	return (0);
199 }
200 
201 /*
202  * pthread_mutex_init: Initializes the mutex object.  It copies the
203  * various attributes into one type argument and calls mutex_init().
204  */
205 #pragma weak _pthread_mutex_init = pthread_mutex_init
206 int
pthread_mutex_init(pthread_mutex_t * _RESTRICT_KYWD mutex,const pthread_mutexattr_t * _RESTRICT_KYWD attr)207 pthread_mutex_init(pthread_mutex_t *_RESTRICT_KYWD mutex,
208     const pthread_mutexattr_t *_RESTRICT_KYWD attr)
209 {
210 	mattr_t *ap;
211 	int	type;
212 	int	prioceiling = 0;
213 
214 	/*
215 	 * All of the pshared, type, protocol, robust attributes
216 	 * translate to bits in the mutex_type field.
217 	 */
218 	if (attr != NULL) {
219 		if ((ap = attr->__pthread_mutexattrp) == NULL)
220 			return (EINVAL);
221 		type = ap->pshared | ap->type | ap->protocol | ap->robustness;
222 		if (ap->protocol == PTHREAD_PRIO_PROTECT)
223 			prioceiling = ap->prioceiling;
224 	} else {
225 		type = PTHREAD_PROCESS_PRIVATE | PTHREAD_MUTEX_DEFAULT |
226 		    PTHREAD_PRIO_NONE | PTHREAD_MUTEX_STALLED;
227 	}
228 
229 	/*
230 	 * POSIX mutexes (this interface) make no guarantee about the state of
231 	 * the mutex before pthread_mutex_init(3C) is called.  Sun mutexes, upon
232 	 * which these are built and which mutex_init(3C) below represents
233 	 * require that a robust mutex be initialized to all 0s _prior_ to
234 	 * mutex_init() being called, and that mutex_init() of an initialized
235 	 * mutex return EBUSY.
236 	 *
237 	 * We respect both these behaviors by zeroing the mutex here in the
238 	 * POSIX implementation if and only if the mutex magic is incorrect,
239 	 * and the mutex is robust.
240 	 */
241 	if (((type & PTHREAD_MUTEX_ROBUST) != 0) &&
242 	    (((mutex_t *)mutex)->mutex_magic != MUTEX_MAGIC)) {
243 		(void) memset(mutex, 0, sizeof (*mutex));
244 	}
245 
246 	return (mutex_init((mutex_t *)mutex, type, &prioceiling));
247 }
248 
249 /*
250  * pthread_mutex_setprioceiling: sets the prioceiling.
251  * From the SUSv3 (POSIX) specification for pthread_mutex_setprioceiling():
252  *	The process of locking the mutex need not
253  *	adhere to the priority protect protocol.
254  * We pass the MUTEX_NOCEIL flag to mutex_lock_internal() so that
255  * a non-realtime thread can successfully execute this operation.
256  */
257 int
pthread_mutex_setprioceiling(pthread_mutex_t * mutex,int ceil,int * oceil)258 pthread_mutex_setprioceiling(pthread_mutex_t *mutex, int ceil, int *oceil)
259 {
260 	mutex_t *mp = (mutex_t *)mutex;
261 	const pcclass_t *pccp = get_info_by_policy(SCHED_FIFO);
262 	int error;
263 
264 	if (!(mp->mutex_type & PTHREAD_PRIO_PROTECT) ||
265 	    ceil < pccp->pcc_primin || ceil > pccp->pcc_primax)
266 		return (EINVAL);
267 	error = mutex_lock_internal(mp, NULL, MUTEX_LOCK | MUTEX_NOCEIL);
268 	if (error == 0 || error == EOWNERDEAD || error == ELOCKUNMAPPED) {
269 		if (oceil)
270 			*oceil = mp->mutex_ceiling;
271 		mp->mutex_ceiling = ceil;
272 		error = mutex_unlock_internal(mp, 1);
273 	}
274 	return (error);
275 }
276 
277 /*
278  * pthread_mutex_getprioceiling: gets the prioceiling.
279  */
280 #pragma weak _pthread_mutex_getprioceiling = pthread_mutex_getprioceiling
281 int
pthread_mutex_getprioceiling(const pthread_mutex_t * mp,int * ceiling)282 pthread_mutex_getprioceiling(const pthread_mutex_t *mp, int *ceiling)
283 {
284 	*ceiling = ((mutex_t *)mp)->mutex_ceiling;
285 	return (0);
286 }
287 
288 /*
289  * UNIX98
290  * pthread_mutexattr_settype: sets the type attribute
291  */
292 int
pthread_mutexattr_settype(pthread_mutexattr_t * attr,int type)293 pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type)
294 {
295 	mattr_t	*ap;
296 
297 	if (attr == NULL || (ap = attr->__pthread_mutexattrp) == NULL)
298 		return (EINVAL);
299 	switch (type) {
300 	case PTHREAD_MUTEX_NORMAL:
301 		type = LOCK_NORMAL;
302 		break;
303 	case PTHREAD_MUTEX_ERRORCHECK:
304 		type = LOCK_ERRORCHECK;
305 		break;
306 	case PTHREAD_MUTEX_RECURSIVE:
307 		type = LOCK_RECURSIVE | LOCK_ERRORCHECK;
308 		break;
309 	default:
310 		return (EINVAL);
311 	}
312 	ap->type = type;
313 	return (0);
314 }
315 
316 /*
317  * UNIX98
318  * pthread_mutexattr_gettype: gets the type attribute.
319  */
320 int
pthread_mutexattr_gettype(const pthread_mutexattr_t * attr,int * typep)321 pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *typep)
322 {
323 	mattr_t	*ap;
324 	int type;
325 
326 	if (attr == NULL || (ap = attr->__pthread_mutexattrp) == NULL ||
327 	    typep == NULL)
328 		return (EINVAL);
329 	switch (ap->type) {
330 	case LOCK_NORMAL:
331 		type = PTHREAD_MUTEX_NORMAL;
332 		break;
333 	case LOCK_ERRORCHECK:
334 		type = PTHREAD_MUTEX_ERRORCHECK;
335 		break;
336 	case LOCK_RECURSIVE | LOCK_ERRORCHECK:
337 		type = PTHREAD_MUTEX_RECURSIVE;
338 		break;
339 	default:
340 		return (EINVAL);
341 	}
342 	*typep = type;
343 	return (0);
344 }
345