db2/mutex/mutex.c

   1 /*-
   2  * See the file LICENSE for redistribution information.
   3  *
   4  * Copyright (c) 1996, 1997, 1998
   5  *      Sleepycat Software.  All rights reserved.
   6  */
   7
   8 #include "config.h"
   9
  10 #ifndef lint
  11 static const char sccsid[] = "@(#)mutex.c       10.48 (Sleepycat) 5/23/98";
  12 #endif /* not lint */
  13
  14 #ifndef NO_SYSTEM_INCLUDES
  15 #include <sys/types.h>
  16
  17 #include <errno.h>
  18 #include <fcntl.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <unistd.h>
  22 #endif
  23
  24 #include "db_int.h"
  25
  26 #ifdef HAVE_SPINLOCKS
  27
  28 #ifdef HAVE_FUNC_AIX
  29 #define TSL_INIT(x)
  30 #define TSL_SET(x)      (!_check_lock(x, 0, 1))
  31 #define TSL_UNSET(x)    _clear_lock(x, 0)
  32 #endif
  33
  34 #ifdef HAVE_ASSEM_MC68020_GCC
  35 #include "68020.gcc"
  36 #endif
  37
  38 #if defined(HAVE_FUNC_MSEM)
  39 /*
  40  * XXX
  41  * Should we not use MSEM_IF_NOWAIT and let the system block for us?
  42  * I've no idea if this will block all threads in the process or not.
  43  */
  44 #define TSL_INIT(x)     (msem_init(x, MSEM_UNLOCKED) == NULL)
  45 #define TSL_INIT_ERROR  1
  46 #define TSL_SET(x)      (!msem_lock(x, MSEM_IF_NOWAIT))
  47 #define TSL_UNSET(x)    msem_unlock(x, 0)
  48 #endif
  49
  50 #ifdef HAVE_FUNC_RELIANT
  51 #define TSL_INIT(x)     initspin(x, 1)
  52 #define TSL_SET(x)      (cspinlock(x) == 0)
  53 #define TSL_UNSET(x)    spinunlock(x)
  54 #endif
  55
  56 #ifdef HAVE_FUNC_SGI
  57 #define TSL_INIT(x)     (init_lock(x) != 0)
  58 #define TSL_INIT_ERROR  1
  59 #define TSL_SET(x)      (!acquire_lock(x))
  60 #define TSL_UNSET(x)    release_lock(x)
  61 #endif
  62
  63 #ifdef HAVE_FUNC_SOLARIS
  64 /*
  65  * Semaphore calls don't work on Solaris 5.5.
  66  *
  67  * #define      TSL_INIT(x)     (sema_init(x, 1, USYNC_PROCESS, NULL) != 0)
  68  * #define      TSL_INIT_ERROR  1
  69  * #define      TSL_SET(x)      (sema_wait(x) == 0)
  70  * #define      TSL_UNSET(x)    sema_post(x)
  71  */
  72 #define TSL_INIT(x)
  73 #define TSL_SET(x)      (_lock_try(x))
  74 #define TSL_UNSET(x)    _lock_clear(x)
  75 #endif
  76
  77 #ifdef HAVE_ASSEM_PARISC_GCC
  78 #include "parisc.gcc"
  79 #endif
  80
  81 #ifdef HAVE_ASSEM_SCO_CC
  82 #include "sco.cc"
  83 #endif
  84
  85 #ifdef HAVE_ASSEM_SPARC_GCC
  86 #include "sparc.gcc"
  87 #endif
  88
  89 #ifdef HAVE_ASSEM_UTS4_CC
  90 #define TSL_INIT(x)
  91 #define TSL_SET(x)      (!uts_lock(x, 1))
  92 #define TSL_UNSET(x)    (*(x) = 0)
  93 #endif
  94
  95 #ifdef HAVE_ASSEM_X86_GCC
  96 #include "x86.gcc"
  97 #endif
  98
  99 #ifdef WIN16
 100 /* Win16 spinlocks are simple because we cannot possibly be preempted. */
 101 #define TSL_INIT(tsl)
 102 #define TSL_SET(tsl)    (*(tsl) = 1)
 103 #define TSL_UNSET(tsl)  (*(tsl) = 0)
 104 #endif
 105
 106 #if defined(_WIN32)
 107 /*
 108  * XXX
 109  * DBDB this needs to be byte-aligned!!
 110  */
 111 #define TSL_INIT(tsl)
 112 #define TSL_SET(tsl)    (!InterlockedExchange((PLONG)tsl, 1))
 113 #define TSL_UNSET(tsl)  (*(tsl) = 0)
 114 #endif
 115
 116 #endif /* HAVE_SPINLOCKS */
 117
 118 /*
 119  * __db_mutex_init --
 120  *      Initialize a DB mutex structure.
 121  *
 122  * PUBLIC: int __db_mutex_init __P((db_mutex_t *, u_int32_t));
 123  */
 124 int
 125 __db_mutex_init(mp, off)
 126         db_mutex_t *mp;
 127         u_int32_t off;
 128 {
 129 #ifdef DIAGNOSTIC
 130         if ((ALIGNTYPE)mp & (MUTEX_ALIGNMENT - 1)) {
 131                 (void)fprintf(stderr,
 132                     "MUTEX ERROR: mutex NOT %d-byte aligned!\n",
 133                     MUTEX_ALIGNMENT);
 134                 abort();
 135         }
 136 #endif
 137         memset(mp, 0, sizeof(db_mutex_t));
 138
 139 #ifdef HAVE_SPINLOCKS
 140         COMPQUIET(off, 0);
 141
 142 #ifdef TSL_INIT_ERROR
 143         if (TSL_INIT(&mp->tsl_resource))
 144                 return (errno);
 145 #else
 146         TSL_INIT(&mp->tsl_resource);
 147 #endif
 148         mp->spins = __os_spin();
 149 #else
 150         mp->off = off;
 151 #endif
 152         return (0);
 153 }
 154
 155 #define MS(n)           ((n) * 1000)    /* Milliseconds to micro-seconds. */
 156 #define SECOND          (MS(1000))      /* A second's worth of micro-seconds. */
 157
 158 /*
 159  * __db_mutex_lock
 160  *      Lock on a mutex, logically blocking if necessary.
 161  *
 162  * PUBLIC: int __db_mutex_lock __P((db_mutex_t *, int));
 163  */
 164 int
 165 __db_mutex_lock(mp, fd)
 166         db_mutex_t *mp;
 167         int fd;
 168 {
 169         u_long usecs;
 170 #ifdef HAVE_SPINLOCKS
 171         int nspins;
 172 #else
 173         struct flock k_lock;
 174         pid_t mypid;
 175         int locked;
 176 #endif
 177
 178         if (!DB_GLOBAL(db_mutexlocks))
 179                 return (0);
 180
 181 #ifdef HAVE_SPINLOCKS
 182         COMPQUIET(fd, 0);
 183
 184         for (usecs = MS(10);;) {
 185                 /* Try and acquire the uncontested resource lock for N spins. */
 186                 for (nspins = mp->spins; nspins > 0; --nspins)
 187                         if (TSL_SET(&mp->tsl_resource)) {
 188 #ifdef DIAGNOSTIC
 189                                 if (mp->pid != 0) {
 190                                         (void)fprintf(stderr,
 191                     "MUTEX ERROR: __db_mutex_lock: lock currently locked\n");
 192                                         abort();
 193                                 }
 194                                 mp->pid = getpid();
 195 #endif
 196                                 if (usecs == MS(10))
 197                                         ++mp->mutex_set_nowait;
 198                                 else
 199                                         ++mp->mutex_set_wait;
 200                                 return (0);
 201                         }
 202
 203                 /* Yield the processor; wait 10ms initially, up to 1 second. */
 204                 if (__db_yield == NULL || __db_yield() != 0) {
 205                         (void)__db_sleep(0, usecs);
 206                         if ((usecs <<= 1) > SECOND)
 207                                 usecs = SECOND;
 208                 }
 209         }
 210         /* NOTREACHED */
 211
 212 #else /* !HAVE_SPINLOCKS */
 213
 214         /* Initialize the lock. */
 215         k_lock.l_whence = SEEK_SET;
 216         k_lock.l_start = mp->off;
 217         k_lock.l_len = 1;
 218
 219         for (locked = 0, mypid = getpid();;) {
 220                 /*
 221                  * Wait for the lock to become available; wait 10ms initially,
 222                  * up to 1 second.
 223                  */
 224                 for (usecs = MS(10); mp->pid != 0;)
 225                         if (__db_yield == NULL || __db_yield() != 0) {
 226                                 (void)__db_sleep(0, usecs);
 227                                 if ((usecs <<= 1) > SECOND)
 228                                         usecs = SECOND;
 229                         }
 230
 231                 /* Acquire an exclusive kernel lock. */
 232                 k_lock.l_type = F_WRLCK;
 233                 if (fcntl(fd, F_SETLKW, &k_lock))
 234                         return (errno);
 235
 236                 /* If the resource tsl is still available, it's ours. */
 237                 if (mp->pid == 0) {
 238                         locked = 1;
 239                         mp->pid = mypid;
 240                 }
 241
 242                 /* Release the kernel lock. */
 243                 k_lock.l_type = F_UNLCK;
 244                 if (fcntl(fd, F_SETLK, &k_lock))
 245                         return (errno);
 246
 247                 /*
 248                  * If we got the resource tsl we're done.
 249                  *
 250                  * !!!
 251                  * We can't check to see if the lock is ours, because we may
 252                  * be trying to block ourselves in the lock manager, and so
 253                  * the holder of the lock that's preventing us from getting
 254                  * the lock may be us!  (Seriously.)
 255                  */
 256                 if (locked)
 257                         break;
 258         }
 259         return (0);
 260 #endif /* !HAVE_SPINLOCKS */
 261 }
 262
 263 /*
 264  * __db_mutex_unlock --
 265  *      Release a lock.
 266  *
 267  * PUBLIC: int __db_mutex_unlock __P((db_mutex_t *, int));
 268  */
 269 int
 270 __db_mutex_unlock(mp, fd)
 271         db_mutex_t *mp;
 272         int fd;
 273 {
 274         if (!DB_GLOBAL(db_mutexlocks))
 275                 return (0);
 276
 277 #ifdef DIAGNOSTIC
 278         if (mp->pid == 0) {
 279                 (void)fprintf(stderr,
 280             "MUTEX ERROR: __db_mutex_unlock: lock already unlocked\n");
 281                 abort();
 282         }
 283 #endif
 284
 285 #ifdef HAVE_SPINLOCKS
 286         COMPQUIET(fd, 0);
 287
 288 #ifdef DIAGNOSTIC
 289         mp->pid = 0;
 290 #endif
 291
 292         /* Release the resource tsl. */
 293         TSL_UNSET(&mp->tsl_resource);
 294 #else
 295         /*
 296          * Release the resource tsl.  We don't have to acquire any locks
 297          * because processes trying to acquire the lock are checking for
 298          * a pid of 0, not a specific value.
 299          */
 300         mp->pid = 0;
 301 #endif
 302         return (0);
 303 }