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

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

MySQL数据库

开发平台：

Visual C++

sync0rw.c：源码内容
  1. /******************************************************
  2. The read-write lock (for thread synchronization)
  4. (c) 1995 Innobase Oy
  6. Created 9/11/1995 Heikki Tuuri
  7. *******************************************************/
  9. #include "sync0rw.h"
  10. #ifdef UNIV_NONINL
  11. #include "sync0rw.ic"
  12. #endif
  14. #include "os0thread.h"
  15. #include "mem0mem.h"
  16. #include "srv0srv.h"
  18. ulint rw_s_system_call_count = 0;
  19. ulint rw_s_spin_wait_count = 0;
  20. ulint rw_s_os_wait_count = 0;
  22. ulint rw_s_exit_count = 0;
  24. ulint rw_x_system_call_count = 0;
  25. ulint rw_x_spin_wait_count = 0;
  26. ulint rw_x_os_wait_count = 0;
  28. ulint rw_x_exit_count = 0;
  30. /* The global list of rw-locks */
  31. rw_lock_list_t rw_lock_list;
  32. mutex_t rw_lock_list_mutex;
  34. #ifdef UNIV_SYNC_DEBUG
  35. /* The global mutex which protects debug info lists of all rw-locks.
  36. To modify the debug info list of an rw-lock, this mutex has to be
  37. acquired in addition to the mutex protecting the lock. */
  39. mutex_t rw_lock_debug_mutex;
  40. os_event_t rw_lock_debug_event; /* If deadlock detection does not
  41. get immediately the mutex, it may
  42. wait for this event */
  43. ibool rw_lock_debug_waiters; /* This is set to TRUE, if there may
  44. be waiters for the event */
  46. /**********************************************************************
  47. Creates a debug info struct. */
  48. static
  49. rw_lock_debug_t*
  50. rw_lock_debug_create(void);
  51. /*======================*/
  52. /**********************************************************************
  53. Frees a debug info struct. */
  54. static
  55. void
  56. rw_lock_debug_free(
  57. /*===============*/
  58. rw_lock_debug_t* info);
  60. /**********************************************************************
  61. Creates a debug info struct. */
  62. static
  63. rw_lock_debug_t*
  64. rw_lock_debug_create(void)
  65. /*======================*/
  66. {
  67. return((rw_lock_debug_t*) mem_alloc(sizeof(rw_lock_debug_t)));
  68. }
  70. /**********************************************************************
  71. Frees a debug info struct. */
  72. static
  73. void
  74. rw_lock_debug_free(
  75. /*===============*/
  76. rw_lock_debug_t* info)
  77. {
  78. mem_free(info);
  79. }
  80. #endif /* UNIV_SYNC_DEBUG */
  82. /**********************************************************************
  83. Creates, or rather, initializes an rw-lock object in a specified memory
  84. location (which must be appropriately aligned). The rw-lock is initialized
  85. to the non-locked state. Explicit freeing of the rw-lock with rw_lock_free
  86. is necessary only if the memory block containing it is freed. */
  88. void
  89. rw_lock_create_func(
  90. /*================*/
  91. rw_lock_t* lock, /* in: pointer to memory */
  92. const char* cfile_name, /* in: file name where created */
  93. ulint cline) /* in: file line where created */
  94. {
  95. /* If this is the very first time a synchronization
  96. object is created, then the following call initializes
  97. the sync system. */
  99. mutex_create(rw_lock_get_mutex(lock));
  100. mutex_set_level(rw_lock_get_mutex(lock), SYNC_NO_ORDER_CHECK);
  102. lock->mutex.cfile_name = cfile_name;
  103. lock->mutex.cline = cline;
  105. rw_lock_set_waiters(lock, 0);
  106. rw_lock_set_writer(lock, RW_LOCK_NOT_LOCKED);
  107. lock->writer_count = 0;
  108. rw_lock_set_reader_count(lock, 0);
  110. lock->writer_is_wait_ex = FALSE;
  112. #ifdef UNIV_SYNC_DEBUG
  113. UT_LIST_INIT(lock->debug_list);
  115. lock->level = SYNC_LEVEL_NONE;
  116. #endif /* UNIV_SYNC_DEBUG */
  117. lock->magic_n = RW_LOCK_MAGIC_N;
  119. lock->cfile_name = cfile_name;
  120. lock->cline = cline;
  122. lock->last_s_file_name = "not yet reserved";
  123. lock->last_x_file_name = "not yet reserved";
  124. lock->last_s_line = 0;
  125. lock->last_x_line = 0;
  127. mutex_enter(&rw_lock_list_mutex);
  129. if (UT_LIST_GET_LEN(rw_lock_list) > 0) {
  130. ut_a(UT_LIST_GET_FIRST(rw_lock_list)->magic_n
  131. == RW_LOCK_MAGIC_N);
  132. }
  134. UT_LIST_ADD_FIRST(list, rw_lock_list, lock);
  136. mutex_exit(&rw_lock_list_mutex);
  137. }
  139. /**********************************************************************
  140. Calling this function is obligatory only if the memory buffer containing
  141. the rw-lock is freed. Removes an rw-lock object from the global list. The
  142. rw-lock is checked to be in the non-locked state. */
  144. void
  145. rw_lock_free(
  146. /*=========*/
  147. rw_lock_t* lock) /* in: rw-lock */
  148. {
  149. #ifdef UNIV_DEBUG
  150. ut_a(rw_lock_validate(lock));
  151. #endif /* UNIV_DEBUG */
  152. ut_a(rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED);
  153. ut_a(rw_lock_get_waiters(lock) == 0);
  154. ut_a(rw_lock_get_reader_count(lock) == 0);
  156. lock->magic_n = 0;
  158. mutex_free(rw_lock_get_mutex(lock));
  160. mutex_enter(&rw_lock_list_mutex);
  162. if (UT_LIST_GET_PREV(list, lock)) {
  163. ut_a(UT_LIST_GET_PREV(list, lock)->magic_n == RW_LOCK_MAGIC_N);
  164. }
  165. if (UT_LIST_GET_NEXT(list, lock)) {
  166. ut_a(UT_LIST_GET_NEXT(list, lock)->magic_n == RW_LOCK_MAGIC_N);
  167. }
  169. UT_LIST_REMOVE(list, rw_lock_list, lock);
  171. mutex_exit(&rw_lock_list_mutex);
  172. }
  174. /**********************************************************************
  175. Checks that the rw-lock has been initialized and that there are no
  176. simultaneous shared and exclusive locks. */
  178. ibool
  179. rw_lock_validate(
  180. /*=============*/
  181. rw_lock_t* lock)
  182. {
  183. ut_a(lock);
  185. mutex_enter(rw_lock_get_mutex(lock));
  187. ut_a(lock->magic_n == RW_LOCK_MAGIC_N);
  188. ut_a((rw_lock_get_reader_count(lock) == 0)
  189.      || (rw_lock_get_writer(lock) != RW_LOCK_EX));
  190. ut_a((rw_lock_get_writer(lock) == RW_LOCK_EX)
  191.      || (rw_lock_get_writer(lock) == RW_LOCK_WAIT_EX)
  192.      || (rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED));
  193. ut_a((rw_lock_get_waiters(lock) == 0)
  194.      || (rw_lock_get_waiters(lock) == 1));
  195. ut_a((lock->writer != RW_LOCK_EX) || (lock->writer_count > 0));
  196.      
  197. mutex_exit(rw_lock_get_mutex(lock));
  199. return(TRUE);
  200. }
  202. /**********************************************************************
  203. Lock an rw-lock in shared mode for the current thread. If the rw-lock is
  204. locked in exclusive mode, or there is an exclusive lock request waiting,
  205. the function spins a preset time (controlled by SYNC_SPIN_ROUNDS), waiting
  206. for the lock, before suspending the thread. */
  208. void
  209. rw_lock_s_lock_spin(
  210. /*================*/
  211.         rw_lock_t*    lock,   /* in: pointer to rw-lock */
  212. ulint pass, /* in: pass value; != 0, if the lock
  213. will be passed to another thread to unlock */
  214. const char* file_name, /* in: file name where lock requested */
  215. ulint line) /* in: line where requested */
  216. {
  217.         ulint    index; /* index of the reserved wait cell */
  218.         ulint    i;    /* spin round count */
  219.         
  220.         ut_ad(rw_lock_validate(lock));
  222. lock_loop:
  223. rw_s_spin_wait_count++;
  225. /* Spin waiting for the writer field to become free */
  226.         i = 0;
  228.         while (rw_lock_get_writer(lock) != RW_LOCK_NOT_LOCKED
  229. && i < SYNC_SPIN_ROUNDS) {
  230.          if (srv_spin_wait_delay) {
  231.          ut_delay(ut_rnd_interval(0, srv_spin_wait_delay));
  232.          }
  234.          i++;
  235.         }
  237. if (i == SYNC_SPIN_ROUNDS) {
  238. os_thread_yield();
  239. }
  241. if (srv_print_latch_waits) {
  242. fprintf(stderr,
  243. "Thread %lu spin wait rw-s-lock at %p cfile %s cline %lu rnds %lun",
  244. (ulong) os_thread_pf(os_thread_get_curr_id()), lock,
  245. lock->cfile_name, (ulong) lock->cline, (ulong) i);
  246. }
  248. mutex_enter(rw_lock_get_mutex(lock));
  250.         /* We try once again to obtain the lock */
  252. if (TRUE == rw_lock_s_lock_low(lock, pass, file_name, line)) {
  253. mutex_exit(rw_lock_get_mutex(lock));
  255. return; /* Success */
  256. } else {
  257. /* If we get here, locking did not succeed, we may
  258. suspend the thread to wait in the wait array */
  260. rw_s_system_call_count++;
  262.          sync_array_reserve_cell(sync_primary_wait_array,
  263. lock, RW_LOCK_SHARED,
  264. file_name, line,
  265. &index);
  267. rw_lock_set_waiters(lock, 1);
  269. mutex_exit(rw_lock_get_mutex(lock));
  271. if (srv_print_latch_waits) {
  272. fprintf(stderr,
  273. "Thread %lu OS wait rw-s-lock at %p cfile %s cline %lun",
  274. os_thread_pf(os_thread_get_curr_id()),
  275.         lock, lock->cfile_name, (ulong) lock->cline);
  276. }
  278. rw_s_system_call_count++;
  279. rw_s_os_wait_count++;
  281.           sync_array_wait_event(sync_primary_wait_array, index);
  283.          goto lock_loop;
  284. }        
  285. }
  287. /**********************************************************************
  288. This function is used in the insert buffer to move the ownership of an
  289. x-latch on a buffer frame to the current thread. The x-latch was set by
  290. the buffer read operation and it protected the buffer frame while the
  291. read was done. The ownership is moved because we want that the current
  292. thread is able to acquire a second x-latch which is stored in an mtr.
  293. This, in turn, is needed to pass the debug checks of index page
  294. operations. */
  296. void
  297. rw_lock_x_lock_move_ownership(
  298. /*==========================*/
  299. rw_lock_t* lock) /* in: lock which was x-locked in the
  300. buffer read */
  301. {
  302. ut_ad(rw_lock_is_locked(lock, RW_LOCK_EX));
  304. mutex_enter(&(lock->mutex));
  306. lock->writer_thread = os_thread_get_curr_id();
  308. lock->pass = 0;
  310. mutex_exit(&(lock->mutex));
  311. }
  313. /**********************************************************************
  314. Low-level function for acquiring an exclusive lock. */
  315. UNIV_INLINE
  316. ulint
  317. rw_lock_x_lock_low(
  318. /*===============*/
  319. /* out: RW_LOCK_NOT_LOCKED if did
  320. not succeed, RW_LOCK_EX if success,
  321. RW_LOCK_WAIT_EX, if got wait reservation */
  322.         rw_lock_t*    lock,   /* in: pointer to rw-lock */
  323. ulint pass, /* in: pass value; != 0, if the lock will
  324. be passed to another thread to unlock */
  325. const char* file_name,/* in: file name where lock requested */
  326. ulint line) /* in: line where requested */
  327. {
  328. #ifdef UNIV_SYNC_DEBUG
  329. ut_ad(mutex_own(rw_lock_get_mutex(lock)));
  330. #endif /* UNIV_SYNC_DEBUG */
  331. if (rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED) {
  333. if (rw_lock_get_reader_count(lock) == 0) {
  335. rw_lock_set_writer(lock, RW_LOCK_EX);
  336. lock->writer_thread = os_thread_get_curr_id();
  337. lock->writer_count++;
  338. lock->pass = pass;
  340. #ifdef UNIV_SYNC_DEBUG
  341. rw_lock_add_debug_info(lock, pass, RW_LOCK_EX,
  342. file_name, line);
  343. #endif
  344. lock->last_x_file_name = file_name;
  345. lock->last_x_line = line;
  347. /* Locking succeeded, we may return */
  348. return(RW_LOCK_EX);
  349. } else {
  350. /* There are readers, we have to wait */
  351. rw_lock_set_writer(lock, RW_LOCK_WAIT_EX);
  352. lock->writer_thread = os_thread_get_curr_id();
  353. lock->pass = pass;
  354. lock->writer_is_wait_ex = TRUE;
  356. #ifdef UNIV_SYNC_DEBUG
  357. rw_lock_add_debug_info(lock, pass, RW_LOCK_WAIT_EX,
  358. file_name, line);
  359. #endif
  361. return(RW_LOCK_WAIT_EX);
  362. }
  364. } else if ((rw_lock_get_writer(lock) == RW_LOCK_WAIT_EX)
  365.    && os_thread_eq(lock->writer_thread,
  366. os_thread_get_curr_id())) {
  368. if (rw_lock_get_reader_count(lock) == 0) {
  370. rw_lock_set_writer(lock, RW_LOCK_EX);
  371. lock->writer_count++;
  372. lock->pass = pass;
  373. lock->writer_is_wait_ex = FALSE;
  375. #ifdef UNIV_SYNC_DEBUG
  376. rw_lock_remove_debug_info(lock, pass, RW_LOCK_WAIT_EX);
  377. rw_lock_add_debug_info(lock, pass, RW_LOCK_EX,
  378. file_name, line);
  379. #endif
  381. lock->last_x_file_name = file_name;
  382. lock->last_x_line = line;
  384. /* Locking succeeded, we may return */
  385. return(RW_LOCK_EX);
  386. }
  388. return(RW_LOCK_WAIT_EX);
  390. } else if ((rw_lock_get_writer(lock) == RW_LOCK_EX)
  391.    && os_thread_eq(lock->writer_thread,
  392. os_thread_get_curr_id())
  393.    && (lock->pass == 0)
  394.    && (pass == 0)) {
  396. lock->writer_count++;
  398. #ifdef UNIV_SYNC_DEBUG
  399. rw_lock_add_debug_info(lock, pass, RW_LOCK_EX, file_name,
  400. line);
  401. #endif
  403. lock->last_x_file_name = file_name;
  404. lock->last_x_line = line;
  406. /* Locking succeeded, we may return */
  407. return(RW_LOCK_EX);
  408. }
  410. /* Locking did not succeed */
  411. return(RW_LOCK_NOT_LOCKED);
  412. }
  414. /**********************************************************************
  415. NOTE! Use the corresponding macro, not directly this function! Lock an
  416. rw-lock in exclusive mode for the current thread. If the rw-lock is locked
  417. in shared or exclusive mode, or there is an exclusive lock request waiting,
  418. the function spins a preset time (controlled by SYNC_SPIN_ROUNDS), waiting
  419. for the lock before suspending the thread. If the same thread has an x-lock
  420. on the rw-lock, locking succeed, with the following exception: if pass != 0,
  421. only a single x-lock may be taken on the lock. NOTE: If the same thread has
  422. an s-lock, locking does not succeed! */
  424. void
  425. rw_lock_x_lock_func(
  426. /*================*/
  427.         rw_lock_t*    lock,   /* in: pointer to rw-lock */
  428. ulint pass, /* in: pass value; != 0, if the lock will
  429. be passed to another thread to unlock */
  430. const char* file_name,/* in: file name where lock requested */
  431. ulint line) /* in: line where requested */
  432. {
  433.         ulint index;  /* index of the reserved wait cell */
  434.         ulint state; /* lock state acquired */
  435.         ulint i; /* spin round count */
  436.         
  437.         ut_ad(rw_lock_validate(lock));
  439. lock_loop:
  440.         /* Acquire the mutex protecting the rw-lock fields */
  441. mutex_enter_fast(&(lock->mutex));
  443. state = rw_lock_x_lock_low(lock, pass, file_name, line);
  445. mutex_exit(&(lock->mutex));
  446.         
  447. if (state == RW_LOCK_EX) {
  449. return; /* Locking succeeded */
  451. } else if (state == RW_LOCK_NOT_LOCKED) {
  453.   /* Spin waiting for the writer field to become free */
  454. i = 0;
  456.          while (rw_lock_get_writer(lock) != RW_LOCK_NOT_LOCKED 
  457.                 && i < SYNC_SPIN_ROUNDS) {
  458.          if (srv_spin_wait_delay) {
  459. ut_delay(ut_rnd_interval(0,
  460. srv_spin_wait_delay));
  461.          }
  462.         
  463.          i++;
  464.          }
  465. if (i == SYNC_SPIN_ROUNDS) {
  466. os_thread_yield();
  467. }
  468.         } else if (state == RW_LOCK_WAIT_EX) {
  470.   /* Spin waiting for the reader count field to become zero */
  471. i = 0;
  473.          while (rw_lock_get_reader_count(lock) != 0 
  474.                 && i < SYNC_SPIN_ROUNDS) {
  475.          if (srv_spin_wait_delay) {
  476. ut_delay(ut_rnd_interval(0,
  477. srv_spin_wait_delay));
  478.          }
  480. i++;
  481.          }
  482. if (i == SYNC_SPIN_ROUNDS) {
  483. os_thread_yield();
  484. }
  485.         } else {
  486. i = 0; /* Eliminate a compiler warning */
  487. ut_error;
  488. }
  490. if (srv_print_latch_waits) {
  491. fprintf(stderr,
  492. "Thread %lu spin wait rw-x-lock at %p cfile %s cline %lu rnds %lun",
  493. os_thread_pf(os_thread_get_curr_id()), lock,
  494. lock->cfile_name, (ulong) lock->cline, (ulong) i);
  495. }
  497. rw_x_spin_wait_count++;
  499.         /* We try once again to obtain the lock. Acquire the mutex protecting
  500. the rw-lock fields */
  502. mutex_enter(rw_lock_get_mutex(lock));
  504. state = rw_lock_x_lock_low(lock, pass, file_name, line);
  506. if (state == RW_LOCK_EX) {
  507. mutex_exit(rw_lock_get_mutex(lock));
  509. return; /* Locking succeeded */
  510. }
  512. rw_x_system_call_count++;
  514.         sync_array_reserve_cell(sync_primary_wait_array,
  515. lock, RW_LOCK_EX,
  516. file_name, line,
  517. &index);
  519. rw_lock_set_waiters(lock, 1);
  521. mutex_exit(rw_lock_get_mutex(lock));
  523. if (srv_print_latch_waits) {
  524. fprintf(stderr,
  525. "Thread %lu OS wait for rw-x-lock at %p cfile %s cline %lun",
  526. os_thread_pf(os_thread_get_curr_id()), lock,
  527. lock->cfile_name, (ulong) lock->cline);
  528. }
  530. rw_x_system_call_count++;
  531. rw_x_os_wait_count++;
  533.         sync_array_wait_event(sync_primary_wait_array, index);
  535.         goto lock_loop;
  536. }
  538. #ifdef UNIV_SYNC_DEBUG
  539. /**********************************************************************
  540. Acquires the debug mutex. We cannot use the mutex defined in sync0sync,
  541. because the debug mutex is also acquired in sync0arr while holding the OS
  542. mutex protecting the sync array, and the ordinary mutex_enter might
  543. recursively call routines in sync0arr, leading to a deadlock on the OS
  544. mutex. */
  546. void
  547. rw_lock_debug_mutex_enter(void)
  548. /*==========================*/
  549. {
  550. loop:
  551. if (0 == mutex_enter_nowait(&rw_lock_debug_mutex,
  552. __FILE__, __LINE__)) {
  553. return;
  554. }
  556. os_event_reset(rw_lock_debug_event);
  558. rw_lock_debug_waiters = TRUE;
  560. if (0 == mutex_enter_nowait(&rw_lock_debug_mutex,
  561. __FILE__, __LINE__)) {
  562. return;
  563. }
  565. os_event_wait(rw_lock_debug_event);
  567. goto loop;
  568. }
  570. /**********************************************************************
  571. Releases the debug mutex. */
  573. void
  574. rw_lock_debug_mutex_exit(void)
  575. /*==========================*/
  576. {
  577. mutex_exit(&rw_lock_debug_mutex);
  579. if (rw_lock_debug_waiters) {
  580. rw_lock_debug_waiters = FALSE;
  581. os_event_set(rw_lock_debug_event);
  582. }
  583. }
  585. /**********************************************************************
  586. Inserts the debug information for an rw-lock. */
  588. void
  589. rw_lock_add_debug_info(
  590. /*===================*/
  591. rw_lock_t* lock, /* in: rw-lock */
  592. ulint pass, /* in: pass value */
  593. ulint lock_type, /* in: lock type */
  594. const char* file_name, /* in: file where requested */
  595. ulint line) /* in: line where requested */
  596. {
  597. rw_lock_debug_t* info;
  599. ut_ad(lock);
  600. ut_ad(file_name);
  602. info = rw_lock_debug_create();
  604. rw_lock_debug_mutex_enter();
  606. info->file_name = file_name;
  607. info->line  = line;
  608. info->lock_type = lock_type;
  609. info->thread_id = os_thread_get_curr_id();
  610. info->pass = pass;
  612. UT_LIST_ADD_FIRST(list, lock->debug_list, info);
  614. rw_lock_debug_mutex_exit();
  616. if ((pass == 0) && (lock_type != RW_LOCK_WAIT_EX)) {
  617. sync_thread_add_level(lock, lock->level);
  618. }
  619. }
  621. /**********************************************************************
  622. Removes a debug information struct for an rw-lock. */
  624. void
  625. rw_lock_remove_debug_info(
  626. /*======================*/
  627. rw_lock_t* lock, /* in: rw-lock */
  628. ulint pass, /* in: pass value */
  629. ulint lock_type) /* in: lock type */
  630. {
  631. rw_lock_debug_t* info;
  633. ut_ad(lock);
  635. if ((pass == 0) && (lock_type != RW_LOCK_WAIT_EX)) {
  636. sync_thread_reset_level(lock);
  637. }
  639. rw_lock_debug_mutex_enter();
  641. info = UT_LIST_GET_FIRST(lock->debug_list);
  643. while (info != NULL) {
  644. if ((pass == info->pass)
  645.     && ((pass != 0)
  646. || os_thread_eq(info->thread_id,
  647. os_thread_get_curr_id()))
  648.     && (info->lock_type == lock_type)) {
  650.      /* Found! */
  651.      UT_LIST_REMOVE(list, lock->debug_list, info);
  652. rw_lock_debug_mutex_exit();
  654.      rw_lock_debug_free(info);
  656.      return;
  657. }
  659. info = UT_LIST_GET_NEXT(list, info);
  660. }
  662. ut_error;
  663. }
  664. #endif /* UNIV_SYNC_DEBUG */
  666. /**********************************************************************
  667. Sets the rw-lock latching level field. */
  669. void
  670. rw_lock_set_level(
  671. /*==============*/
  672. rw_lock_t* lock, /* in: rw-lock */
  673. ulint level) /* in: level */
  674. {
  675. lock->level = level;
  676. }
  678. #ifdef UNIV_SYNC_DEBUG
  679. /**********************************************************************
  680. Checks if the thread has locked the rw-lock in the specified mode, with
  681. the pass value == 0. */
  683. ibool
  684. rw_lock_own(
  685. /*========*/
  686. /* out: TRUE if locked */
  687. rw_lock_t* lock, /* in: rw-lock */
  688. ulint lock_type) /* in: lock type: RW_LOCK_SHARED,
  689. RW_LOCK_EX */
  690. {
  691. rw_lock_debug_t* info;
  693. ut_ad(lock);
  694. ut_ad(rw_lock_validate(lock));
  696. mutex_enter(&(lock->mutex));
  698. info = UT_LIST_GET_FIRST(lock->debug_list);
  700. while (info != NULL) {
  702. if (os_thread_eq(info->thread_id, os_thread_get_curr_id())
  703.     && (info->pass == 0)
  704.     && (info->lock_type == lock_type)) {
  706. mutex_exit(&(lock->mutex));
  707.      /* Found! */
  709.      return(TRUE);
  710. }
  712. info = UT_LIST_GET_NEXT(list, info);
  713. }
  714. mutex_exit(&(lock->mutex));
  716. return(FALSE);
  717. }
  718. #endif /* UNIV_SYNC_DEBUG */
  720. /**********************************************************************
  721. Checks if somebody has locked the rw-lock in the specified mode. */
  723. ibool
  724. rw_lock_is_locked(
  725. /*==============*/
  726. /* out: TRUE if locked */
  727. rw_lock_t* lock, /* in: rw-lock */
  728. ulint lock_type) /* in: lock type: RW_LOCK_SHARED,
  729. RW_LOCK_EX */
  730. {
  731. ibool ret = FALSE;
  733. ut_ad(lock);
  734. ut_ad(rw_lock_validate(lock));
  736. mutex_enter(&(lock->mutex));
  738. if (lock_type == RW_LOCK_SHARED) {
  739. if (lock->reader_count > 0) {
  740. ret = TRUE;
  741. }
  742. } else if (lock_type == RW_LOCK_EX) {
  743. if (lock->writer == RW_LOCK_EX) {
  744. ret = TRUE;
  745. }
  746. } else {
  747. ut_error;
  748. }
  750. mutex_exit(&(lock->mutex));
  752. return(ret);
  753. }
  755. #ifdef UNIV_SYNC_DEBUG
  756. /*******************************************************************
  757. Prints debug info of currently locked rw-locks. */
  759. void
  760. rw_lock_list_print_info(void)
  761. /*=========================*/
  762. {
  763. rw_lock_t* lock;
  764. ulint count = 0;
  765. rw_lock_debug_t* info;
  767. mutex_enter(&rw_lock_list_mutex);
  769. fputs("-------------n"
  770. "RW-LATCH INFOn"
  771. "-------------n", stderr);
  773. lock = UT_LIST_GET_FIRST(rw_lock_list);
  775. while (lock != NULL) {
  777. count++;
  779. mutex_enter(&(lock->mutex));
  781. if ((rw_lock_get_writer(lock) != RW_LOCK_NOT_LOCKED)
  782.     || (rw_lock_get_reader_count(lock) != 0)
  783.     || (rw_lock_get_waiters(lock) != 0)) {
  785. fprintf(stderr, "RW-LOCK: %p ", lock);
  787. if (rw_lock_get_waiters(lock)) {
  788. fputs(" Waiters for the lock existn", stderr);
  789. } else {
  790. putc('n', stderr);
  791. }
  792.     
  793. info = UT_LIST_GET_FIRST(lock->debug_list);
  794. while (info != NULL) {
  795. rw_lock_debug_print(info);
  796. info = UT_LIST_GET_NEXT(list, info);
  797. }
  798. }
  800. mutex_exit(&(lock->mutex));
  801. lock = UT_LIST_GET_NEXT(list, lock);
  802. }
  804. fprintf(stderr, "Total number of rw-locks %ldn", count);
  805. mutex_exit(&rw_lock_list_mutex);
  806. }
  808. /*******************************************************************
  809. Prints debug info of an rw-lock. */
  811. void
  812. rw_lock_print(
  813. /*==========*/
  814. rw_lock_t* lock) /* in: rw-lock */
  815. {
  816. rw_lock_debug_t* info;
  818. fprintf(stderr,
  819. "-------------n"
  820. "RW-LATCH INFOn"
  821. "RW-LATCH: %p ", lock);
  823. if ((rw_lock_get_writer(lock) != RW_LOCK_NOT_LOCKED)
  824.     || (rw_lock_get_reader_count(lock) != 0)
  825.     || (rw_lock_get_waiters(lock) != 0)) {
  827. if (rw_lock_get_waiters(lock)) {
  828. fputs(" Waiters for the lock existn", stderr);
  829. } else {
  830. putc('n', stderr);
  831. }
  832.     
  833. info = UT_LIST_GET_FIRST(lock->debug_list);
  834. while (info != NULL) {
  835. rw_lock_debug_print(info);
  836. info = UT_LIST_GET_NEXT(list, info);
  837. }
  838. }
  839. }
  841. /*************************************************************************
  842. Prints info of a debug struct. */
  844. void
  845. rw_lock_debug_print(
  846. /*================*/
  847. rw_lock_debug_t* info) /* in: debug struct */
  848. {
  849. ulint rwt;
  851. rwt    = info->lock_type;
  853. fprintf(stderr, "Locked: thread %ld file %s line %ld  ",
  854. (ulong) os_thread_pf(info->thread_id), info->file_name,
  855.         (ulong) info->line);
  856. if (rwt == RW_LOCK_SHARED) {
  857. fputs("S-LOCK", stderr);
  858. } else if (rwt == RW_LOCK_EX) {
  859. fputs("X-LOCK", stderr);
  860. } else if (rwt == RW_LOCK_WAIT_EX) {
  861. fputs("WAIT X-LOCK", stderr);
  862. } else {
  863. ut_error;
  864. }
  865. if (info->pass != 0) {
  866. fprintf(stderr, " pass value %lu", (ulong) info->pass);
  867. }
  868. putc('n', stderr);
  869. }
  871. /*******************************************************************
  872. Returns the number of currently locked rw-locks. Works only in the debug
  873. version. */
  875. ulint
  876. rw_lock_n_locked(void)
  877. /*==================*/
  878. {
  879. rw_lock_t* lock;
  880. ulint count = 0;
  882. mutex_enter(&rw_lock_list_mutex);
  884. lock = UT_LIST_GET_FIRST(rw_lock_list);
  886. while (lock != NULL) {
  887. mutex_enter(rw_lock_get_mutex(lock));
  889. if ((rw_lock_get_writer(lock) != RW_LOCK_NOT_LOCKED)
  890. || (rw_lock_get_reader_count(lock) != 0)) {
  891. count++;
  892. }
  894. mutex_exit(rw_lock_get_mutex(lock));
  895. lock = UT_LIST_GET_NEXT(list, lock);
  896. }
  898. mutex_exit(&rw_lock_list_mutex);
  900. return(count);
  901. }
  902. #endif /* UNIV_SYNC_DEBUG */