2 * Copyright 1999, 2000 John D. Polstra.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
25 * from: FreeBSD: src/libexec/rtld-elf/sparc64/lockdflt.c,v 1.3 2002/10/09
30 * Thread locking implementation for the dynamic linker.
32 * We use the "simple, non-scalable reader-preference lock" from:
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.
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".
45 #include <sys/param.h>
55 #include "rtld_machdep.h"
57 extern pid_t __sys_getpid(void);
59 #define WAFLAG 0x1 /* A writer holds the lock */
60 #define RC_INCR 0x2 /* Adjusts count of readers desiring lock */
64 int tid; /* owner (exclusive) */
65 int count; /* recursion (exclusive) */
66 sigset_t savesigmask; /* first exclusive owner sets mask */
69 #define cpu_ccfence() __asm __volatile("" : : : "memory")
71 static sigset_t fullsigmask;
73 struct Struct_Lock phdr_lock;
74 struct Struct_Lock bind_lock;
75 struct Struct_Lock libc_lock;
77 rtld_lock_t rtld_phdr_lock = &phdr_lock;
78 rtld_lock_t rtld_bind_lock = &bind_lock;
79 rtld_lock_t rtld_libc_lock = &libc_lock;
82 rlock_acquire(rtld_lock_t lock, RtldLockState *state)
90 if ((v & WAFLAG) == 0) {
91 if (atomic_fcmpset_int(&lock->lock, &v, v + RC_INCR)) {
92 state->lockstate = RTLD_LOCK_RLOCKED;
98 if (lock->tid == tid) {
100 state->lockstate = RTLD_LOCK_WLOCKED;
103 umtx_sleep(&lock->lock, v, 0);
111 wlock_acquire(rtld_lock_t lock, RtldLockState *state)
113 sigset_t tmp_oldsigmask;
114 int tid = lwp_gettid();
116 if (lock->tid == tid) {
118 state->lockstate = RTLD_LOCK_WLOCKED;
122 sigprocmask(SIG_BLOCK, &fullsigmask, &tmp_oldsigmask);
124 if (atomic_cmpset_acq_int(&lock->lock, 0, WAFLAG))
126 umtx_sleep(&lock->lock, 0, 0);
130 lock->savesigmask = tmp_oldsigmask;
131 state->lockstate = RTLD_LOCK_WLOCKED;
135 lock_release(rtld_lock_t lock, RtldLockState *state)
137 sigset_t tmp_oldsigmask;
140 if (state->lockstate == RTLD_LOCK_UNLOCKED)
142 if ((lock->lock & WAFLAG) == 0) {
143 v = atomic_fetchadd_int(&lock->lock, -RC_INCR) - RC_INCR;
145 umtx_wakeup(&lock->lock, 0);
146 } else if (--lock->count == 0) {
147 tmp_oldsigmask = lock->savesigmask;
149 v = atomic_fetchadd_int(&lock->lock, -WAFLAG) - WAFLAG;
151 umtx_wakeup(&lock->lock, 0);
152 sigprocmask(SIG_SETMASK, &tmp_oldsigmask, NULL);
154 state->lockstate = RTLD_LOCK_UNLOCKED;
159 lock_reset(rtld_lock_t lock)
161 memset(lock, 0, sizeof(*lock));
165 lock_upgrade(rtld_lock_t lock, RtldLockState *state)
169 if (state->lockstate == RTLD_LOCK_RLOCKED) {
170 lock_release(lock, state);
171 wlock_acquire(lock, state);
176 lock_restart_for_upgrade(RtldLockState *state)
180 switch (state->lockstate) {
181 case RTLD_LOCK_UNLOCKED:
182 case RTLD_LOCK_WLOCKED:
184 case RTLD_LOCK_RLOCKED:
185 siglongjmp(state->env, 1);
196 * Construct a mask to block all signals except traps which might
197 * conceivably be generated within the dynamic linker itself.
199 sigfillset(&fullsigmask);
200 sigdelset(&fullsigmask, SIGILL);
201 sigdelset(&fullsigmask, SIGTRAP);
202 sigdelset(&fullsigmask, SIGABRT);
203 sigdelset(&fullsigmask, SIGEMT);
204 sigdelset(&fullsigmask, SIGFPE);
205 sigdelset(&fullsigmask, SIGBUS);
206 sigdelset(&fullsigmask, SIGSEGV);
207 sigdelset(&fullsigmask, SIGSYS);
209 _rtld_thread_init(NULL);
213 * (also called by pthreads)
216 _rtld_thread_init(void *dummy __unused)
218 lock_reset(rtld_phdr_lock);
219 lock_reset(rtld_bind_lock);
220 lock_reset(rtld_libc_lock);
223 static RtldLockState fork_states[3];
226 _rtld_thread_prefork(void)
228 wlock_acquire(rtld_phdr_lock, &fork_states[0]);
229 wlock_acquire(rtld_bind_lock, &fork_states[1]);
230 wlock_acquire(rtld_libc_lock, &fork_states[2]);
234 _rtld_thread_postfork(void)
236 lock_release(rtld_libc_lock, &fork_states[2]);
237 lock_release(rtld_bind_lock, &fork_states[1]);
238 lock_release(rtld_phdr_lock, &fork_states[0]);
242 _rtld_thread_childfork(void)
244 sigset_t tmp_oldsigmask;
246 lock_reset(rtld_phdr_lock);
247 lock_reset(rtld_bind_lock);
248 tmp_oldsigmask = rtld_libc_lock->savesigmask;
249 lock_reset(rtld_libc_lock);
250 sigprocmask(SIG_SETMASK, &tmp_oldsigmask, NULL);