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 90 _rtld_setthreaded(int threaded) 91 { 92 _rtld_isthreaded = threaded; 93 } 94 95 static __inline 96 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 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 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 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 194 lock_reset(rtld_lock_t lock) 195 { 196 memset(lock, 0, sizeof(*lock)); 197 } 198 199 void 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 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 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 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 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 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 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