1 /*-
2 * Copyright 1999, 2000 John D. Polstra.
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 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 *
25 * from: FreeBSD: src/libexec/rtld-elf/sparc64/lockdflt.c,v 1.3 2002/10/09
26 * $FreeBSD$
27 */
28
29 /*
30 * Thread locking implementation for the dynamic linker.
31 *
32 * We use the "simple, non-scalable reader-preference lock" from:
33 *
34 * J. M. Mellor-Crummey and M. L. Scott. "Scalable Reader-Writer
35 * Synchronization for Shared-Memory Multiprocessors." 3rd ACM Symp. on
36 * Principles and Practice of Parallel Programming, April 1991.
37 *
38 * In this algorithm the lock is a single word. Its low-order bit is
39 * set when a writer holds the lock. The remaining high-order bits
40 * contain a count of readers desiring the lock. The algorithm requires
41 * atomic "compare_and_store" and "add" operations, which we implement
42 * using assembly language sequences in "rtld_start.S".
43 */
44
45 #include <sys/param.h>
46 #include <signal.h>
47 #include <stdlib.h>
48 #include <time.h>
49
50 #include <stdio.h>
51 #include <sys/file.h>
52
53 #include <machine/sysarch.h>
54 #include <machine/tls.h>
55
56 #include "debug.h"
57 #include "rtld.h"
58 #include "rtld_machdep.h"
59
60 extern pid_t __sys_getpid(void);
61
62 #define WAFLAG 0x1 /* A writer holds the lock */
63 #define SLFLAG 0x2 /* Sleep pending on lock */
64 #define RC_INCR 0x4 /* Adjusts count of readers desiring lock */
65
66 struct Struct_Lock {
67 volatile u_int lock;
68 int count; /* recursion (exclusive) */
69 void *owner; /* owner (exclusive) - tls_get_tcb() */
70 sigset_t savesigmask; /* first exclusive owner sets mask */
71 } __cachealign;
72
73 #define cpu_ccfence() __asm __volatile("" : : : "memory")
74
75 static sigset_t fullsigmask;
76
77 struct Struct_Lock phdr_lock;
78 struct Struct_Lock bind_lock;
79 struct Struct_Lock libc_lock;
80
81 rtld_lock_t rtld_phdr_lock = &phdr_lock;
82 rtld_lock_t rtld_bind_lock = &bind_lock;
83 rtld_lock_t rtld_libc_lock = &libc_lock;
84
85 static int _rtld_isthreaded;
86
87 void _rtld_setthreaded(int threaded);
88
89 void
_rtld_setthreaded(int threaded)90 _rtld_setthreaded(int threaded)
91 {
92 _rtld_isthreaded = threaded;
93 }
94
95 static __inline
96 void *
myid(void)97 myid(void)
98 {
99 if (_rtld_isthreaded) {
100 return(tls_get_tcb());
101 }
102 return (void *)(intptr_t)1;
103 }
104
105 void
rlock_acquire(rtld_lock_t lock,RtldLockState * state)106 rlock_acquire(rtld_lock_t lock, RtldLockState *state)
107 {
108 void *tid = myid();
109 int v;
110
111 v = lock->lock;
112 cpu_ccfence();
113 for (;;) {
114 if ((v & WAFLAG) == 0) {
115 if (atomic_fcmpset_int(&lock->lock, &v, v + RC_INCR)) {
116 state->lockstate = RTLD_LOCK_RLOCKED;
117 break;
118 }
119 } else {
120 if (lock->owner == tid) {
121 ++lock->count;
122 state->lockstate = RTLD_LOCK_WLOCKED;
123 break;
124 }
125 if (atomic_fcmpset_int(&lock->lock, &v, v | SLFLAG)) {
126 umtx_sleep(&lock->lock, v, 0);
127 }
128 }
129 cpu_ccfence();
130 }
131 }
132
133 void
wlock_acquire(rtld_lock_t lock,RtldLockState * state)134 wlock_acquire(rtld_lock_t lock, RtldLockState *state)
135 {
136 void *tid = myid();
137 sigset_t tmp_oldsigmask;
138 int v;
139
140 if (lock->owner == tid) {
141 ++lock->count;
142 state->lockstate = RTLD_LOCK_WLOCKED;
143 return;
144 }
145
146 sigprocmask(SIG_BLOCK, &fullsigmask, &tmp_oldsigmask);
147 v = lock->lock;
148 for (;;) {
149 if ((v & ~SLFLAG) == 0) {
150 if (atomic_fcmpset_int(&lock->lock, &v, WAFLAG))
151 break;
152 } else {
153 if (atomic_fcmpset_int(&lock->lock, &v, v | SLFLAG)) {
154 umtx_sleep(&lock->lock, v, 0);
155 }
156 }
157 cpu_ccfence();
158 }
159 lock->owner = tid;
160 lock->count = 1;
161 lock->savesigmask = tmp_oldsigmask;
162 state->lockstate = RTLD_LOCK_WLOCKED;
163 }
164
165 void
lock_release(rtld_lock_t lock,RtldLockState * state)166 lock_release(rtld_lock_t lock, RtldLockState *state)
167 {
168 sigset_t tmp_oldsigmask;
169 int v;
170
171 if (state->lockstate == RTLD_LOCK_UNLOCKED)
172 return;
173 if ((lock->lock & WAFLAG) == 0) {
174 v = atomic_fetchadd_int(&lock->lock, -RC_INCR) - RC_INCR;
175 if (v == SLFLAG) {
176 atomic_clear_int(&lock->lock, SLFLAG);
177 umtx_wakeup(&lock->lock, 0);
178 }
179 } else if (--lock->count == 0) {
180 tmp_oldsigmask = lock->savesigmask;
181 lock->owner = NULL;
182 v = atomic_fetchadd_int(&lock->lock, -WAFLAG) - WAFLAG;
183 if (v == SLFLAG) {
184 atomic_clear_int(&lock->lock, SLFLAG);
185 umtx_wakeup(&lock->lock, 0);
186 }
187 sigprocmask(SIG_SETMASK, &tmp_oldsigmask, NULL);
188 }
189 state->lockstate = RTLD_LOCK_UNLOCKED;
190 }
191
192 static
193 void
lock_reset(rtld_lock_t lock)194 lock_reset(rtld_lock_t lock)
195 {
196 memset(lock, 0, sizeof(*lock));
197 }
198
199 void
lock_upgrade(rtld_lock_t lock,RtldLockState * state)200 lock_upgrade(rtld_lock_t lock, RtldLockState *state)
201 {
202 if (state == NULL)
203 return;
204 if (state->lockstate == RTLD_LOCK_RLOCKED) {
205 lock_release(lock, state);
206 wlock_acquire(lock, state);
207 }
208 }
209
210 void
lock_restart_for_upgrade(RtldLockState * state)211 lock_restart_for_upgrade(RtldLockState *state)
212 {
213 if (state == NULL)
214 return;
215 switch (state->lockstate) {
216 case RTLD_LOCK_UNLOCKED:
217 case RTLD_LOCK_WLOCKED:
218 break;
219 case RTLD_LOCK_RLOCKED:
220 siglongjmp(state->env, 1);
221 break;
222 default:
223 assert(0);
224 }
225 }
226
227 void
lockdflt_init(void)228 lockdflt_init(void)
229 {
230 /*
231 * Construct a mask to block all signals except traps which might
232 * conceivably be generated within the dynamic linker itself.
233 */
234 sigfillset(&fullsigmask);
235 sigdelset(&fullsigmask, SIGILL);
236 sigdelset(&fullsigmask, SIGTRAP);
237 sigdelset(&fullsigmask, SIGABRT);
238 sigdelset(&fullsigmask, SIGEMT);
239 sigdelset(&fullsigmask, SIGFPE);
240 sigdelset(&fullsigmask, SIGBUS);
241 sigdelset(&fullsigmask, SIGSEGV);
242 sigdelset(&fullsigmask, SIGSYS);
243
244 _rtld_thread_init(NULL);
245 }
246
247 /*
248 * (also called by pthreads)
249 */
250 void
_rtld_thread_init(void * dummy __unused)251 _rtld_thread_init(void *dummy __unused)
252 {
253 lock_reset(rtld_phdr_lock);
254 lock_reset(rtld_bind_lock);
255 lock_reset(rtld_libc_lock);
256 }
257
258 static RtldLockState fork_states[3];
259
260 void
_rtld_thread_prefork(void)261 _rtld_thread_prefork(void)
262 {
263 wlock_acquire(rtld_phdr_lock, &fork_states[0]);
264 wlock_acquire(rtld_bind_lock, &fork_states[1]);
265 wlock_acquire(rtld_libc_lock, &fork_states[2]);
266 }
267
268 void
_rtld_thread_postfork(void)269 _rtld_thread_postfork(void)
270 {
271 lock_release(rtld_libc_lock, &fork_states[2]);
272 lock_release(rtld_bind_lock, &fork_states[1]);
273 lock_release(rtld_phdr_lock, &fork_states[0]);
274 }
275
276 void
_rtld_thread_childfork(void)277 _rtld_thread_childfork(void)
278 {
279 sigset_t tmp_oldsigmask;
280
281 lock_reset(rtld_phdr_lock);
282 lock_reset(rtld_bind_lock);
283 tmp_oldsigmask = rtld_libc_lock->savesigmask;
284 lock_reset(rtld_libc_lock);
285 sigprocmask(SIG_SETMASK, &tmp_oldsigmask, NULL);
286 }
287