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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
sync0rw.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：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;
  21. ulint rw_s_exit_count = 0;
  23. ulint rw_x_system_call_count = 0;
  24. ulint rw_x_spin_wait_count = 0;
  26. ulint rw_x_exit_count = 0;
  28. /* The global list of rw-locks */
  29. rw_lock_list_t rw_lock_list;
  30. mutex_t rw_lock_list_mutex;
  32. /* The global mutex which protects debug info lists of all rw-locks.
  33. To modify the debug info list of an rw-lock, this mutex has to be
  34. acquired in addition to the mutex protecting the lock. */
  36. mutex_t rw_lock_debug_mutex;
  37. os_event_t rw_lock_debug_event; /* If deadlock detection does not
  38. get immediately the mutex, it may
  39. wait for this event */
  40. ibool rw_lock_debug_waiters; /* This is set to TRUE, if there may
  41. be waiters for the event */
  43. /**********************************************************************
  44. Creates a debug info struct. */
  45. static
  46. rw_lock_debug_t*
  47. rw_lock_debug_create(void);
  48. /*======================*/
  49. /**********************************************************************
  50. Frees a debug info struct. */
  51. static
  52. void
  53. rw_lock_debug_free(
  54. /*===============*/
  55. rw_lock_debug_t* info);
  57. /**********************************************************************
  58. Creates a debug info struct. */
  59. static
  60. rw_lock_debug_t*
  61. rw_lock_debug_create(void)
  62. /*======================*/
  63. {
  64. return((rw_lock_debug_t*) mem_alloc(sizeof(rw_lock_debug_t)));
  65. }
  67. /**********************************************************************
  68. Frees a debug info struct. */
  69. static
  70. void
  71. rw_lock_debug_free(
  72. /*===============*/
  73. rw_lock_debug_t* info)
  74. {
  75. mem_free(info);
  76. }
  78. /**********************************************************************
  79. Creates, or rather, initializes an rw-lock object in a specified memory
  80. location (which must be appropriately aligned). The rw-lock is initialized
  81. to the non-locked state. Explicit freeing of the rw-lock with rw_lock_free
  82. is necessary only if the memory block containing it is freed. */
  84. void
  85. rw_lock_create_func(
  86. /*================*/
  87. rw_lock_t* lock, /* in: pointer to memory */
  88. char* cfile_name, /* in: file name where created */
  89. ulint cline) /* in: file line where created */
  90. {
  91. /* If this is the very first time a synchronization
  92. object is created, then the following call initializes
  93. the sync system. */
  95. mutex_create(rw_lock_get_mutex(lock));
  96. mutex_set_level(rw_lock_get_mutex(lock), SYNC_NO_ORDER_CHECK);
  98. ut_memcpy(&(lock->mutex.cfile_name), cfile_name,
  99. ut_min(RW_CNAME_LEN - 1, ut_strlen(cfile_name)));
  100. lock->mutex.cline = cline;
  102. rw_lock_set_waiters(lock, 0);
  103. rw_lock_set_writer(lock, RW_LOCK_NOT_LOCKED);
  104. lock->writer_count = 0;
  105. rw_lock_set_reader_count(lock, 0);
  107. lock->writer_is_wait_ex = FALSE;
  109. UT_LIST_INIT(lock->debug_list);
  111. lock->magic_n = RW_LOCK_MAGIC_N;
  112. lock->level = SYNC_LEVEL_NONE;
  114. ut_memcpy(&(lock->cfile_name), cfile_name,
  115. ut_min(RW_CNAME_LEN - 1, ut_strlen(cfile_name)));
  116. lock->cfile_name[RW_CNAME_LEN - 1] = '';
  117. lock->cline = cline;
  119. mutex_enter(&rw_lock_list_mutex);
  121. UT_LIST_ADD_FIRST(list, rw_lock_list, lock);
  123. mutex_exit(&rw_lock_list_mutex);
  124. }
  126. /**********************************************************************
  127. Calling this function is obligatory only if the memory buffer containing
  128. the rw-lock is freed. Removes an rw-lock object from the global list. The
  129. rw-lock is checked to be in the non-locked state. */
  131. void
  132. rw_lock_free(
  133. /*=========*/
  134. rw_lock_t* lock) /* in: rw-lock */
  135. {
  136. ut_ad(rw_lock_validate(lock));
  137. ut_a(rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED);
  138. ut_a(rw_lock_get_waiters(lock) == 0);
  139. ut_a(rw_lock_get_reader_count(lock) == 0);
  141. lock->magic_n = 0;
  143. mutex_free(rw_lock_get_mutex(lock));
  145. mutex_enter(&rw_lock_list_mutex);
  147. UT_LIST_REMOVE(list, rw_lock_list, lock);
  149. mutex_exit(&rw_lock_list_mutex);
  150. }
  152. /**********************************************************************
  153. Checks that the rw-lock has been initialized and that there are no
  154. simultaneous shared and exclusive locks. */
  156. ibool
  157. rw_lock_validate(
  158. /*=============*/
  159. rw_lock_t* lock)
  160. {
  161. ut_a(lock);
  163. mutex_enter(rw_lock_get_mutex(lock));
  165. ut_a(lock->magic_n == RW_LOCK_MAGIC_N);
  166. ut_a((rw_lock_get_reader_count(lock) == 0)
  167.      || (rw_lock_get_writer(lock) != RW_LOCK_EX));
  168. ut_a((rw_lock_get_writer(lock) == RW_LOCK_EX)
  169.      || (rw_lock_get_writer(lock) == RW_LOCK_WAIT_EX)
  170.      || (rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED));
  171. ut_a((rw_lock_get_waiters(lock) == 0)
  172.      || (rw_lock_get_waiters(lock) == 1));
  173. ut_a((lock->writer != RW_LOCK_EX) || (lock->writer_count > 0));
  174.      
  175. mutex_exit(rw_lock_get_mutex(lock));
  177. return(TRUE);
  178. }
  180. /**********************************************************************
  181. Lock an rw-lock in shared mode for the current thread. If the rw-lock is
  182. locked in exclusive mode, or there is an exclusive lock request waiting,
  183. the function spins a preset time (controlled by SYNC_SPIN_ROUNDS), waiting
  184. for the lock, before suspending the thread. */
  186. void
  187. rw_lock_s_lock_spin(
  188. /*================*/
  189.         rw_lock_t*    lock   /* in: pointer to rw-lock */
  190. #ifdef UNIV_SYNC_DEBUG
  191. ,ulint pass, /* in: pass value; != 0, if the lock
  192. will be passed to another thread to unlock */
  193. char* file_name, /* in: file name where lock requested */
  194. ulint line /* in: line where requested */
  195. #endif
  196. )
  197. {
  198.         ulint    index; /* index of the reserved wait cell */
  199.         ulint    i;    /* spin round count */
  200.         
  201.         ut_ad(rw_lock_validate(lock));
  203. lock_loop:
  204. rw_s_spin_wait_count++;
  206.   /* Spin waiting for the writer field to become free */
  207.         i = 0;
  209.         while (rw_lock_get_writer(lock) != RW_LOCK_NOT_LOCKED
  210. && i < SYNC_SPIN_ROUNDS) {
  211.          if (srv_spin_wait_delay) {
  212.          ut_delay(ut_rnd_interval(0, srv_spin_wait_delay));
  213.          }
  215.          i++;
  216.         }
  218. if (i == SYNC_SPIN_ROUNDS) {
  219. os_thread_yield();
  220. }
  222. if (srv_print_latch_waits) {
  223. printf(
  224. "Thread %lu spin wait rw-s-lock at %lx cfile %s cline %lu rnds %lun",
  225. os_thread_get_curr_id(), (ulint)lock,
  226. &(lock->cfile_name), lock->cline, i);
  227. }
  229. mutex_enter(rw_lock_get_mutex(lock));
  231.         /* We try once again to obtain the lock */
  233. if (TRUE == rw_lock_s_lock_low(lock
  234. #ifdef UNIV_SYNC_DEBUG
  235. , pass, file_name,
  236. line
  237. #endif
  238.    )) {
  239. mutex_exit(rw_lock_get_mutex(lock));
  241. return; /* Success */
  242. } else {
  243. /* If we get here, locking did not succeed, we may
  244. suspend the thread to wait in the wait array */
  246. rw_s_system_call_count++;
  248.          sync_array_reserve_cell(sync_primary_wait_array,
  249. lock, RW_LOCK_SHARED,
  250. #ifdef UNIV_SYNC_DEBUG
  251. file_name, line,
  252. #endif
  253. &index);
  255. rw_lock_set_waiters(lock, 1);
  257. mutex_exit(rw_lock_get_mutex(lock));
  259. if (srv_print_latch_waits) {
  260. printf(
  261. "Thread %lu OS wait rw-s-lock at %lx cfile %s cline %lun",
  262. os_thread_get_curr_id(), (ulint)lock,
  263. &(lock->cfile_name), lock->cline);
  264. }
  266. rw_s_system_call_count++;
  268.          sync_array_wait_event(sync_primary_wait_array, index);
  270.          goto lock_loop;
  271. }        
  272. }
  274. /**********************************************************************
  275. This function is used in the insert buffer to move the ownership of an
  276. x-latch on a buffer frame to the current thread. The x-latch was set by
  277. the buffer read operation and it protected the buffer frame while the
  278. read was done. The ownership is moved because we want that the current
  279. thread is able to acquire a second x-latch which is stored in an mtr.
  280. This, in turn, is needed to pass the debug checks of index page
  281. operations. */
  283. void
  284. rw_lock_x_lock_move_ownership(
  285. /*==========================*/
  286. rw_lock_t* lock) /* in: lock which was x-locked in the
  287. buffer read */
  288. {
  289. ut_ad(rw_lock_is_locked(lock, RW_LOCK_EX));
  291. mutex_enter(&(lock->mutex));
  293. lock->writer_thread = os_thread_get_curr_id();
  295. lock->pass = 0;
  297. mutex_exit(&(lock->mutex));
  298. }
  300. /**********************************************************************
  301. Low-level function for acquiring an exclusive lock. */
  302. UNIV_INLINE
  303. ulint
  304. rw_lock_x_lock_low(
  305. /*===============*/
  306. /* out: RW_LOCK_NOT_LOCKED if did
  307. not succeed, RW_LOCK_EX if success,
  308. RW_LOCK_WAIT_EX, if got wait reservation */
  309.         rw_lock_t*    lock,   /* in: pointer to rw-lock */
  310. ulint pass /* in: pass value; != 0, if the lock will
  311. be passed to another thread to unlock */
  312. #ifdef UNIV_SYNC_DEBUG
  313. ,char* file_name, /* in: file name where lock requested */
  314. ulint line /* in: line where requested */
  315. #endif
  316. )
  317. {
  318. ut_ad(mutex_own(rw_lock_get_mutex(lock)));
  320. if (rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED) {
  322. if (rw_lock_get_reader_count(lock) == 0) {
  324. rw_lock_set_writer(lock, RW_LOCK_EX);
  325. lock->writer_thread = os_thread_get_curr_id();
  326. lock->writer_count++;
  327. lock->pass = pass;
  329. #ifdef UNIV_SYNC_DEBUG
  330. rw_lock_add_debug_info(lock, pass, RW_LOCK_EX,
  331. file_name, line);
  332. #endif
  334. /* Locking succeeded, we may return */
  335. return(RW_LOCK_EX);
  336. } else {
  337. /* There are readers, we have to wait */
  338. rw_lock_set_writer(lock, RW_LOCK_WAIT_EX);
  339. lock->writer_thread = os_thread_get_curr_id();
  340. lock->pass = pass;
  341. lock->writer_is_wait_ex = TRUE;
  343. #ifdef UNIV_SYNC_DEBUG
  344. rw_lock_add_debug_info(lock, pass, RW_LOCK_WAIT_EX,
  345. file_name, line);
  346. #endif
  348. return(RW_LOCK_WAIT_EX);
  349. }
  351. } else if ((rw_lock_get_writer(lock) == RW_LOCK_WAIT_EX)
  352.    && (lock->writer_thread == os_thread_get_curr_id())) {
  354. if (rw_lock_get_reader_count(lock) == 0) {
  356. rw_lock_set_writer(lock, RW_LOCK_EX);
  357. lock->writer_count++;
  358. lock->pass = pass;
  359. lock->writer_is_wait_ex = FALSE;
  361. #ifdef UNIV_SYNC_DEBUG
  362. rw_lock_remove_debug_info(lock, pass, RW_LOCK_WAIT_EX);
  363. rw_lock_add_debug_info(lock, pass, RW_LOCK_EX,
  364. file_name, line);
  365. #endif
  367. /* Locking succeeded, we may return */
  368. return(RW_LOCK_EX);
  369. }
  371. return(RW_LOCK_WAIT_EX);
  373. } else if ((rw_lock_get_writer(lock) == RW_LOCK_EX)
  374.    && (lock->writer_thread == os_thread_get_curr_id())
  375.    && (lock->pass == 0)
  376.    && (pass == 0)) {
  378. lock->writer_count++;
  380. #ifdef UNIV_SYNC_DEBUG
  381. rw_lock_add_debug_info(lock, pass, RW_LOCK_EX, file_name,
  382. line);
  383. #endif
  385. /* Locking succeeded, we may return */
  386. return(RW_LOCK_EX);
  387. }
  389. /* Locking did not succeed */
  390. return(RW_LOCK_NOT_LOCKED);
  391. }
  393. /**********************************************************************
  394. NOTE! Use the corresponding macro, not directly this function! Lock an
  395. rw-lock in exclusive mode for the current thread. If the rw-lock is locked
  396. in shared or exclusive mode, or there is an exclusive lock request waiting,
  397. the function spins a preset time (controlled by SYNC_SPIN_ROUNDS), waiting
  398. for the lock before suspending the thread. If the same thread has an x-lock
  399. on the rw-lock, locking succeed, with the following exception: if pass != 0,
  400. only a single x-lock may be taken on the lock. NOTE: If the same thread has
  401. an s-lock, locking does not succeed! */
  403. void
  404. rw_lock_x_lock_func(
  405. /*================*/
  406.         rw_lock_t*    lock,   /* in: pointer to rw-lock */
  407. ulint pass /* in: pass value; != 0, if the lock will
  408. be passed to another thread to unlock */
  409. #ifdef UNIV_SYNC_DEBUG
  410. ,char* file_name, /* in: file name where lock requested */
  411. ulint line /* in: line where requested */
  412. #endif
  413. )
  414. {
  415.         ulint index;  /* index of the reserved wait cell */
  416.         ulint state; /* lock state acquired */
  417.         ulint i; /* spin round count */
  418.         
  419.         ut_ad(rw_lock_validate(lock));
  421. lock_loop:
  422.         /* Acquire the mutex protecting the rw-lock fields */
  423. mutex_enter_fast(&(lock->mutex));
  425. state = rw_lock_x_lock_low(lock, pass
  426. #ifdef UNIV_SYNC_DEBUG
  427. ,file_name, line
  428. #endif
  429.        );
  431. mutex_exit(&(lock->mutex));
  432.         
  433. if (state == RW_LOCK_EX) {
  435. return; /* Locking succeeded */
  437. } else if (state == RW_LOCK_NOT_LOCKED) {
  439.   /* Spin waiting for the writer field to become free */
  440. i = 0;
  442.          while (rw_lock_get_writer(lock) != RW_LOCK_NOT_LOCKED 
  443.                 && i < SYNC_SPIN_ROUNDS) {
  444.          if (srv_spin_wait_delay) {
  445. ut_delay(ut_rnd_interval(0,
  446. srv_spin_wait_delay));
  447.          }
  448.         
  449.          i++;
  450.          }
  451. if (i == SYNC_SPIN_ROUNDS) {
  452. os_thread_yield();
  453. }
  454.         } else if (state == RW_LOCK_WAIT_EX) {
  456.   /* Spin waiting for the reader count field to become zero */
  457. i = 0;
  459.          while (rw_lock_get_reader_count(lock) != 0 
  460.                 && i < SYNC_SPIN_ROUNDS) {
  461.          if (srv_spin_wait_delay) {
  462. ut_delay(ut_rnd_interval(0,
  463. srv_spin_wait_delay));
  464.          }
  466. i++;
  467.          }
  468. if (i == SYNC_SPIN_ROUNDS) {
  469. os_thread_yield();
  470. }
  471.         } else {
  472. ut_error;
  473. }
  475. if (srv_print_latch_waits) {
  476. printf(
  477. "Thread %lu spin wait rw-x-lock at %lx cfile %s cline %lu rnds %lun",
  478. os_thread_get_curr_id(), (ulint)lock,
  479. &(lock->cfile_name), lock->cline, i);
  480. }
  482. rw_x_spin_wait_count++;
  484.         /* We try once again to obtain the lock. Acquire the mutex protecting
  485. the rw-lock fields */
  487. mutex_enter(rw_lock_get_mutex(lock));
  489. state = rw_lock_x_lock_low(lock, pass
  490. #ifdef UNIV_SYNC_DEBUG
  491. ,file_name, line
  492. #endif
  493.        );
  495. if (state == RW_LOCK_EX) {
  496. mutex_exit(rw_lock_get_mutex(lock));
  498. return; /* Locking succeeded */
  499. }
  501. rw_x_system_call_count++;
  503.         sync_array_reserve_cell(sync_primary_wait_array,
  504. lock, RW_LOCK_EX,
  505. #ifdef UNIV_SYNC_DEBUG
  506. file_name, line,
  507. #endif
  508. &index);
  510. rw_lock_set_waiters(lock, 1);
  512. mutex_exit(rw_lock_get_mutex(lock));
  514. if (srv_print_latch_waits) {
  515. printf(
  516. "Thread %lu OS wait for rw-x-lock at %lx cfile %s cline %lun",
  517. os_thread_get_curr_id(), (ulint)lock, &(lock->cfile_name),
  518. lock->cline);
  519. }
  521. rw_x_system_call_count++;
  523.         sync_array_wait_event(sync_primary_wait_array, index);
  525.         goto lock_loop;
  526. }
  528. /**********************************************************************
  529. Acquires the debug mutex. We cannot use the mutex defined in sync0sync,
  530. because the debug mutex is also acquired in sync0arr while holding the OS
  531. mutex protecting the sync array, and the ordinary mutex_enter might
  532. recursively call routines in sync0arr, leading to a deadlock on the OS
  533. mutex. */
  535. void
  536. rw_lock_debug_mutex_enter(void)
  537. /*==========================*/
  538. {
  539. loop:
  540. if (0 == mutex_enter_nowait(&rw_lock_debug_mutex)) {
  542. return;
  543. }
  545. os_event_reset(rw_lock_debug_event);
  547. rw_lock_debug_waiters = TRUE;
  549. if (0 == mutex_enter_nowait(&rw_lock_debug_mutex)) {
  551. return;
  552. }
  554. os_event_wait(rw_lock_debug_event);
  556. goto loop;
  557. }
  559. /**********************************************************************
  560. Releases the debug mutex. */
  562. void
  563. rw_lock_debug_mutex_exit(void)
  564. /*==========================*/
  565. {
  566. mutex_exit(&rw_lock_debug_mutex);
  568. if (rw_lock_debug_waiters) {
  569. rw_lock_debug_waiters = FALSE;
  570. os_event_set(rw_lock_debug_event);
  571. }
  572. }
  574. /**********************************************************************
  575. Inserts the debug information for an rw-lock. */
  577. void
  578. rw_lock_add_debug_info(
  579. /*===================*/
  580. rw_lock_t* lock, /* in: rw-lock */
  581. ulint pass, /* in: pass value */
  582. ulint lock_type, /* in: lock type */
  583. char* file_name, /* in: file where requested */
  584. ulint line) /* in: line where requested */
  585. {
  586. rw_lock_debug_t* info;
  588. ut_ad(lock);
  589. ut_ad(file_name);
  591. info = rw_lock_debug_create();
  593. rw_lock_debug_mutex_enter();
  595. info->file_name = file_name;
  596. info->line  = line;
  597. info->lock_type = lock_type;
  598. info->thread_id = os_thread_get_curr_id();
  599. info->pass = pass;
  601. UT_LIST_ADD_FIRST(list, lock->debug_list, info);
  603. rw_lock_debug_mutex_exit();
  605. if ((pass == 0) && (lock_type != RW_LOCK_WAIT_EX)) {
  606. sync_thread_add_level(lock, lock->level);
  607. }
  608. }
  610. /**********************************************************************
  611. Removes a debug information struct for an rw-lock. */
  613. void
  614. rw_lock_remove_debug_info(
  615. /*======================*/
  616. rw_lock_t* lock, /* in: rw-lock */
  617. ulint pass, /* in: pass value */
  618. ulint lock_type) /* in: lock type */
  619. {
  620. rw_lock_debug_t* info;
  622. ut_ad(lock);
  624. if ((pass == 0) && (lock_type != RW_LOCK_WAIT_EX)) {
  625. sync_thread_reset_level(lock);
  626. }
  628. rw_lock_debug_mutex_enter();
  630. info = UT_LIST_GET_FIRST(lock->debug_list);
  632. while (info != NULL) {
  633. if ((pass == info->pass)
  634.     && ((pass != 0)
  635. || (info->thread_id == os_thread_get_curr_id()))
  636.     && (info->lock_type == lock_type)) {
  638.      /* Found! */
  639.      UT_LIST_REMOVE(list, lock->debug_list, info);
  640. rw_lock_debug_mutex_exit();
  642.      rw_lock_debug_free(info);
  644.      return;
  645. }
  647. info = UT_LIST_GET_NEXT(list, info);
  648. }
  650. ut_error;
  651. }
  653. /**********************************************************************
  654. Sets the rw-lock latching level field. */
  656. void
  657. rw_lock_set_level(
  658. /*==============*/
  659. rw_lock_t* lock, /* in: rw-lock */
  660. ulint level) /* in: level */
  661. {
  662. lock->level = level;
  663. }
  665. /**********************************************************************
  666. Checks if the thread has locked the rw-lock in the specified mode, with
  667. the pass value == 0. */
  669. ibool
  670. rw_lock_own(
  671. /*========*/
  672. /* out: TRUE if locked */
  673. rw_lock_t* lock, /* in: rw-lock */
  674. ulint lock_type) /* in: lock type */
  675. {
  676. rw_lock_debug_t* info;
  678. ut_ad(lock);
  679. ut_ad(rw_lock_validate(lock));
  681. #ifndef UNIV_SYNC_DEBUG
  682. ut_error;
  683. #endif
  684. mutex_enter(&(lock->mutex));
  686. info = UT_LIST_GET_FIRST(lock->debug_list);
  688. while (info != NULL) {
  690. if ((info->thread_id == os_thread_get_curr_id())
  691.     && (info->pass == 0)
  692.     && (info->lock_type == lock_type)) {
  694. mutex_exit(&(lock->mutex));
  695.      /* Found! */
  697.      return(TRUE);
  698. }
  700. info = UT_LIST_GET_NEXT(list, info);
  701. }
  702. mutex_exit(&(lock->mutex));
  704. return(FALSE);
  705. }
  707. /**********************************************************************
  708. Checks if somebody has locked the rw-lock in the specified mode. */
  710. ibool
  711. rw_lock_is_locked(
  712. /*==============*/
  713. /* out: TRUE if locked */
  714. rw_lock_t* lock, /* in: rw-lock */
  715. ulint lock_type) /* in: lock type: RW_LOCK_SHARED,
  716. RW_LOCK_EX */
  717. {
  718. ibool ret = FALSE;
  720. ut_ad(lock);
  721. ut_ad(rw_lock_validate(lock));
  723. mutex_enter(&(lock->mutex));
  725. if (lock_type == RW_LOCK_SHARED) {
  726. if (lock->reader_count > 0) {
  727. ret = TRUE;
  728. }
  729. } else if (lock_type == RW_LOCK_EX) {
  730. if (lock->writer == RW_LOCK_EX) {
  731. ret = TRUE;
  732. }
  733. } else {
  734. ut_error;
  735. }
  737. mutex_exit(&(lock->mutex));
  739. return(ret);
  740. }
  742. /*******************************************************************
  743. Prints debug info of currently locked rw-locks. */
  745. void
  746. rw_lock_list_print_info(void)
  747. /*=========================*/
  748. {
  749. #ifndef UNIV_SYNC_DEBUG
  750. printf(
  751.    "Sorry, cannot give rw-lock list info in non-debug version!n");
  752. #else
  753. rw_lock_t* lock;
  754. ulint count = 0;
  755. rw_lock_debug_t* info;
  757. mutex_enter(&rw_lock_list_mutex);
  759. printf("----------------------------------------------n");
  760. printf("RW-LOCK INFOn");
  762. lock = UT_LIST_GET_FIRST(rw_lock_list);
  764. while (lock != NULL) {
  766. count++;
  768. mutex_enter(&(lock->mutex));
  770. if ((rw_lock_get_writer(lock) != RW_LOCK_NOT_LOCKED)
  771.     || (rw_lock_get_reader_count(lock) != 0)
  772.     || (rw_lock_get_waiters(lock) != 0)) {
  774. printf("RW-LOCK: %lx ", (ulint)lock);
  776. if (rw_lock_get_waiters(lock)) {
  777. printf(" Waiters for the lock existn");
  778. } else {
  779. printf("n");
  780. }
  781.     
  782. info = UT_LIST_GET_FIRST(lock->debug_list);
  783. while (info != NULL) {
  784. rw_lock_debug_print(info);
  785. info = UT_LIST_GET_NEXT(list, info);
  786. }
  787. }
  789. mutex_exit(&(lock->mutex));
  790. lock = UT_LIST_GET_NEXT(list, lock);
  791. }
  793. printf("Total number of rw-locks %ldn", count);
  794. mutex_exit(&rw_lock_list_mutex);
  795. #endif
  796. }
  798. /*******************************************************************
  799. Prints debug info of an rw-lock. */
  801. void
  802. rw_lock_print(
  803. /*==========*/
  804. rw_lock_t* lock) /* in: rw-lock */
  805. {
  806. #ifndef UNIV_SYNC_DEBUG
  807. printf(
  808.    "Sorry, cannot give rw-lock info in non-debug version!n");
  809. #else
  810. ulint count = 0;
  811. rw_lock_debug_t* info;
  813. printf("----------------------------------------------n");
  814. printf("RW-LOCK INFOn");
  815. printf("RW-LOCK: %lx ", (ulint)lock);
  817. mutex_enter(&(lock->mutex));
  818. if ((rw_lock_get_writer(lock) != RW_LOCK_NOT_LOCKED)
  819.     || (rw_lock_get_reader_count(lock) != 0)
  820.     || (rw_lock_get_waiters(lock) != 0)) {
  822. if (rw_lock_get_waiters(lock)) {
  823. printf(" Waiters for the lock existn");
  824. } else {
  825. printf("n");
  826. }
  827.     
  828. info = UT_LIST_GET_FIRST(lock->debug_list);
  829. while (info != NULL) {
  830. rw_lock_debug_print(info);
  831. info = UT_LIST_GET_NEXT(list, info);
  832. }
  833. }
  835. mutex_exit(&(lock->mutex));
  836. #endif
  837. }
  839. /*************************************************************************
  840. Prints info of a debug struct. */
  842. void
  843. rw_lock_debug_print(
  844. /*================*/
  845. rw_lock_debug_t* info) /* in: debug struct */
  846. {
  847. ulint rwt;
  849. rwt    = info->lock_type;
  851. printf("Locked: thread %ld file %s line %ld  ",
  852.      info->thread_id, info->file_name, info->line);
  853. if (rwt == RW_LOCK_SHARED) {
  854. printf("S-LOCK");
  855. } else if (rwt == RW_LOCK_EX) {
  856. printf("X-LOCK");
  857. } else if (rwt == RW_LOCK_WAIT_EX) {
  858. printf("WAIT X-LOCK");
  859. } else {
  860. ut_error;
  861. }
  862. if (info->pass != 0) {
  863. printf(" pass value %lu", info->pass);
  864. }
  865. printf("n");
  866. }
  868. /*******************************************************************
  869. Returns the number of currently locked rw-locks. Works only in the debug
  870. version. */
  872. ulint
  873. rw_lock_n_locked(void)
  874. /*==================*/
  875. {
  876. #ifndef UNIV_SYNC_DEBUG
  877. printf(
  878.    "Sorry, cannot give rw-lock info in non-debug version!n");
  879. ut_error;
  880. return(0);
  881. #else
  882. rw_lock_t* lock;
  883. ulint count = 0;
  885. mutex_enter(&rw_lock_list_mutex);
  887. lock = UT_LIST_GET_FIRST(rw_lock_list);
  889. while (lock != NULL) {
  890. mutex_enter(rw_lock_get_mutex(lock));
  892. if ((rw_lock_get_writer(lock) != RW_LOCK_NOT_LOCKED)
  893. || (rw_lock_get_reader_count(lock) != 0)) {
  894. count++;
  895. }
  897. mutex_exit(rw_lock_get_mutex(lock));
  898. lock = UT_LIST_GET_NEXT(list, lock);
  899. }
  901. mutex_exit(&rw_lock_list_mutex);
  903. return(count);
  904. #endif
  905. }