开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
mutex.h
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：28k
源码类别：

MySQL数据库

开发平台：

Visual C++

mutex.h：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  *
  7.  * $Id: mutex.h,v 11.71 2002/09/10 01:36:48 bostic Exp $
  8.  */
  10. #ifndef _DB_MUTEX_H_
  11. #define _DB_MUTEX_H_
  13. /*
  14.  * Some of the Berkeley DB ports require single-threading at various
  15.  * places in the code.  In those cases, these #defines will be set.
  16.  */
  17. #define DB_BEGIN_SINGLE_THREAD
  18. #define DB_END_SINGLE_THREAD
  20. /*********************************************************************
  21.  * POSIX.1 pthreads interface.
  22.  *********************************************************************/
  23. #ifdef HAVE_MUTEX_PTHREADS
  24. #include <pthread.h>
  26. #define MUTEX_FIELDS
  27. pthread_mutex_t mutex; /* Mutex. */
  28. pthread_cond_t  cond; /* Condition variable. */
  29. #endif
  31. /*********************************************************************
  32.  * Solaris lwp threads interface.
  33.  *
  34.  * !!!
  35.  * We use LWP mutexes on Solaris instead of UI or POSIX mutexes (both of
  36.  * which are available), for two reasons.  First, the Solaris C library
  37.  * includes versions of the both UI and POSIX thread mutex interfaces, but
  38.  * they are broken in that they don't support inter-process locking, and
  39.  * there's no way to detect it, e.g., calls to configure the mutexes for
  40.  * inter-process locking succeed without error.  So, we use LWP mutexes so
  41.  * that we don't fail in fairly undetectable ways because the application
  42.  * wasn't linked with the appropriate threads library.  Second, there were
  43.  * bugs in SunOS 5.7 (Solaris 7) where if an application loaded the C library
  44.  * before loading the libthread/libpthread threads libraries (e.g., by using
  45.  * dlopen to load the DB library), the pwrite64 interface would be translated
  46.  * into a call to pwrite and DB would drop core.
  47.  *********************************************************************/
  48. #ifdef HAVE_MUTEX_SOLARIS_LWP
  49. /*
  50.  * XXX
  51.  * Don't change <synch.h> to <sys/lwp.h> -- although lwp.h is listed in the
  52.  * Solaris manual page as the correct include to use, it causes the Solaris
  53.  * compiler on SunOS 2.6 to fail.
  54.  */
  55. #include <synch.h>
  57. #define MUTEX_FIELDS
  58. lwp_mutex_t mutex; /* Mutex. */
  59. lwp_cond_t cond; /* Condition variable. */
  60. #endif
  62. /*********************************************************************
  63.  * Solaris/Unixware threads interface.
  64.  *********************************************************************/
  65. #ifdef HAVE_MUTEX_UI_THREADS
  66. #include <thread.h>
  67. #include <synch.h>
  69. #define MUTEX_FIELDS
  70. mutex_t mutex; /* Mutex. */
  71. cond_t  cond; /* Condition variable. */
  72. #endif
  74. /*********************************************************************
  75.  * AIX C library functions.
  76.  *********************************************************************/
  77. #ifdef HAVE_MUTEX_AIX_CHECK_LOCK
  78. #include <sys/atomic_op.h>
  79. typedef int tsl_t;
  80. #define MUTEX_ALIGN sizeof(int)
  82. #ifdef LOAD_ACTUAL_MUTEX_CODE
  83. #define MUTEX_INIT(x) 0
  84. #define MUTEX_SET(x) (!_check_lock(x, 0, 1))
  85. #define MUTEX_UNSET(x) _clear_lock(x, 0)
  86. #endif
  87. #endif
  89. /*********************************************************************
  90.  * General C library functions (msemaphore).
  91.  *
  92.  * !!!
  93.  * Check for HPPA as a special case, because it requires unusual alignment,
  94.  * and doesn't support semaphores in malloc(3) or shmget(2) memory.
  95.  *
  96.  * !!!
  97.  * Do not remove the MSEM_IF_NOWAIT flag.  The problem is that if a single
  98.  * process makes two msem_lock() calls in a row, the second one returns an
  99.  * error.  We depend on the fact that we can lock against ourselves in the
  100.  * locking subsystem, where we set up a mutex so that we can block ourselves.
  101.  * Tested on OSF1 v4.0.
  102.  *********************************************************************/
  103. #ifdef HAVE_MUTEX_HPPA_MSEM_INIT
  104. #define MUTEX_NO_MALLOC_LOCKS
  105. #define MUTEX_NO_SHMGET_LOCKS
  107. #define MUTEX_ALIGN 16
  108. #endif
  110. #if defined(HAVE_MUTEX_MSEM_INIT) || defined(HAVE_MUTEX_HPPA_MSEM_INIT)
  111. #include <sys/mman.h>
  112. typedef msemaphore tsl_t;
  114. #ifndef MUTEX_ALIGN
  115. #define MUTEX_ALIGN sizeof(int)
  116. #endif
  118. #ifdef LOAD_ACTUAL_MUTEX_CODE
  119. #define MUTEX_INIT(x) (msem_init(x, MSEM_UNLOCKED) <= (msemaphore *)0)
  120. #define MUTEX_SET(x) (!msem_lock(x, MSEM_IF_NOWAIT))
  121. #define MUTEX_UNSET(x) msem_unlock(x, 0)
  122. #endif
  123. #endif
  125. /*********************************************************************
  126.  * Plan 9 library functions.
  127.  *********************************************************************/
  128. #ifdef HAVE_MUTEX_PLAN9
  129. typedef Lock tsl_t;
  131. #define MUTEX_ALIGN sizeof(int)
  133. #define MUTEX_INIT(x) (memset(x, 0, sizeof(Lock)), 0)
  134. #define MUTEX_SET(x) canlock(x)
  135. #define MUTEX_UNSET(x) unlock(x)
  136. #endif
  138. /*********************************************************************
  139.  * Reliant UNIX C library functions.
  140.  *********************************************************************/
  141. #ifdef HAVE_MUTEX_RELIANTUNIX_INITSPIN
  142. #include <ulocks.h>
  143. typedef spinlock_t tsl_t;
  145. #ifdef LOAD_ACTUAL_MUTEX_CODE
  146. #define MUTEX_INIT(x) (initspin(x, 1), 0)
  147. #define MUTEX_SET(x) (cspinlock(x) == 0)
  148. #define MUTEX_UNSET(x) spinunlock(x)
  149. #endif
  150. #endif
  152. /*********************************************************************
  153.  * General C library functions (POSIX 1003.1 sema_XXX).
  154.  *
  155.  * !!!
  156.  * Never selected by autoconfig in this release (semaphore calls are known
  157.  * to not work in Solaris 5.5).
  158.  *********************************************************************/
  159. #ifdef HAVE_MUTEX_SEMA_INIT
  160. #include <synch.h>
  161. typedef sema_t tsl_t;
  162. #define MUTEX_ALIGN  sizeof(int)
  164. #ifdef LOAD_ACTUAL_MUTEX_CODE
  165. #define MUTEX_DESTROY(x) sema_destroy(x)
  166. #define MUTEX_INIT(x)  (sema_init(x, 1, USYNC_PROCESS, NULL) != 0)
  167. #define MUTEX_SET(x)  (sema_wait(x) == 0)
  168. #define MUTEX_UNSET(x)  sema_post(x)
  169. #endif
  170. #endif
  172. /*********************************************************************
  173.  * SGI C library functions.
  174.  *********************************************************************/
  175. #ifdef HAVE_MUTEX_SGI_INIT_LOCK
  176. #include <abi_mutex.h>
  177. typedef abilock_t tsl_t;
  178. #define MUTEX_ALIGN sizeof(int)
  180. #ifdef LOAD_ACTUAL_MUTEX_CODE
  181. #define MUTEX_INIT(x) (init_lock(x) != 0)
  182. #define MUTEX_SET(x) (!acquire_lock(x))
  183. #define MUTEX_UNSET(x) release_lock(x)
  184. #endif
  185. #endif
  187. /*********************************************************************
  188.  * Solaris C library functions.
  189.  *
  190.  * !!!
  191.  * These are undocumented functions, but they're the only ones that work
  192.  * correctly as far as we know.
  193.  *********************************************************************/
  194. #ifdef HAVE_MUTEX_SOLARIS_LOCK_TRY
  195. #include <sys/machlock.h>
  196. typedef lock_t tsl_t;
  197. #define MUTEX_ALIGN sizeof(int)
  199. #ifdef LOAD_ACTUAL_MUTEX_CODE
  200. #define MUTEX_INIT(x) 0
  201. #define MUTEX_SET(x) _lock_try(x)
  202. #define MUTEX_UNSET(x) _lock_clear(x)
  203. #endif
  204. #endif
  206. /*********************************************************************
  207.  * VMS.
  208.  *********************************************************************/
  209. #ifdef HAVE_MUTEX_VMS
  210. #include <sys/mman.h>;
  211. #include <builtins.h>
  212. typedef unsigned char tsl_t;
  213. #define MUTEX_ALIGN sizeof(unsigned int)
  215. #ifdef LOAD_ACTUAL_MUTEX_CODE
  216. #ifdef __ALPHA
  217. #define MUTEX_SET(tsl) (!__TESTBITSSI(tsl, 0))
  218. #else /* __VAX */
  219. #define MUTEX_SET(tsl) (!(int)_BBSSI(0, tsl))
  220. #endif
  221. #define MUTEX_UNSET(tsl) (*(tsl) = 0)
  222. #define MUTEX_INIT(tsl) MUTEX_UNSET(tsl)
  223. #endif
  224. #endif
  226. /*********************************************************************
  227.  * VxWorks
  228.  * Use basic binary semaphores in VxWorks, as we currently do not need
  229.  * any special features.  We do need the ability to single-thread the
  230.  * entire system, however, because VxWorks doesn't support the open(2)
  231.  * flag O_EXCL, the mechanism we normally use to single thread access
  232.  * when we're first looking for a DB environment.
  233.  *********************************************************************/
  234. #ifdef HAVE_MUTEX_VXWORKS
  235. #include "taskLib.h"
  236. typedef SEM_ID tsl_t;
  237. #define MUTEX_ALIGN sizeof(unsigned int)
  239. #ifdef LOAD_ACTUAL_MUTEX_CODE
  240. #define MUTEX_SET(tsl) (semTake((*tsl), WAIT_FOREVER) == OK)
  241. #define MUTEX_UNSET(tsl) (semGive((*tsl)))
  242. #define MUTEX_INIT(tsl)
  243. ((*(tsl) = semBCreate(SEM_Q_FIFO, SEM_FULL)) == NULL)
  244. #define MUTEX_DESTROY(tsl) semDelete(*tsl)
  245. #endif
  247. /*
  248.  * Use the taskLock() mutex to eliminate a race where two tasks are
  249.  * trying to initialize the global lock at the same time.
  250.  */
  251. #undef DB_BEGIN_SINGLE_THREAD
  252. #define DB_BEGIN_SINGLE_THREAD
  253. do {
  254. if (DB_GLOBAL(db_global_init))
  255. (void)semTake(DB_GLOBAL(db_global_lock), WAIT_FOREVER);
  256. else {
  257. taskLock();
  258. if (DB_GLOBAL(db_global_init)) {
  259. taskUnlock();
  260. (void)semTake(DB_GLOBAL(db_global_lock),
  261.     WAIT_FOREVER);
  262. continue;
  263. }
  264. DB_GLOBAL(db_global_lock) =
  265.     semBCreate(SEM_Q_FIFO, SEM_EMPTY);
  266. if (DB_GLOBAL(db_global_lock) != NULL)
  267. DB_GLOBAL(db_global_init) = 1;
  268. taskUnlock();
  269. }
  270. } while (DB_GLOBAL(db_global_init) == 0)
  271. #undef DB_END_SINGLE_THREAD
  272. #define DB_END_SINGLE_THREAD (void)semGive(DB_GLOBAL(db_global_lock))
  273. #endif
  275. /*********************************************************************
  276.  * Win16
  277.  *
  278.  * Win16 spinlocks are simple because we cannot possibly be preempted.
  279.  *
  280.  * !!!
  281.  * We should simplify this by always returning a no-need-to-lock lock
  282.  * when we initialize the mutex.
  283.  *********************************************************************/
  284. #ifdef HAVE_MUTEX_WIN16
  285. typedef unsigned int tsl_t;
  286. #define MUTEX_ALIGN sizeof(unsigned int)
  288. #ifdef LOAD_ACTUAL_MUTEX_CODE
  289. #define MUTEX_INIT(x) 0
  290. #define MUTEX_SET(tsl) (*(tsl) = 1)
  291. #define MUTEX_UNSET(tsl) (*(tsl) = 0)
  292. #endif
  293. #endif
  295. /*********************************************************************
  296.  * Win32
  297.  *********************************************************************/
  298. #ifdef HAVE_MUTEX_WIN32
  299. #define MUTEX_FIELDS
  300. LONG tas;
  301. LONG nwaiters;
  302. union {
  303. HANDLE event; /* Windows event HANDLE for wakeups */
  304. u_int32_t id; /* ID used for shared mutexes */
  305. } /* anonymous */;
  307. #if defined(LOAD_ACTUAL_MUTEX_CODE)
  308. #define MUTEX_SET(tsl) (!InterlockedExchange((PLONG)tsl, 1))
  309. #define MUTEX_UNSET(tsl) (*(tsl) = 0)
  310. #define MUTEX_INIT(tsl) MUTEX_UNSET(tsl)
  311. #endif
  312. #endif
  314. /*********************************************************************
  315.  * 68K/gcc assembly.
  316.  *********************************************************************/
  317. #ifdef HAVE_MUTEX_68K_GCC_ASSEMBLY
  318. typedef unsigned char tsl_t;
  320. #ifdef LOAD_ACTUAL_MUTEX_CODE
  321. /*
  322.  * For gcc/68K, 0 is clear, 1 is set.
  323.  */
  324. #define MUTEX_SET(tsl) ({
  325. register tsl_t *__l = (tsl);
  326. int __r;
  327.     asm volatile("tas  %1; n
  328.   seq  %0"
  329. : "=dm" (__r), "=m" (*__l)
  330. : "1" (*__l)
  331. );
  332. __r & 1;
  333. })
  335. #define MUTEX_UNSET(tsl) (*(tsl) = 0)
  336. #define MUTEX_INIT(tsl) MUTEX_UNSET(tsl)
  337. #endif
  338. #endif
  340. /*********************************************************************
  341.  * ALPHA/gcc assembly.
  342.  *********************************************************************/
  343. #ifdef HAVE_MUTEX_ALPHA_GCC_ASSEMBLY
  344. typedef u_int32_t tsl_t;
  345. #define MUTEX_ALIGN 4
  347. #ifdef LOAD_ACTUAL_MUTEX_CODE
  348. /*
  349.  * For gcc/alpha.  Should return 0 if could not acquire the lock, 1 if
  350.  * lock was acquired properly.
  351.  */
  352. #ifdef __GNUC__
  353. static inline int
  354. MUTEX_SET(tsl_t *tsl) {
  355. register tsl_t *__l = tsl;
  356. register tsl_t __r;
  357. asm volatile(
  358. "1: ldl_l %0,%2n"
  359. " blbs %0,2fn"
  360. " or $31,1,%0n"
  361. " stl_c %0,%1n"
  362. " beq %0,3fn"
  363. " mbn"
  364. " br 3fn"
  365. "2: xor %0,%0n"
  366. "3:"
  367. : "=&r"(__r), "=m"(*__l) : "1"(*__l) : "memory");
  368. return __r;
  369. }
  371. /*
  372.  * Unset mutex. Judging by Alpha Architecture Handbook, the mb instruction
  373.  * might be necessary before unlocking
  374.  */
  375. static inline int
  376. MUTEX_UNSET(tsl_t *tsl) {
  377. asm volatile(" mbn");
  378. return *tsl = 0;
  379. }
  380. #endif
  382. #ifdef __DECC
  383. #include <alpha/builtins.h>
  384. #define MUTEX_SET(tsl) (__LOCK_LONG_RETRY((tsl), 1) != 0)
  385. #define MUTEX_UNSET(tsl) (*(tsl) = 0)
  386. #endif
  388. #define MUTEX_INIT(tsl) MUTEX_UNSET(tsl)
  389. #endif
  390. #endif
  392. /*********************************************************************
  393.  * ARM/gcc assembly.
  394.  *********************************************************************/
  395. #ifdef HAVE_MUTEX_ARM_GCC_ASSEMBLY
  396. typedef unsigned char tsl_t;
  398. #ifdef LOAD_ACTUAL_MUTEX_CODE
  399. /*
  400.  * For arm/gcc, 0 is clear, 1 is set.
  401.  */
  402. #define MUTEX_SET(tsl) ({
  403. int __r;
  404. asm volatile("swpb %0, %1, [%2]"
  405.     : "=r" (__r) 
  406.     : "0" (1), "r" (tsl)
  407.     : "memory"
  408.     );
  409. __r & 1;
  410. })
  412. #define MUTEX_UNSET(tsl) (*(volatile tsl_t *)(tsl) = 0)
  413. #define MUTEX_INIT(tsl) MUTEX_UNSET(tsl)
  414. #endif
  415. #endif
  417. /*********************************************************************
  418.  * HPPA/gcc assembly.
  419.  *********************************************************************/
  420. #ifdef HAVE_MUTEX_HPPA_GCC_ASSEMBLY
  421. typedef u_int32_t tsl_t;
  422. #define MUTEX_ALIGN 16
  424. #ifdef LOAD_ACTUAL_MUTEX_CODE
  425. /*
  426.  * The PA-RISC has a "load and clear" instead of a "test and set" instruction.
  427.  * The 32-bit word used by that instruction must be 16-byte aligned.  We could
  428.  * use the "aligned" attribute in GCC but that doesn't work for stack variables.
  429.  */
  430. #define MUTEX_SET(tsl) ({
  431. register tsl_t *__l = (tsl);
  432. int __r;
  433. asm volatile("ldcws 0(%1),%0" : "=r" (__r) : "r" (__l));
  434. __r & 1;
  435. })
  437. #define MUTEX_UNSET(tsl) (*(tsl) = -1)
  438. #define MUTEX_INIT(tsl) (MUTEX_UNSET(tsl), 0)
  439. #endif
  440. #endif
  442. /*********************************************************************
  443.  * IA64/gcc assembly.
  444.  *********************************************************************/
  445. #ifdef HAVE_MUTEX_IA64_GCC_ASSEMBLY
  446. typedef unsigned char tsl_t;
  448. #ifdef LOAD_ACTUAL_MUTEX_CODE
  449. /*
  450.  * For gcc/ia64, 0 is clear, 1 is set.
  451.  */
  452. #define MUTEX_SET(tsl) ({
  453. register tsl_t *__l = (tsl);
  454. long __r;
  455. asm volatile("xchg1 %0=%1,%3" : "=r"(__r), "=m"(*__l) : "1"(*__l), "r"(1));
  456. __r ^ 1;
  457. })
  459. /*
  460.  * Store through a "volatile" pointer so we get a store with "release"
  461.  * semantics.
  462.  */
  463. #define MUTEX_UNSET(tsl) (*(volatile unsigned char *)(tsl) = 0)
  464. #define MUTEX_INIT(tsl) MUTEX_UNSET(tsl)
  465. #endif
  466. #endif
  468. /*********************************************************************
  469.  * PowerPC/gcc assembly.
  470.  *********************************************************************/
  471. #if defined(HAVE_MUTEX_PPC_GENERIC_GCC_ASSEMBLY) ||
  472.     (HAVE_MUTEX_PPC_APPLE_GCC_ASSEMBLY)
  473. typedef u_int32_t tsl_t;
  475. #ifdef LOAD_ACTUAL_MUTEX_CODE
  476. /*
  477.  * The PowerPC does a sort of pseudo-atomic locking.  You set up a
  478.  * 'reservation' on a chunk of memory containing a mutex by loading the
  479.  * mutex value with LWARX.  If the mutex has an 'unlocked' (arbitrary)
  480.  * value, you then try storing into it with STWCX.  If no other process or
  481.  * thread broke your 'reservation' by modifying the memory containing the
  482.  * mutex, then the STCWX succeeds; otherwise it fails and you try to get
  483.  * a reservation again.
  484.  *
  485.  * While mutexes are explicitly 4 bytes, a 'reservation' applies to an
  486.  * entire cache line, normally 32 bytes, aligned naturally.  If the mutex
  487.  * lives near data that gets changed a lot, there's a chance that you'll
  488.  * see more broken reservations than you might otherwise.  The only
  489.  * situation in which this might be a problem is if one processor is
  490.  * beating on a variable in the same cache block as the mutex while another
  491.  * processor tries to acquire the mutex.  That's bad news regardless
  492.  * because of the way it bashes caches, but if you can't guarantee that a
  493.  * mutex will reside in a relatively quiescent cache line, you might
  494.  * consider padding the mutex to force it to live in a cache line by
  495.  * itself.  No, you aren't guaranteed that cache lines are 32 bytes.  Some
  496.  * embedded processors use 16-byte cache lines, while some 64-bit
  497.  * processors use 128-bit cache lines.  But assuming a 32-byte cache line
  498.  * won't get you into trouble for now.
  499.  *
  500.  * If mutex locking is a bottleneck, then you can speed it up by adding a
  501.  * regular LWZ load before the LWARX load, so that you can test for the
  502.  * common case of a locked mutex without wasting cycles making a reservation.
  503.  *
  504.  * 'set' mutexes have the value 1, like on Intel; the returned value from
  505.  * MUTEX_SET() is 1 if the mutex previously had its low bit clear, 0 otherwise.
  506.  *
  507.  * Mutexes on Mac OS X work the same way as the standard PowerPC version, but
  508.  * the assembler syntax is subtly different -- the standard PowerPC version
  509.  * assembles but doesn't work correctly.  This version makes (unnecessary?)
  510.  * use of a stupid linker trick: __db_mutex_tas_dummy is never called, but the
  511.  * ___db_mutex_set label is used as a function name.
  512.  */
  513. #ifdef HAVE_MUTEX_PPC_APPLE_GCC_ASSEMBLY
  514. extern int __db_mutex_set __P((volatile tsl_t *));
  515. void
  516. __db_mutex_tas_dummy()
  517. {
  518. __asm__ __volatile__(" n
  519. .globl  ___db_mutex_set n
  520. ___db_mutex_set: n
  521. lwarx r5,0,r3 n
  522. cmpwi  r5,0 n
  523. bne  fail n
  524. addi  r5,r5,1 n
  525. stwcx.  r5,0,r3 n
  526. beq  success n
  527. fail: n
  528. li  r3,0 n
  529. blr  n
  530. success: n
  531. li  r3,1 n
  532. blr");
  533. }
  534. #define MUTEX_SET(tsl)  __db_mutex_set(tsl)
  535. #endif
  536. #ifdef HAVE_MUTEX_PPC_GENERIC_GCC_ASSEMBLY
  537. #define MUTEX_SET(tsl) ({
  538. int __one = 1;
  539. int __r;
  540. tsl_t *__l = (tsl);
  541. asm volatile ("
  542. 0:
  543. lwarx %0,0,%1;
  544. cmpwi %0,0;
  545. bne 1f;
  546. stwcx. %2,0,%1;
  547. bne- 0b;
  548. 1:"
  549. : "=&r" (__r)
  550. : "r" (__l), "r" (__one));
  551. !(__r & 1);
  552. })
  553. #endif
  554. #define MUTEX_UNSET(tsl) (*(tsl) = 0)
  555. #define MUTEX_INIT(tsl) MUTEX_UNSET(tsl)
  556. #endif
  557. #endif
  559. /*********************************************************************
  560.  * S/390 32-bit assembly.
  561.  *********************************************************************/
  562. #ifdef HAVE_MUTEX_S390_GCC_ASSEMBLY
  563. typedef int tsl_t;
  565. #ifdef LOAD_ACTUAL_MUTEX_CODE
  566. /*
  567.  * For gcc/S390, 0 is clear, 1 is set.
  568.  */
  569. static inline int
  570. MUTEX_SET(tsl_t *tsl) {
  571. register tsl_t *__l = (tsl);
  572. int __r;
  573.   asm volatile(
  574.        "    la    1,%1n"
  575.        "    lhi   0,1n"
  576.        "    l     %0,%1n"
  577.        "0:  cs    %0,0,0(1)n"
  578.        "    jl    0b"
  579.        : "=&d" (__r), "+m" (*__l)
  580.        : : "0", "1", "cc");
  581. return !__r;
  582. }
  584. #define MUTEX_UNSET(tsl) (*(tsl) = 0)
  585. #define MUTEX_INIT(tsl) MUTEX_UNSET(tsl)
  586. #endif
  587. #endif
  589. /*********************************************************************
  590.  * SCO/cc assembly.
  591.  *********************************************************************/
  592. #ifdef HAVE_MUTEX_SCO_X86_CC_ASSEMBLY
  593. typedef unsigned char tsl_t;
  595. #ifdef LOAD_ACTUAL_MUTEX_CODE
  596. /*
  597.  * UnixWare has threads in libthread, but OpenServer doesn't (yet).
  598.  *
  599.  * For cc/x86, 0 is clear, 1 is set.
  600.  */
  602. #if defined(__USLC__)
  603. asm int
  604. _tsl_set(void *tsl)
  605. {
  606. %mem tsl
  607. movl tsl, %ecx
  608. movl $1, %eax
  609. lock
  610. xchgb (%ecx),%al
  611. xorl $1,%eax
  612. }
  613. #endif
  615. #define MUTEX_SET(tsl) _tsl_set(tsl)
  616. #define MUTEX_UNSET(tsl) (*(tsl) = 0)
  617. #define MUTEX_INIT(tsl) MUTEX_UNSET(tsl)
  618. #endif
  619. #endif
  621. /*********************************************************************
  622.  * Sparc/gcc assembly.
  623.  *********************************************************************/
  624. #ifdef HAVE_MUTEX_SPARC_GCC_ASSEMBLY
  625. typedef unsigned char tsl_t;
  627. #ifdef LOAD_ACTUAL_MUTEX_CODE
  628. /*
  629.  *
  630.  * The ldstub instruction takes the location specified by its first argument
  631.  * (a register containing a memory address) and loads its contents into its
  632.  * second argument (a register) and atomically sets the contents the location
  633.  * specified by its first argument to a byte of 1s.  (The value in the second
  634.  * argument is never read, but only overwritten.)
  635.  *
  636.  * The stbar is needed for v8, and is implemented as membar #sync on v9,
  637.  * so is functional there as well.  For v7, stbar may generate an illegal
  638.  * instruction and we have no way to tell what we're running on.  Some
  639.  * operating systems notice and skip this instruction in the fault handler.
  640.  *
  641.  * For gcc/sparc, 0 is clear, 1 is set.
  642.  */
  643. #define MUTEX_SET(tsl) ({
  644. register tsl_t *__l = (tsl);
  645. register tsl_t __r;
  646. __asm__ volatile
  647.     ("ldstub [%1],%0; stbar"
  648.     : "=r"( __r) : "r" (__l));
  649. !__r;
  650. })
  652. #define MUTEX_UNSET(tsl) (*(tsl) = 0)
  653. #define MUTEX_INIT(tsl) MUTEX_UNSET(tsl)
  654. #endif
  655. #endif
  657. /*********************************************************************
  658.  * UTS/cc assembly.
  659.  *********************************************************************/
  660. #ifdef HAVE_MUTEX_UTS_CC_ASSEMBLY
  661. typedef int tsl_t;
  663. #define MUTEX_ALIGN sizeof(int)
  664. #ifdef LOAD_ACTUAL_MUTEX_CODE
  665. #define MUTEX_INIT(x) 0
  666. #define MUTEX_SET(x) (!uts_lock(x, 1))
  667. #define MUTEX_UNSET(x) (*(x) = 0)
  668. #endif
  669. #endif
  671. /*********************************************************************
  672.  * x86/gcc assembly.
  673.  *********************************************************************/
  674. #ifdef HAVE_MUTEX_X86_GCC_ASSEMBLY
  675. typedef unsigned char tsl_t;
  677. #ifdef LOAD_ACTUAL_MUTEX_CODE
  678. /*
  679.  * For gcc/x86, 0 is clear, 1 is set.
  680.  */
  681. #define MUTEX_SET(tsl) ({
  682. register tsl_t *__l = (tsl);
  683. int __r;
  684. asm volatile("movl $1,%%eax; lock; xchgb %1,%%al; xorl $1,%%eax"
  685.     : "=&a" (__r), "=m" (*__l)
  686.     : "1" (*__l)
  687.     );
  688. __r & 1;
  689. })
  691. #define MUTEX_UNSET(tsl) (*(tsl) = 0)
  692. #define MUTEX_INIT(tsl) MUTEX_UNSET(tsl)
  693. #endif
  694. #endif
  696. /*
  697.  * Mutex alignment defaults to one byte.
  698.  *
  699.  * !!!
  700.  * Various systems require different alignments for mutexes (the worst we've
  701.  * seen so far is 16-bytes on some HP architectures).  Malloc(3) is assumed
  702.  * to return reasonable alignment, all other mutex users must ensure proper
  703.  * alignment locally.
  704.  */
  705. #ifndef MUTEX_ALIGN
  706. #define MUTEX_ALIGN 1
  707. #endif
  709. /*
  710.  * Mutex destruction defaults to a no-op.
  711.  */
  712. #ifdef LOAD_ACTUAL_MUTEX_CODE
  713. #ifndef MUTEX_DESTROY
  714. #define MUTEX_DESTROY(x)
  715. #endif
  716. #endif
  718. /*
  719.  * !!!
  720.  * These defines are separated into the u_int8_t flags stored in the
  721.  * mutex below, and the 32 bit flags passed to __db_mutex_setup.
  722.  * But they must co-exist and not overlap.  Flags to __db_mutex_setup are:
  723.  *
  724.  * MUTEX_ALLOC - Use when the mutex to initialize needs to be allocated.
  725.  *    The 'ptr' arg to __db_mutex_setup should be a DB_MUTEX ** whenever
  726.  *    you use this flag.  If this flag is not set, the 'ptr' arg is
  727.  *    a DB_MUTEX *.
  728.  * MUTEX_NO_RECORD - Explicitly do not record the mutex in the region.
  729.  *    Otherwise the mutex will be recorded by default.  If you set
  730.  *    this you need to understand why you don't need it recorded.  The
  731.  *    *only* ones not recorded are those that are part of region structures
  732.  *    that only get destroyed when the regions are destroyed.
  733.  * MUTEX_NO_RLOCK - Explicitly do not lock the given region otherwise
  734.  *    the region will be locked by default.
  735.  * MUTEX_SELF_BLOCK - Set if self blocking mutex.
  736.  * MUTEX_THREAD - Set if mutex is a thread-only mutex.
  737.  */
  738. #define MUTEX_IGNORE 0x001 /* Ignore, no lock required. */
  739. #define MUTEX_INITED 0x002 /* Mutex is successfully initialized */
  740. #define MUTEX_MPOOL 0x004 /* Allocated from mpool. */
  741. #define MUTEX_SELF_BLOCK 0x008 /* Must block self. */
  742. /* Flags only, may be larger than 0xff. */
  743. #define MUTEX_ALLOC 0x00000100 /* Allocate and init a mutex */
  744. #define MUTEX_NO_RECORD 0x00000200 /* Do not record lock */
  745. #define MUTEX_NO_RLOCK 0x00000400 /* Do not acquire region lock */
  746. #define MUTEX_THREAD 0x00000800 /* Thread-only mutex. */
  748. /* Mutex. */
  749. struct __mutex_t {
  750. #ifdef HAVE_MUTEX_THREADS
  751. #ifdef MUTEX_FIELDS
  752. MUTEX_FIELDS
  753. #else
  754. tsl_t tas; /* Test and set. */
  755. #endif
  756. u_int32_t spins; /* Spins before block. */
  757. u_int32_t locked; /* !0 if locked. */
  758. #else
  759. u_int32_t off; /* Byte offset to lock. */
  760. u_int32_t pid; /* Lock holder: 0 or process pid. */
  761. #endif
  762. u_int32_t mutex_set_wait; /* Granted after wait. */
  763. u_int32_t mutex_set_nowait; /* Granted without waiting. */
  764. u_int32_t mutex_set_spin; /* Granted without spinning. */
  765. u_int32_t mutex_set_spins; /* Total number of spins. */
  766. #ifdef HAVE_MUTEX_SYSTEM_RESOURCES
  767. roff_t   reg_off; /* Shared lock info offset. */
  768. #endif
  770. u_int8_t  flags; /* MUTEX_XXX */
  771. };
  773. /* Redirect calls to the correct functions. */
  774. #ifdef HAVE_MUTEX_THREADS
  775. #if defined(HAVE_MUTEX_PTHREADS) ||
  776.     defined(HAVE_MUTEX_SOLARIS_LWP) ||
  777.     defined(HAVE_MUTEX_UI_THREADS)
  778. #define __db_mutex_init_int(a, b, c, d) __db_pthread_mutex_init(a, b, d)
  779. #define __db_mutex_lock(a, b) __db_pthread_mutex_lock(a, b)
  780. #define __db_mutex_unlock(a, b) __db_pthread_mutex_unlock(a, b)
  781. #define __db_mutex_destroy(a) __db_pthread_mutex_destroy(a)
  782. #elif defined(HAVE_MUTEX_WIN32)
  783. #define __db_mutex_init_int(a, b, c, d) __db_win32_mutex_init(a, b, d)
  784. #define __db_mutex_lock(a, b) __db_win32_mutex_lock(a, b)
  785. #define __db_mutex_unlock(a, b) __db_win32_mutex_unlock(a, b)
  786. #define __db_mutex_destroy(a) __db_win32_mutex_destroy(a)
  787. #else
  788. #define __db_mutex_init_int(a, b, c, d) __db_tas_mutex_init(a, b, d)
  789. #define __db_mutex_lock(a, b) __db_tas_mutex_lock(a, b)
  790. #define __db_mutex_unlock(a, b) __db_tas_mutex_unlock(a, b)
  791. #define __db_mutex_destroy(a) __db_tas_mutex_destroy(a)
  792. #endif
  793. #else
  794. #define __db_mutex_init_int(a, b, c, d) __db_fcntl_mutex_init(a, b, c)
  795. #define __db_mutex_lock(a, b) __db_fcntl_mutex_lock(a, b)
  796. #define __db_mutex_unlock(a, b) __db_fcntl_mutex_unlock(a, b)
  797. #define __db_mutex_destroy(a) __db_fcntl_mutex_destroy(a)
  798. #endif
  800. /* Redirect system resource calls to correct functions */
  801. #ifdef HAVE_MUTEX_SYSTEM_RESOURCES
  802. #define __db_maintinit(a, b, c) __db_shreg_maintinit(a, b, c)
  803. #define __db_shlocks_clear(a, b, c) __db_shreg_locks_clear(a, b, c)
  804. #define __db_shlocks_destroy(a, b) __db_shreg_locks_destroy(a, b)
  805. #define __db_mutex_init(a, b, c, d, e, f)
  806.     __db_shreg_mutex_init(a, b, c, d, e, f)
  807. #else
  808. #define __db_maintinit(a, b, c)
  809. #define __db_shlocks_clear(a, b, c)
  810. #define __db_shlocks_destroy(a, b)
  811. #define __db_mutex_init(a, b, c, d, e, f) __db_mutex_init_int(a, b, c, d)
  812. #endif
  814. /*
  815.  * Lock/unlock a mutex.  If the mutex was marked as uninteresting, the thread
  816.  * of control can proceed without it.
  817.  *
  818.  * If the lock is for threads-only, then it was optionally not allocated and
  819.  * file handles aren't necessary, as threaded applications aren't supported by
  820.  * fcntl(2) locking.
  821.  */
  822. #ifdef DIAGNOSTIC
  823. /*
  824.  * XXX
  825.  * We want to switch threads as often as possible.  Yield every time
  826.  * we get a mutex to ensure contention.
  827.  */
  828. #define MUTEX_LOCK(dbenv, mp)
  829. if (!F_ISSET((mp), MUTEX_IGNORE))
  830. DB_ASSERT(__db_mutex_lock(dbenv, mp) == 0);
  831. if (F_ISSET(dbenv, DB_ENV_YIELDCPU))
  832. __os_yield(NULL, 1);
  833. #else
  834. #define MUTEX_LOCK(dbenv, mp)
  835. if (!F_ISSET((mp), MUTEX_IGNORE))
  836. (void)__db_mutex_lock(dbenv, mp);
  837. #endif
  838. #define MUTEX_UNLOCK(dbenv, mp)
  839. if (!F_ISSET((mp), MUTEX_IGNORE))
  840. (void)__db_mutex_unlock(dbenv, mp);
  841. #define MUTEX_THREAD_LOCK(dbenv, mp)
  842. if (mp != NULL)
  843. MUTEX_LOCK(dbenv, mp)
  844. #define MUTEX_THREAD_UNLOCK(dbenv, mp)
  845. if (mp != NULL)
  846. MUTEX_UNLOCK(dbenv, mp)
  848. /*
  849.  * We use a single file descriptor for fcntl(2) locking, and (generally) the
  850.  * object's offset in a shared region as the byte that we're locking.  So,
  851.  * there's a (remote) possibility that two objects might have the same offsets
  852.  * such that the locks could conflict, resulting in deadlock.  To avoid this
  853.  * possibility, we offset the region offset by a small integer value, using a
  854.  * different offset for each subsystem's locks.  Since all region objects are
  855.  * suitably aligned, the offset guarantees that we don't collide with another
  856.  * region's objects.
  857.  */
  858. #define DB_FCNTL_OFF_GEN 0 /* Everything else. */
  859. #define DB_FCNTL_OFF_LOCK 1 /* Lock subsystem offset. */
  860. #define DB_FCNTL_OFF_MPOOL 2 /* Mpool subsystem offset. */
  862. #ifdef HAVE_MUTEX_SYSTEM_RESOURCES
  863. /*
  864.  * When the underlying mutexes require library (most likely heap) or system
  865.  * resources, we have to clean up when we discard mutexes (for the library
  866.  * resources) and both when discarding mutexes and after application failure
  867.  * (for the mutexes requiring system resources).  This violates the rule that
  868.  * we never look at a shared region after application failure, but we've no
  869.  * other choice.  In those cases, the #define HAVE_MUTEX_SYSTEM_RESOURCES is
  870.  * set.
  871.  *
  872.  * To support mutex release after application failure, allocate thread-handle
  873.  * mutexes in shared memory instead of in the heap.  The number of slots we
  874.  * allocate for this purpose isn't configurable, but this tends to be an issue
  875.  * only on embedded systems where we don't expect large server applications.
  876.  */
  877. #define DB_MAX_HANDLES 100 /* Mutex slots for handles. */
  878. #endif
  879. #endif /* !_DB_MUTEX_H_ */