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 <signal.h>
  46 #include <stdlib.h>
  47 #include <time.h>
  48
  49 #include "debug.h"
  50 #include "rtld.h"
  51 #include "rtld_machdep.h"
  52
  53 #define WAFLAG          0x1     /* A writer holds the lock */
  54 #define RC_INCR         0x2     /* Adjusts count of readers desiring lock */
  55
  56 typedef struct Struct_Lock {
  57         volatile u_int lock;
  58         void *base;
  59 } Lock;
  60
  61 static sigset_t fullsigmask, oldsigmask;
  62 static int thread_flag;
  63
  64 static void *
  65 def_lock_create()
  66 {
  67     void *base;
  68     char *p;
  69     uintptr_t r;
  70     Lock *l;
  71
  72     /*
  73      * Arrange for the lock to occupy its own cache line.  First, we
  74      * optimistically allocate just a cache line, hoping that malloc
  75      * will give us a well-aligned block of memory.  If that doesn't
  76      * work, we allocate a larger block and take a well-aligned cache
  77      * line from it.
  78      */
  79     base = xmalloc(CACHE_LINE_SIZE);
  80     p = (char *)base;
  81     if ((uintptr_t)p % CACHE_LINE_SIZE != 0) {
  82         free(base);
  83         base = xmalloc(2 * CACHE_LINE_SIZE);
  84         p = (char *)base;
  85         if ((r = (uintptr_t)p % CACHE_LINE_SIZE) != 0)
  86             p += CACHE_LINE_SIZE - r;
  87     }
  88     l = (Lock *)p;
  89     l->base = base;
  90     l->lock = 0;
  91     return l;
  92 }
  93
  94 static void
  95 def_lock_destroy(void *lock)
  96 {
  97     Lock *l = (Lock *)lock;
  98
  99     free(l->base);
 100 }
 101
 102 static void
 103 def_rlock_acquire(void *lock)
 104 {
 105     Lock *l = (Lock *)lock;
 106
 107     atomic_add_acq_int(&l->lock, RC_INCR);
 108     while (l->lock & WAFLAG)
 109             ;   /* Spin */
 110 }
 111
 112 static void
 113 def_wlock_acquire(void *lock)
 114 {
 115     Lock *l = (Lock *)lock;
 116     sigset_t tmp_oldsigmask;
 117
 118     for ( ; ; ) {
 119         sigprocmask(SIG_BLOCK, &fullsigmask, &tmp_oldsigmask);
 120         if (atomic_cmpset_acq_int(&l->lock, 0, WAFLAG))
 121             break;
 122         sigprocmask(SIG_SETMASK, &tmp_oldsigmask, NULL);
 123     }
 124     oldsigmask = tmp_oldsigmask;
 125 }
 126
 127 static void
 128 def_lock_release(void *lock)
 129 {
 130     Lock *l = (Lock *)lock;
 131
 132     if ((l->lock & WAFLAG) == 0)
 133         atomic_add_rel_int(&l->lock, -RC_INCR);
 134     else {
 135         atomic_add_rel_int(&l->lock, -WAFLAG);
 136         sigprocmask(SIG_SETMASK, &oldsigmask, NULL);
 137     }
 138 }
 139
 140 static int
 141 def_thread_set_flag(int mask)
 142 {
 143         int old_val = thread_flag;
 144         thread_flag |= mask;
 145         return (old_val);
 146 }
 147
 148 static int
 149 def_thread_clr_flag(int mask)
 150 {
 151         int old_val = thread_flag;
 152         thread_flag &= ~mask;
 153         return (old_val);
 154 }
 155
 156 /*
 157  * Public interface exposed to the rest of the dynamic linker.
 158  */
 159 static struct RtldLockInfo lockinfo;
 160 static struct RtldLockInfo deflockinfo;
 161
 162 static __inline int
 163 thread_mask_set(int mask)
 164 {
 165         return lockinfo.thread_set_flag(mask);
 166 }
 167
 168 static __inline void
 169 thread_mask_clear(int mask)
 170 {
 171         lockinfo.thread_clr_flag(mask);
 172 }
 173
 174 #define RTLD_LOCK_CNT   2
 175 struct rtld_lock {
 176         void    *handle;
 177         int      mask;
 178 } rtld_locks[RTLD_LOCK_CNT];
 179
 180 rtld_lock_t     rtld_bind_lock = &rtld_locks[0];
 181 rtld_lock_t     rtld_libc_lock = &rtld_locks[1];
 182
 183 int
 184 rlock_acquire(rtld_lock_t lock)
 185 {
 186         if (thread_mask_set(lock->mask)) {
 187             dbg("rlock_acquire: recursed");
 188             return (0);
 189         }
 190         lockinfo.rlock_acquire(lock->handle);
 191         return (1);
 192 }
 193
 194 int
 195 wlock_acquire(rtld_lock_t lock)
 196 {
 197         if (thread_mask_set(lock->mask)) {
 198             dbg("wlock_acquire: recursed");
 199             return (0);
 200         }
 201         lockinfo.wlock_acquire(lock->handle);
 202         return (1);
 203 }
 204
 205 void
 206 rlock_release(rtld_lock_t lock, int locked)
 207 {
 208         if (locked == 0)
 209             return;
 210         thread_mask_clear(lock->mask);
 211         lockinfo.lock_release(lock->handle);
 212 }
 213
 214 void
 215 wlock_release(rtld_lock_t lock, int locked)
 216 {
 217         if (locked == 0)
 218             return;
 219         thread_mask_clear(lock->mask);
 220         lockinfo.lock_release(lock->handle);
 221 }
 222
 223 void
 224 lockdflt_init()
 225 {
 226     int i;
 227
 228     deflockinfo.rtli_version  = RTLI_VERSION;
 229     deflockinfo.lock_create   = def_lock_create;
 230     deflockinfo.lock_destroy  = def_lock_destroy;
 231     deflockinfo.rlock_acquire = def_rlock_acquire;
 232     deflockinfo.wlock_acquire = def_wlock_acquire;
 233     deflockinfo.lock_release  = def_lock_release;
 234     deflockinfo.thread_set_flag = def_thread_set_flag;
 235     deflockinfo.thread_clr_flag = def_thread_clr_flag;
 236     deflockinfo.at_fork = NULL;
 237
 238     for (i = 0; i < RTLD_LOCK_CNT; i++) {
 239             rtld_locks[i].mask   = (1 << i);
 240             rtld_locks[i].handle = NULL;
 241     }
 242
 243     memcpy(&lockinfo, &deflockinfo, sizeof(lockinfo));
 244     _rtld_thread_init(NULL);
 245     /*
 246      * Construct a mask to block all signals except traps which might
 247      * conceivably be generated within the dynamic linker itself.
 248      */
 249     sigfillset(&fullsigmask);
 250     sigdelset(&fullsigmask, SIGILL);
 251     sigdelset(&fullsigmask, SIGTRAP);
 252     sigdelset(&fullsigmask, SIGABRT);
 253     sigdelset(&fullsigmask, SIGEMT);
 254     sigdelset(&fullsigmask, SIGFPE);
 255     sigdelset(&fullsigmask, SIGBUS);
 256     sigdelset(&fullsigmask, SIGSEGV);
 257     sigdelset(&fullsigmask, SIGSYS);
 258 }
 259
 260 /*
 261  * Callback function to allow threads implementation to
 262  * register their own locking primitives if the default
 263  * one is not suitable.
 264  * The current context should be the only context
 265  * executing at the invocation time.
 266  */
 267 void
 268 _rtld_thread_init(struct RtldLockInfo *pli)
 269 {
 270         int flags, i;
 271         void *locks[RTLD_LOCK_CNT];
 272
 273         /* disable all locking while this function is running */
 274         flags = thread_mask_set(~0);
 275
 276         if (pli == NULL)
 277                 pli = &deflockinfo;
 278
 279
 280         for (i = 0; i < RTLD_LOCK_CNT; i++)
 281                 if ((locks[i] = pli->lock_create()) == NULL)
 282                         break;
 283
 284         if (i < RTLD_LOCK_CNT) {
 285                 while (--i >= 0)
 286                         pli->lock_destroy(locks[i]);
 287                 abort();
 288         }
 289
 290         for (i = 0; i < RTLD_LOCK_CNT; i++) {
 291                 if (rtld_locks[i].handle == NULL)
 292                         continue;
 293                 if (flags & rtld_locks[i].mask)
 294                         lockinfo.lock_release(rtld_locks[i].handle);
 295                 lockinfo.lock_destroy(rtld_locks[i].handle);
 296         }
 297
 298         for (i = 0; i < RTLD_LOCK_CNT; i++) {
 299                 rtld_locks[i].handle = locks[i];
 300                 if (flags & rtld_locks[i].mask)
 301                         pli->wlock_acquire(rtld_locks[i].handle);
 302         }
 303
 304         lockinfo.lock_create = pli->lock_create;
 305         lockinfo.lock_destroy = pli->lock_destroy;
 306         lockinfo.rlock_acquire = pli->rlock_acquire;
 307         lockinfo.wlock_acquire = pli->wlock_acquire;
 308         lockinfo.lock_release  = pli->lock_release;
 309         lockinfo.thread_set_flag = pli->thread_set_flag;
 310         lockinfo.thread_clr_flag = pli->thread_clr_flag;
 311         lockinfo.at_fork = pli->at_fork;
 312
 313         /* restore thread locking state, this time with new locks */
 314         thread_mask_clear(~0);
 315         thread_mask_set(flags);
 316         dbg("_rtld_thread_init: done");
 317 }