1 /*
2  * Copyright (c) 1997 John Birrell <jb@cimlogic.com.au>.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the author nor the names of any co-contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  */
30 
31 #include <sys/types.h>
32 #include <machine/atomic.h>
33 #include <machine/tls.h>
34 #include <pthread.h>
35 #include <libc_private.h>
36 #include "spinlock.h"
37 
38 #include "thr_private.h"
39 
40 #define	MAX_SPINLOCKS	256
41 
42 /*
43  * These data structures are used to trace all spinlocks
44  * in libc.
45  */
46 struct spinlock_extra {
47 	spinlock_t	*owner;
48 };
49 
50 static umtx_t			spinlock_static_lock;
51 static struct spinlock_extra	extra[MAX_SPINLOCKS];
52 static int			spinlock_count;
53 static int			initialized;
54 
55 static void	init_spinlock(spinlock_t *lck);
56 
57 /*
58  * These functions implement temporary spinlocks as used by libc.
59  * these are not persistent spinlocks, so we use the API for
60  * temporary locks which block all signals for the duration.
61  */
62 void
63 _spinunlock(spinlock_t *lck)
64 {
65 	pthread_t curthread = tls_get_curthread();
66 
67 	THR_UMTX_UNLOCK(curthread, (volatile umtx_t *)&lck->access_lock);
68 }
69 
70 void
71 _spinlock(spinlock_t *lck)
72 {
73 	pthread_t curthread;
74 
75 	if (!__isthreaded)
76 		PANIC("Spinlock called when not threaded.");
77 	if (!initialized)
78 		PANIC("Spinlocks not initialized.");
79 	if (lck->fname == NULL)
80 		init_spinlock(lck);
81 
82 	curthread = tls_get_curthread();
83 	THR_UMTX_LOCK(curthread, (volatile umtx_t *)&lck->access_lock);
84 }
85 
86 /*
87  * Returns 0 on success, else EBUSY
88  */
89 int
90 _spintrylock(spinlock_t *lck)
91 {
92 	pthread_t curthread;
93 
94 	if (!__isthreaded)
95 		PANIC("Spinlock called when not threaded.");
96 	if (!initialized)
97 		PANIC("Spinlocks not initialized.");
98 	if (lck->fname == NULL)
99 		init_spinlock(lck);
100 
101 	curthread = tls_get_curthread();
102 	return(THR_UMTX_TRYLOCK(curthread,
103 				(volatile umtx_t *)&lck->access_lock));
104 }
105 
106 void
107 _spinlock_debug(spinlock_t *lck, char *fname __unused, int lineno __unused)
108 {
109 	_spinlock(lck);
110 }
111 
112 static void
113 init_spinlock(spinlock_t *lck)
114 {
115 	static int count = 0;
116 	pthread_t curthread = tls_get_curthread();
117 
118 	THR_UMTX_LOCK(curthread, &spinlock_static_lock);
119 	if ((lck->fname == NULL) && (spinlock_count < MAX_SPINLOCKS)) {
120 		lck->fname = (char *)&extra[spinlock_count];
121 		extra[spinlock_count].owner = lck;
122 		spinlock_count++;
123 	}
124 	THR_UMTX_UNLOCK(curthread, &spinlock_static_lock);
125 	if (lck->fname == NULL && ++count < 5)
126 		stderr_debug("Warning: exceeded max spinlocks");
127 }
128 
129 void
130 _thr_spinlock_init(void)
131 {
132 	int i;
133 
134 	_thr_umtx_init(&spinlock_static_lock);
135 	if (initialized != 0) {
136 		/*
137 		 * called after fork() to reset state of libc spin locks,
138 		 * it is not quite right since libc may be in inconsistent
139 		 * state, resetting the locks to allow current thread to be
140 		 * able to hold them may not help things too much, but
141 		 * anyway, we do our best.
142 		 * it is better to do pthread_atfork in libc.
143 		 */
144 		for (i = 0; i < spinlock_count; i++)
145 			_thr_umtx_init((volatile umtx_t *)
146 				&extra[i].owner->access_lock);
147 	} else {
148 		initialized = 1;
149 	}
150 }
151