libexec/rtld-elf/rtld_lock.c

   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 }