mut_tas.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:5k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  8. #ifndef lint
  9. static const char revid[] = "$Id: mut_tas.c,v 11.32 2002/05/07 18:42:21 bostic Exp $";
  10. #endif /* not lint */
  11. #ifndef NO_SYSTEM_INCLUDES
  12. #include <sys/types.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include <unistd.h>
  16. #endif
  17. /*
  18.  * This is where we load in the actual test-and-set mutex code.
  19.  */
  20. #define LOAD_ACTUAL_MUTEX_CODE
  21. #include "db_int.h"
  22. /*
  23.  * __db_tas_mutex_init --
  24.  * Initialize a DB_MUTEX.
  25.  *
  26.  * PUBLIC: int __db_tas_mutex_init __P((DB_ENV *, DB_MUTEX *, u_int32_t));
  27.  */
  28. int
  29. __db_tas_mutex_init(dbenv, mutexp, flags)
  30. DB_ENV *dbenv;
  31. DB_MUTEX *mutexp;
  32. u_int32_t flags;
  33. {
  34. u_int32_t save;
  35. /* Check alignment. */
  36. DB_ASSERT(((db_alignp_t)mutexp & (MUTEX_ALIGN - 1)) == 0);
  37. /*
  38.  * The only setting/checking of the MUTEX_MPOOL flags is in the mutex
  39.  * mutex allocation code (__db_mutex_alloc/free).  Preserve only that
  40.  * flag.  This is safe because even if this flag was never explicitly
  41.  * set, but happened to be set in memory, it will never be checked or
  42.  * acted upon.
  43.  */
  44. save = F_ISSET(mutexp, MUTEX_MPOOL);
  45. memset(mutexp, 0, sizeof(*mutexp));
  46. F_SET(mutexp, save);
  47. /*
  48.  * If this is a thread lock or the process has told us that there are
  49.  * no other processes in the environment, use thread-only locks, they
  50.  * are faster in some cases.
  51.  *
  52.  * This is where we decide to ignore locks we don't need to set -- if
  53.  * the application isn't threaded, there aren't any threads to block.
  54.  */
  55. if (LF_ISSET(MUTEX_THREAD) || F_ISSET(dbenv, DB_ENV_PRIVATE)) {
  56. if (!F_ISSET(dbenv, DB_ENV_THREAD)) {
  57. F_SET(mutexp, MUTEX_IGNORE);
  58. return (0);
  59. }
  60. }
  61. /* Initialize the lock. */
  62. if (MUTEX_INIT(&mutexp->tas))
  63. return (__os_get_errno());
  64. mutexp->spins = __os_spin(dbenv);
  65. #ifdef HAVE_MUTEX_SYSTEM_RESOURCES
  66. mutexp->reg_off = INVALID_ROFF;
  67. #endif
  68. F_SET(mutexp, MUTEX_INITED);
  69. return (0);
  70. }
  71. /*
  72.  * __db_tas_mutex_lock
  73.  * Lock on a mutex, logically blocking if necessary.
  74.  *
  75.  * PUBLIC: int __db_tas_mutex_lock __P((DB_ENV *, DB_MUTEX *));
  76.  */
  77. int
  78. __db_tas_mutex_lock(dbenv, mutexp)
  79. DB_ENV *dbenv;
  80. DB_MUTEX *mutexp;
  81. {
  82. u_long ms;
  83. int nspins;
  84. if (F_ISSET(dbenv, DB_ENV_NOLOCKING) || F_ISSET(mutexp, MUTEX_IGNORE))
  85. return (0);
  86. ms = 1;
  87. loop: /* Attempt to acquire the resource for N spins. */
  88. for (nspins = mutexp->spins; nspins > 0; --nspins) {
  89. #ifdef HAVE_MUTEX_HPPA_MSEM_INIT
  90. relock:
  91. #endif
  92. if (!MUTEX_SET(&mutexp->tas))
  93. continue;
  94. #ifdef HAVE_MUTEX_HPPA_MSEM_INIT
  95. /*
  96.  * HP semaphores are unlocked automatically when a holding
  97.  * process exits.  If the mutex appears to be locked
  98.  * (mutexp->locked != 0) but we got here, assume this has
  99.  * happened.  Stick our own pid into mutexp->locked and
  100.  * lock again.  (The default state of the mutexes used to
  101.  * block in __lock_get_internal is locked, so exiting with
  102.  * a locked mutex is reasonable behavior for a process that
  103.  * happened to initialize or use one of them.)
  104.  */
  105. if (mutexp->locked != 0) {
  106. __os_id(&mutexp->locked);
  107. goto relock;
  108. }
  109. /*
  110.  * If we make it here, locked == 0, the diagnostic won't fire,
  111.  * and we were really unlocked by someone calling the
  112.  * DB mutex unlock function.
  113.  */
  114. #endif
  115. #ifdef DIAGNOSTIC
  116. if (mutexp->locked != 0)
  117. __db_err(dbenv,
  118. "__db_tas_mutex_lock: ERROR: lock currently in use: ID: %lu",
  119.     (u_long)mutexp->locked);
  120. #endif
  121. #if defined(DIAGNOSTIC) || defined(HAVE_MUTEX_HPPA_MSEM_INIT)
  122. __os_id(&mutexp->locked);
  123. #endif
  124. if (ms == 1)
  125. ++mutexp->mutex_set_nowait;
  126. else
  127. ++mutexp->mutex_set_wait;
  128. return (0);
  129. }
  130. /* Yield the processor; wait 1ms initially, up to 1 second. */
  131. __os_yield(NULL, ms * USEC_PER_MS);
  132. if ((ms <<= 1) > MS_PER_SEC)
  133. ms = MS_PER_SEC;
  134. goto loop;
  135. }
  136. /*
  137.  * __db_tas_mutex_unlock --
  138.  * Release a lock.
  139.  *
  140.  * PUBLIC: int __db_tas_mutex_unlock __P((DB_ENV *, DB_MUTEX *));
  141.  */
  142. int
  143. __db_tas_mutex_unlock(dbenv, mutexp)
  144. DB_ENV *dbenv;
  145. DB_MUTEX *mutexp;
  146. {
  147. if (F_ISSET(dbenv, DB_ENV_NOLOCKING) || F_ISSET(mutexp, MUTEX_IGNORE))
  148. return (0);
  149. #ifdef DIAGNOSTIC
  150. if (!mutexp->locked)
  151. __db_err(dbenv,
  152.     "__db_tas_mutex_unlock: ERROR: lock already unlocked");
  153. #endif
  154. #if defined(DIAGNOSTIC) || defined(HAVE_MUTEX_HPPA_MSEM_INIT)
  155. mutexp->locked = 0;
  156. #endif
  157. MUTEX_UNSET(&mutexp->tas);
  158. return (0);
  159. }
  160. /*
  161.  * __db_tas_mutex_destroy --
  162.  * Destroy a DB_MUTEX.
  163.  *
  164.  * PUBLIC: int __db_tas_mutex_destroy __P((DB_MUTEX *));
  165.  */
  166. int
  167. __db_tas_mutex_destroy(mutexp)
  168. DB_MUTEX *mutexp;
  169. {
  170. if (F_ISSET(mutexp, MUTEX_IGNORE))
  171. return (0);
  172. MUTEX_DESTROY(&mutexp->tas);
  173. return (0);
  174. }