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

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

MySQL数据库

开发平台：

Visual C++

trx0purge.c：源码内容
  1. /******************************************************
  2. Purge old versions
  4. (c) 1996 Innobase Oy
  6. Created 3/26/1996 Heikki Tuuri
  7. *******************************************************/
  9. #include "trx0purge.h"
  11. #ifdef UNIV_NONINL
  12. #include "trx0purge.ic"
  13. #endif
  15. #include "fsp0fsp.h"
  16. #include "mach0data.h"
  17. #include "trx0rseg.h"
  18. #include "trx0trx.h"
  19. #include "trx0roll.h"
  20. #include "read0read.h"
  21. #include "fut0fut.h"
  22. #include "que0que.h"
  23. #include "row0purge.h"
  24. #include "row0upd.h"
  25. #include "trx0rec.h"
  26. #include "srv0que.h"
  27. #include "os0thread.h"
  29. /* The global data structure coordinating a purge */
  30. trx_purge_t* purge_sys = NULL;
  32. /* A dummy undo record used as a return value when we have a whole undo log
  33. which needs no purge */
  34. trx_undo_rec_t trx_purge_dummy_rec;
  36. /*********************************************************************
  37. Checks if trx_id is >= purge_view: then it is guaranteed that its update
  38. undo log still exists in the system. */
  40. ibool
  41. trx_purge_update_undo_must_exist(
  42. /*=============================*/
  43. /* out: TRUE if is sure that it is preserved, also
  44. if the function returns FALSE, it is possible that
  45. the undo log still exists in the system */
  46. dulint trx_id) /* in: transaction id */
  47. {
  48. #ifdef UNIV_SYNC_DEBUG
  49. ut_ad(rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED));
  50. #endif /* UNIV_SYNC_DEBUG */
  52. if (!read_view_sees_trx_id(purge_sys->view, trx_id)) {
  54. return(TRUE);
  55. }
  57. return(FALSE);
  58. }
  60. /*=================== PURGE RECORD ARRAY =============================*/
  62. /***********************************************************************
  63. Stores info of an undo log record during a purge. */
  64. static
  65. trx_undo_inf_t*
  66. trx_purge_arr_store_info(
  67. /*=====================*/
  68. /* out: pointer to the storage cell */
  69. dulint trx_no, /* in: transaction number */
  70. dulint undo_no)/* in: undo number */
  71. {
  72. trx_undo_inf_t* cell;
  73. trx_undo_arr_t* arr;
  74. ulint i;
  76. arr = purge_sys->arr;
  78. for (i = 0;; i++) {
  79. cell = trx_undo_arr_get_nth_info(arr, i);
  81. if (!(cell->in_use)) {
  82. /* Not in use, we may store here */
  83. cell->undo_no = undo_no;
  84. cell->trx_no = trx_no;
  85. cell->in_use = TRUE;
  87. arr->n_used++;
  89. return(cell);
  90. }
  91. }
  92. }
  94. /***********************************************************************
  95. Removes info of an undo log record during a purge. */
  96. UNIV_INLINE
  97. void
  98. trx_purge_arr_remove_info(
  99. /*======================*/
  100. trx_undo_inf_t* cell) /* in: pointer to the storage cell */
  101. {
  102. trx_undo_arr_t* arr;
  104. arr = purge_sys->arr;
  106. cell->in_use = FALSE;
  108. ut_ad(arr->n_used > 0);
  110. arr->n_used--;
  111. }
  113. /***********************************************************************
  114. Gets the biggest pair of a trx number and an undo number in a purge array. */
  115. static
  116. void
  117. trx_purge_arr_get_biggest(
  118. /*======================*/
  119. trx_undo_arr_t* arr, /* in: purge array */
  120. dulint* trx_no, /* out: transaction number: ut_dulint_zero
  121. if array is empty */
  122. dulint* undo_no)/* out: undo number */
  123. {
  124. trx_undo_inf_t* cell;
  125. dulint pair_trx_no;
  126. dulint pair_undo_no;
  127. int trx_cmp;
  128. ulint n_used;
  129. ulint i;
  130. ulint n;
  132. n = 0;
  133. n_used = arr->n_used;
  134. pair_trx_no = ut_dulint_zero;
  135. pair_undo_no = ut_dulint_zero;
  137. for (i = 0;; i++) {
  138. cell = trx_undo_arr_get_nth_info(arr, i);
  140. if (cell->in_use) {
  141. n++;
  142.   trx_cmp = ut_dulint_cmp(cell->trx_no, pair_trx_no);
  144. if ((trx_cmp > 0)
  145.     || ((trx_cmp == 0)
  146.         && (ut_dulint_cmp(cell->undo_no,
  147. pair_undo_no) >= 0))) {
  149. pair_trx_no = cell->trx_no;
  150. pair_undo_no = cell->undo_no;
  151. }
  152. }
  154. if (n == n_used) {
  155. *trx_no = pair_trx_no;
  156. *undo_no = pair_undo_no;
  158. return;
  159. }
  160. }
  161. }
  163. /********************************************************************
  164. Builds a purge 'query' graph. The actual purge is performed by executing
  165. this query graph. */
  166. static
  167. que_t*
  168. trx_purge_graph_build(void)
  169. /*=======================*/
  170. /* out, own: the query graph */
  171. {
  172. mem_heap_t* heap;
  173. que_fork_t* fork;
  174. que_thr_t* thr;
  175. /* que_thr_t* thr2; */
  177. heap = mem_heap_create(512);
  178. fork = que_fork_create(NULL, NULL, QUE_FORK_PURGE, heap);
  179. fork->trx = purge_sys->trx;
  181. thr = que_thr_create(fork, heap);
  183. thr->child = row_purge_node_create(thr, heap);  
  185. /* thr2 = que_thr_create(fork, fork, heap);
  187. thr2->child = row_purge_node_create(fork, thr2, heap);   */
  189. return(fork);
  190. }
  192. /************************************************************************
  193. Creates the global purge system control structure and inits the history
  194. mutex. */
  196. void
  197. trx_purge_sys_create(void)
  198. /*======================*/
  199. {
  200. #ifdef UNIV_SYNC_DEBUG
  201. ut_ad(mutex_own(&kernel_mutex));
  202. #endif /* UNIV_SYNC_DEBUG */
  204. purge_sys = mem_alloc(sizeof(trx_purge_t));
  206. purge_sys->state = TRX_STOP_PURGE;
  208. purge_sys->n_pages_handled = 0;
  210. purge_sys->purge_trx_no = ut_dulint_zero;
  211. purge_sys->purge_undo_no = ut_dulint_zero;
  212. purge_sys->next_stored = FALSE;
  214. rw_lock_create(&(purge_sys->latch));
  215. rw_lock_set_level(&(purge_sys->latch), SYNC_PURGE_LATCH);
  217. mutex_create(&(purge_sys->mutex));
  218. mutex_set_level(&(purge_sys->mutex), SYNC_PURGE_SYS);
  220. purge_sys->heap = mem_heap_create(256);
  222. purge_sys->arr = trx_undo_arr_create();
  224. purge_sys->sess = sess_open();
  226. purge_sys->trx = purge_sys->sess->trx;
  228. purge_sys->trx->type = TRX_PURGE;
  230. ut_a(trx_start_low(purge_sys->trx, ULINT_UNDEFINED));
  232. purge_sys->query = trx_purge_graph_build();
  234. purge_sys->view = read_view_oldest_copy_or_open_new(NULL,
  235. purge_sys->heap);
  236. }
  238. /*================ UNDO LOG HISTORY LIST =============================*/
  240. /************************************************************************
  241. Adds the update undo log as the first log in the history list. Removes the
  242. update undo log segment from the rseg slot if it is too big for reuse. */
  244. void
  245. trx_purge_add_update_undo_to_history(
  246. /*=================================*/
  247. trx_t* trx, /* in: transaction */
  248. page_t* undo_page, /* in: update undo log header page,
  249. x-latched */
  250. mtr_t* mtr) /* in: mtr */
  251. {
  252. trx_undo_t* undo;
  253. trx_rseg_t* rseg;
  254. trx_rsegf_t* rseg_header;
  255. trx_usegf_t* seg_header;
  256. trx_ulogf_t* undo_header;
  257. trx_upagef_t* page_header;
  258. ulint hist_size;
  260. undo = trx->update_undo;
  262. ut_ad(undo);
  264. rseg = undo->rseg;
  265. #ifdef UNIV_SYNC_DEBUG
  266. ut_ad(mutex_own(&(rseg->mutex)));
  267. #endif /* UNIV_SYNC_DEBUG */
  269. rseg_header = trx_rsegf_get(rseg->space, rseg->page_no, mtr);
  271. undo_header = undo_page + undo->hdr_offset;
  272. seg_header  = undo_page + TRX_UNDO_SEG_HDR;
  273. page_header = undo_page + TRX_UNDO_PAGE_HDR;
  275. if (undo->state != TRX_UNDO_CACHED) {
  276. /* The undo log segment will not be reused */
  278. if (undo->id >= TRX_RSEG_N_SLOTS) {
  279. fprintf(stderr,
  280. "InnoDB: Error: undo->id is %lun", (ulong) undo->id);
  281. ut_error;
  282. }
  284. trx_rsegf_set_nth_undo(rseg_header, undo->id, FIL_NULL, mtr);
  286. hist_size = mtr_read_ulint(rseg_header + TRX_RSEG_HISTORY_SIZE,
  287. MLOG_4BYTES, mtr);
  288. ut_ad(undo->size ==
  289. flst_get_len(seg_header + TRX_UNDO_PAGE_LIST, mtr));
  291. mlog_write_ulint(rseg_header + TRX_RSEG_HISTORY_SIZE,
  292. hist_size + undo->size, MLOG_4BYTES, mtr);
  293. }
  295. /* Add the log as the first in the history list */
  296. flst_add_first(rseg_header + TRX_RSEG_HISTORY,
  297. undo_header + TRX_UNDO_HISTORY_NODE, mtr);
  298. mutex_enter(&kernel_mutex);
  299. trx_sys->rseg_history_len++;
  300. mutex_exit(&kernel_mutex);
  302. /* Write the trx number to the undo log header */
  303. mlog_write_dulint(undo_header + TRX_UNDO_TRX_NO, trx->no, mtr);
  304. /* Write information about delete markings to the undo log header */
  306. if (!undo->del_marks) {
  307. mlog_write_ulint(undo_header + TRX_UNDO_DEL_MARKS, FALSE,
  308. MLOG_2BYTES, mtr);
  309. }
  311. if (rseg->last_page_no == FIL_NULL) {
  313. rseg->last_page_no = undo->hdr_page_no;
  314. rseg->last_offset = undo->hdr_offset;
  315. rseg->last_trx_no = trx->no;
  316. rseg->last_del_marks = undo->del_marks;
  317. }
  318. }
  320. /**************************************************************************
  321. Frees an undo log segment which is in the history list. Cuts the end of the
  322. history list at the youngest undo log in this segment. */
  323. static
  324. void
  325. trx_purge_free_segment(
  326. /*===================*/
  327. trx_rseg_t* rseg, /* in: rollback segment */
  328. fil_addr_t hdr_addr, /* in: the file address of log_hdr */
  329. ulint n_removed_logs) /* in: count of how many undo logs we
  330. will cut off from the end of the
  331. history list */
  332. {
  333. page_t* undo_page;
  334. trx_rsegf_t* rseg_hdr;
  335. trx_ulogf_t* log_hdr;
  336. trx_usegf_t* seg_hdr;
  337. ibool freed;
  338. ulint seg_size;
  339. ulint hist_size;
  340. ibool marked = FALSE;
  341. mtr_t mtr;
  343. /* fputs("Freeing an update undo log segmentn", stderr); */
  345. #ifdef UNIV_SYNC_DEBUG
  346. ut_ad(mutex_own(&(purge_sys->mutex)));
  347. #endif /* UNIV_SYNC_DEBUG */
  348. loop:
  349. mtr_start(&mtr);
  350. mutex_enter(&(rseg->mutex));
  352. rseg_hdr = trx_rsegf_get(rseg->space, rseg->page_no, &mtr);
  354. undo_page = trx_undo_page_get(rseg->space, hdr_addr.page, &mtr);
  355. seg_hdr = undo_page + TRX_UNDO_SEG_HDR;
  356. log_hdr = undo_page + hdr_addr.boffset;
  358. /* Mark the last undo log totally purged, so that if the system
  359. crashes, the tail of the undo log will not get accessed again. The
  360. list of pages in the undo log tail gets inconsistent during the
  361. freeing of the segment, and therefore purge should not try to access
  362. them again. */
  364. if (!marked) {
  365. mlog_write_ulint(log_hdr + TRX_UNDO_DEL_MARKS, FALSE,
  366. MLOG_2BYTES, &mtr);
  367. marked = TRUE;
  368. }
  370. freed = fseg_free_step_not_header(seg_hdr + TRX_UNDO_FSEG_HEADER,
  371. &mtr);
  372. if (!freed) {
  373. mutex_exit(&(rseg->mutex));
  374. mtr_commit(&mtr);
  376. goto loop;
  377. }
  379. /* The page list may now be inconsistent, but the length field
  380. stored in the list base node tells us how big it was before we
  381. started the freeing. */
  383. seg_size = flst_get_len(seg_hdr + TRX_UNDO_PAGE_LIST, &mtr);
  385. /* We may free the undo log segment header page; it must be freed
  386. within the same mtr as the undo log header is removed from the
  387. history list: otherwise, in case of a database crash, the segment
  388. could become inaccessible garbage in the file space. */
  390. flst_cut_end(rseg_hdr + TRX_RSEG_HISTORY,
  391. log_hdr + TRX_UNDO_HISTORY_NODE, n_removed_logs, &mtr);
  393. mutex_enter(&kernel_mutex);
  394. ut_ad(trx_sys->rseg_history_len >= n_removed_logs);
  395. trx_sys->rseg_history_len -= n_removed_logs;
  396. mutex_exit(&kernel_mutex);
  398. freed = FALSE;
  400. while (!freed) {
  401. /* Here we assume that a file segment with just the header
  402. page can be freed in a few steps, so that the buffer pool
  403. is not flooded with bufferfixed pages: see the note in
  404. fsp0fsp.c. */
  406. freed = fseg_free_step(seg_hdr + TRX_UNDO_FSEG_HEADER,
  407. &mtr);
  408. }
  410. hist_size = mtr_read_ulint(rseg_hdr + TRX_RSEG_HISTORY_SIZE,
  411. MLOG_4BYTES, &mtr);
  412. ut_ad(hist_size >= seg_size);
  414. mlog_write_ulint(rseg_hdr + TRX_RSEG_HISTORY_SIZE,
  415. hist_size - seg_size, MLOG_4BYTES, &mtr);
  417. ut_ad(rseg->curr_size >= seg_size);
  419. rseg->curr_size -= seg_size;
  421. mutex_exit(&(rseg->mutex));
  423. mtr_commit(&mtr);
  424. }
  426. /************************************************************************
  427. Removes unnecessary history data from a rollback segment. */
  428. static
  429. void
  430. trx_purge_truncate_rseg_history(
  431. /*============================*/
  432. trx_rseg_t* rseg, /* in: rollback segment */
  433. dulint limit_trx_no, /* in: remove update undo logs whose
  434. trx number is < limit_trx_no */
  435. dulint limit_undo_no) /* in: if transaction number is equal
  436. to limit_trx_no, truncate undo records
  437. with undo number < limit_undo_no */
  438. {
  439. fil_addr_t hdr_addr;
  440. fil_addr_t prev_hdr_addr;
  441. trx_rsegf_t* rseg_hdr;
  442. page_t* undo_page;
  443. trx_ulogf_t* log_hdr;
  444. trx_usegf_t* seg_hdr;
  445. int cmp;
  446. ulint n_removed_logs = 0;
  447. mtr_t mtr;
  449. #ifdef UNIV_SYNC_DEBUG
  450. ut_ad(mutex_own(&(purge_sys->mutex)));
  451. #endif /* UNIV_SYNC_DEBUG */
  453. mtr_start(&mtr);
  454. mutex_enter(&(rseg->mutex));
  456. rseg_hdr = trx_rsegf_get(rseg->space, rseg->page_no, &mtr);
  458. hdr_addr = trx_purge_get_log_from_hist(
  459. flst_get_last(rseg_hdr + TRX_RSEG_HISTORY, &mtr));
  460. loop:
  461. if (hdr_addr.page == FIL_NULL) {
  463. mutex_exit(&(rseg->mutex));
  465. mtr_commit(&mtr);
  467. return;
  468. }
  470. undo_page = trx_undo_page_get(rseg->space, hdr_addr.page, &mtr);
  472. log_hdr = undo_page + hdr_addr.boffset;
  474.   cmp = ut_dulint_cmp(mach_read_from_8(log_hdr + TRX_UNDO_TRX_NO),
  475.      limit_trx_no);
  476. if (cmp == 0) {
  477. trx_undo_truncate_start(rseg, rseg->space, hdr_addr.page,
  478. hdr_addr.boffset, limit_undo_no);
  479. }
  481. if (cmp >= 0) {
  482. mutex_enter(&kernel_mutex);
  483. ut_a(trx_sys->rseg_history_len >= n_removed_logs);
  484. trx_sys->rseg_history_len -= n_removed_logs;
  485. mutex_exit(&kernel_mutex);
  487. flst_truncate_end(rseg_hdr + TRX_RSEG_HISTORY,
  488.      log_hdr + TRX_UNDO_HISTORY_NODE,
  489. n_removed_logs, &mtr);
  491. mutex_exit(&(rseg->mutex));
  492. mtr_commit(&mtr);
  494. return;
  495. }
  497. prev_hdr_addr = trx_purge_get_log_from_hist(
  498.   flst_get_prev_addr(log_hdr + TRX_UNDO_HISTORY_NODE,
  499. &mtr));
  500. n_removed_logs++;
  502. seg_hdr = undo_page + TRX_UNDO_SEG_HDR;
  504. if ((mach_read_from_2(seg_hdr + TRX_UNDO_STATE) == TRX_UNDO_TO_PURGE)
  505.      && (mach_read_from_2(log_hdr + TRX_UNDO_NEXT_LOG) == 0)) {
  507. /* We can free the whole log segment */
  509. mutex_exit(&(rseg->mutex));
  510. mtr_commit(&mtr);
  512. trx_purge_free_segment(rseg, hdr_addr, n_removed_logs);
  514. n_removed_logs = 0;
  515. } else {
  516. mutex_exit(&(rseg->mutex));
  517. mtr_commit(&mtr);
  518. }
  520. mtr_start(&mtr);
  521. mutex_enter(&(rseg->mutex));
  523. rseg_hdr = trx_rsegf_get(rseg->space, rseg->page_no, &mtr);
  525. hdr_addr = prev_hdr_addr;
  527. goto loop;
  528. }
  530. /************************************************************************
  531. Removes unnecessary history data from rollback segments. NOTE that when this
  532. function is called, the caller must not have any latches on undo log pages! */
  533. static
  534. void
  535. trx_purge_truncate_history(void)
  536. /*============================*/
  537. {
  538. trx_rseg_t* rseg;
  539. dulint limit_trx_no;
  540. dulint limit_undo_no;
  542. #ifdef UNIV_SYNC_DEBUG
  543. ut_ad(mutex_own(&(purge_sys->mutex)));
  544. #endif /* UNIV_SYNC_DEBUG */
  546. trx_purge_arr_get_biggest(purge_sys->arr, &limit_trx_no,
  547. &limit_undo_no);
  549. if (ut_dulint_cmp(limit_trx_no, ut_dulint_zero) == 0) {
  551. limit_trx_no = purge_sys->purge_trx_no;
  552. limit_undo_no = purge_sys->purge_undo_no;
  553. }
  555. /* We play safe and set the truncate limit at most to the purge view
  556. low_limit number, though this is not necessary */
  558. if (ut_dulint_cmp(limit_trx_no, purge_sys->view->low_limit_no) >= 0) {
  559. limit_trx_no = purge_sys->view->low_limit_no;
  560. limit_undo_no = ut_dulint_zero;
  561. }
  563. ut_ad((ut_dulint_cmp(limit_trx_no,
  564. purge_sys->view->low_limit_no) <= 0));
  566. rseg = UT_LIST_GET_FIRST(trx_sys->rseg_list);
  568. while (rseg) {
  569. trx_purge_truncate_rseg_history(rseg, limit_trx_no,
  570. limit_undo_no);
  571. rseg = UT_LIST_GET_NEXT(rseg_list, rseg);
  572. }
  573. }
  575. /************************************************************************
  576. Does a truncate if the purge array is empty. NOTE that when this function is
  577. called, the caller must not have any latches on undo log pages! */
  578. UNIV_INLINE
  579. ibool
  580. trx_purge_truncate_if_arr_empty(void)
  581. /*=================================*/
  582. /* out: TRUE if array empty */
  583. {
  584. #ifdef UNIV_SYNC_DEBUG
  585. ut_ad(mutex_own(&(purge_sys->mutex)));
  586. #endif /* UNIV_SYNC_DEBUG */
  588. if (purge_sys->arr->n_used == 0) {
  590. trx_purge_truncate_history();
  592. return(TRUE);
  593. }
  595. return(FALSE);
  596. }
  598. /***************************************************************************
  599. Updates the last not yet purged history log info in rseg when we have purged
  600. a whole undo log. Advances also purge_sys->purge_trx_no past the purged log. */
  601. static 
  602. void
  603. trx_purge_rseg_get_next_history_log(
  604. /*================================*/
  605. trx_rseg_t* rseg) /* in: rollback segment */
  606. {
  607. page_t*  undo_page;
  608. trx_ulogf_t* log_hdr;
  609. trx_usegf_t* seg_hdr;
  610. fil_addr_t prev_log_addr;
  611. dulint trx_no;
  612. ibool del_marks;
  613. mtr_t mtr;
  615. #ifdef UNIV_SYNC_DEBUG
  616. ut_ad(mutex_own(&(purge_sys->mutex)));
  617. #endif /* UNIV_SYNC_DEBUG */
  619. mutex_enter(&(rseg->mutex));
  621. ut_a(rseg->last_page_no != FIL_NULL);
  623. purge_sys->purge_trx_no = ut_dulint_add(rseg->last_trx_no, 1);
  624. purge_sys->purge_undo_no = ut_dulint_zero;
  625. purge_sys->next_stored = FALSE;
  627. mtr_start(&mtr);
  629. undo_page = trx_undo_page_get_s_latched(rseg->space,
  630. rseg->last_page_no, &mtr);
  631. log_hdr = undo_page + rseg->last_offset;
  632. seg_hdr = undo_page + TRX_UNDO_SEG_HDR;
  634. /* Increase the purge page count by one for every handled log */
  636. purge_sys->n_pages_handled++;
  638. prev_log_addr = trx_purge_get_log_from_hist(
  639.  flst_get_prev_addr(log_hdr + TRX_UNDO_HISTORY_NODE,
  640. &mtr));
  641. if (prev_log_addr.page == FIL_NULL) {
  642. /* No logs left in the history list */
  644. rseg->last_page_no = FIL_NULL;
  646. mutex_exit(&(rseg->mutex));
  647. mtr_commit(&mtr);
  649. mutex_enter(&kernel_mutex);
  651. /* Add debug code to track history list corruption reported
  652. on the MySQL mailing list on Nov 9, 2004. The fut0lst.c
  653. file-based list was corrupt. The prev node pointer was
  654. FIL_NULL, even though the list length was over 8 million nodes!
  655. We assume that purge truncates the history list in moderate
  656. size pieces, and if we here reach the head of the list, the
  657. list cannot be longer than 20 000 undo logs now. */
  659. if (trx_sys->rseg_history_len > 20000) {
  660. ut_print_timestamp(stderr);
  661. fprintf(stderr,
  662. "  InnoDB: Warning: purge reached the head of the history list,n"
  663. "InnoDB: but its length is still reported as %lu! Make a detailed bugn"
  664. "InnoDB: report, and post it to bugs.mysql.comn",
  665. (ulong)trx_sys->rseg_history_len);
  666. }
  668. mutex_exit(&kernel_mutex);
  670. return;
  671. }
  673. mutex_exit(&(rseg->mutex));
  674. mtr_commit(&mtr);
  676. /* Read the trx number and del marks from the previous log header */
  677. mtr_start(&mtr);
  679. log_hdr = trx_undo_page_get_s_latched(rseg->space,
  680. prev_log_addr.page, &mtr)
  681.   + prev_log_addr.boffset;
  683. trx_no = mach_read_from_8(log_hdr + TRX_UNDO_TRX_NO);
  685. del_marks = mach_read_from_2(log_hdr + TRX_UNDO_DEL_MARKS);
  687. mtr_commit(&mtr);
  689. mutex_enter(&(rseg->mutex));
  691. rseg->last_page_no = prev_log_addr.page;
  692. rseg->last_offset = prev_log_addr.boffset;
  693. rseg->last_trx_no = trx_no;
  694. rseg->last_del_marks = del_marks;
  696. mutex_exit(&(rseg->mutex));
  697. }
  699. /***************************************************************************
  700. Chooses the next undo log to purge and updates the info in purge_sys. This
  701. function is used to initialize purge_sys when the next record to purge is
  702. not known, and also to update the purge system info on the next record when
  703. purge has handled the whole undo log for a transaction. */
  704. static 
  705. void
  706. trx_purge_choose_next_log(void)
  707. /*===========================*/
  708. {
  709. trx_undo_rec_t* rec;
  710. trx_rseg_t* rseg;
  711. trx_rseg_t* min_rseg;
  712. dulint min_trx_no;
  713. ulint space = 0;   /* remove warning (??? bug ???) */
  714. ulint page_no = 0; /* remove warning (??? bug ???) */
  715. ulint offset = 0;  /* remove warning (??? bug ???) */
  716. mtr_t mtr;
  718. #ifdef UNIV_SYNC_DEBUG
  719. ut_ad(mutex_own(&(purge_sys->mutex)));
  720. #endif /* UNIV_SYNC_DEBUG */
  721. ut_ad(purge_sys->next_stored == FALSE);
  723. rseg = UT_LIST_GET_FIRST(trx_sys->rseg_list);
  725. min_trx_no = ut_dulint_max;
  727. min_rseg = NULL;
  729. while (rseg) {
  730. mutex_enter(&(rseg->mutex));
  732. if (rseg->last_page_no != FIL_NULL) {
  734. if ((min_rseg == NULL)
  735.     || (ut_dulint_cmp(min_trx_no, rseg->last_trx_no)
  736.      > 0)) {
  738. min_rseg = rseg;
  739. min_trx_no = rseg->last_trx_no;
  740. space = rseg->space;
  741. ut_a(space == 0); /* We assume in purge of
  742. externally stored fields
  743. that space id == 0 */
  744. page_no = rseg->last_page_no;
  745. offset = rseg->last_offset;
  746. }
  747. }
  749. mutex_exit(&(rseg->mutex));
  751. rseg = UT_LIST_GET_NEXT(rseg_list, rseg);
  752. }
  754. if (min_rseg == NULL) {
  756. return;
  757. }
  759. mtr_start(&mtr);
  761. if (!min_rseg->last_del_marks) {
  762. /* No need to purge this log */
  764. rec = &trx_purge_dummy_rec;
  765. } else {
  766. rec = trx_undo_get_first_rec(space, page_no, offset,
  767. RW_S_LATCH, &mtr);
  768. if (rec == NULL) {
  769. /* Undo log empty */
  771. rec = &trx_purge_dummy_rec;
  772. }
  773. }
  775. purge_sys->next_stored = TRUE;
  776. purge_sys->rseg = min_rseg;
  778. purge_sys->hdr_page_no = page_no;
  779. purge_sys->hdr_offset = offset;
  781. purge_sys->purge_trx_no = min_trx_no;
  783. if (rec == &trx_purge_dummy_rec) {
  785. purge_sys->purge_undo_no = ut_dulint_zero;
  786. purge_sys->page_no = page_no;
  787. purge_sys->offset = 0;
  788. } else {
  789. purge_sys->purge_undo_no = trx_undo_rec_get_undo_no(rec);
  791. purge_sys->page_no = buf_frame_get_page_no(rec);
  792. purge_sys->offset = rec - buf_frame_align(rec);
  793. }
  795. mtr_commit(&mtr);
  796. }
  798. /***************************************************************************
  799. Gets the next record to purge and updates the info in the purge system. */
  800. static
  801. trx_undo_rec_t*
  802. trx_purge_get_next_rec(
  803. /*===================*/
  804. /* out: copy of an undo log record or
  805. pointer to the dummy undo log record */
  806. mem_heap_t* heap) /* in: memory heap where copied */
  807. {
  808. trx_undo_rec_t* rec;
  809. trx_undo_rec_t* rec_copy;
  810. trx_undo_rec_t* rec2;
  811. trx_undo_rec_t* next_rec;
  812. page_t*  undo_page;
  813. page_t*  page;
  814. ulint offset;
  815. ulint page_no;
  816. ulint space;
  817. ulint type;
  818. ulint cmpl_info;
  819. mtr_t mtr;
  821. #ifdef UNIV_SYNC_DEBUG
  822. ut_ad(mutex_own(&(purge_sys->mutex)));
  823. #endif /* UNIV_SYNC_DEBUG */
  824. ut_ad(purge_sys->next_stored);
  826. space = purge_sys->rseg->space;
  827. page_no = purge_sys->page_no;
  828. offset = purge_sys->offset;
  830. if (offset == 0) {
  831. /* It is the dummy undo log record, which means that there is
  832. no need to purge this undo log */
  834. trx_purge_rseg_get_next_history_log(purge_sys->rseg);
  836. /* Look for the next undo log and record to purge */
  838. trx_purge_choose_next_log();
  840. return(&trx_purge_dummy_rec);
  841. }
  843. mtr_start(&mtr);
  845. undo_page = trx_undo_page_get_s_latched(space, page_no, &mtr);
  846. rec = undo_page + offset;
  848. rec2 = rec;
  850. for (;;) {
  851. /* Try first to find the next record which requires a purge
  852. operation from the same page of the same undo log */
  854. next_rec = trx_undo_page_get_next_rec(rec2,
  855. purge_sys->hdr_page_no,
  856. purge_sys->hdr_offset);
  857. if (next_rec == NULL) {
  858. rec2 = trx_undo_get_next_rec(rec2,
  859. purge_sys->hdr_page_no,
  860. purge_sys->hdr_offset, &mtr);
  861. break;
  862. }
  864. rec2 = next_rec;
  866. type = trx_undo_rec_get_type(rec2);
  868. if (type == TRX_UNDO_DEL_MARK_REC) {
  870. break;
  871. }     
  873. cmpl_info = trx_undo_rec_get_cmpl_info(rec2);
  875. if (trx_undo_rec_get_extern_storage(rec2)) {
  876. break;
  877. }
  879. if ((type == TRX_UNDO_UPD_EXIST_REC)
  880. && !(cmpl_info & UPD_NODE_NO_ORD_CHANGE)) {
  881.           break;
  882.     }
  883. }
  885. if (rec2 == NULL) {
  886. mtr_commit(&mtr);
  888. trx_purge_rseg_get_next_history_log(purge_sys->rseg);
  890. /* Look for the next undo log and record to purge */
  892. trx_purge_choose_next_log();
  894. mtr_start(&mtr);
  896. undo_page = trx_undo_page_get_s_latched(space, page_no, &mtr);
  898. rec = undo_page + offset;
  899. } else {
  900. page = buf_frame_align(rec2);
  902. purge_sys->purge_undo_no = trx_undo_rec_get_undo_no(rec2);
  903. purge_sys->page_no = buf_frame_get_page_no(page);
  904. purge_sys->offset = rec2 - page;
  906. if (undo_page != page) {
  907. /* We advance to a new page of the undo log: */
  908. purge_sys->n_pages_handled++;
  909. }
  910. }
  912. rec_copy = trx_undo_rec_copy(rec, heap);
  914. mtr_commit(&mtr);
  916. return(rec_copy);
  917. }
  919. /************************************************************************
  920. Fetches the next undo log record from the history list to purge. It must be
  921. released with the corresponding release function. */
  923. trx_undo_rec_t*
  924. trx_purge_fetch_next_rec(
  925. /*=====================*/
  926. /* out: copy of an undo log record or
  927. pointer to the dummy undo log record
  928. &trx_purge_dummy_rec, if the whole undo log
  929. can skipped in purge; NULL if none left */
  930. dulint* roll_ptr,/* out: roll pointer to undo record */
  931. trx_undo_inf_t** cell, /* out: storage cell for the record in the
  932. purge array */
  933. mem_heap_t* heap) /* in: memory heap where copied */
  934. {
  935. trx_undo_rec_t* undo_rec;
  937. mutex_enter(&(purge_sys->mutex));
  939. if (purge_sys->state == TRX_STOP_PURGE) {
  940. trx_purge_truncate_if_arr_empty();
  942. mutex_exit(&(purge_sys->mutex));
  944. return(NULL);
  945. }
  947. if (!purge_sys->next_stored) {
  948. trx_purge_choose_next_log();
  950. if (!purge_sys->next_stored) {
  951. purge_sys->state = TRX_STOP_PURGE;
  953. trx_purge_truncate_if_arr_empty();
  955. if (srv_print_thread_releases) {
  956. fprintf(stderr,
  957. "Purge: No logs left in the history list; pages handled %lun",
  958. (ulong) purge_sys->n_pages_handled);
  959. }
  961. mutex_exit(&(purge_sys->mutex));
  963. return(NULL);
  964. }
  965. }
  967. if (purge_sys->n_pages_handled >= purge_sys->handle_limit) {
  969. purge_sys->state = TRX_STOP_PURGE;
  971. trx_purge_truncate_if_arr_empty();
  973. mutex_exit(&(purge_sys->mutex));
  975. return(NULL);
  976. }
  978. if (ut_dulint_cmp(purge_sys->purge_trx_no,
  979. purge_sys->view->low_limit_no) >= 0) {
  980. purge_sys->state = TRX_STOP_PURGE;
  982. trx_purge_truncate_if_arr_empty();
  984. mutex_exit(&(purge_sys->mutex));
  986. return(NULL);
  987. }
  989. /* fprintf(stderr, "Thread %lu purging trx %lu undo record %lun",
  990. os_thread_get_curr_id(),
  991. ut_dulint_get_low(purge_sys->purge_trx_no),
  992. ut_dulint_get_low(purge_sys->purge_undo_no)); */
  994. *roll_ptr = trx_undo_build_roll_ptr(FALSE, (purge_sys->rseg)->id,
  995. purge_sys->page_no,
  996. purge_sys->offset);
  998. *cell = trx_purge_arr_store_info(purge_sys->purge_trx_no,
  999.  purge_sys->purge_undo_no);
  1001. ut_ad(ut_dulint_cmp(purge_sys->purge_trx_no,
  1002.     (purge_sys->view)->low_limit_no) < 0);
  1004. /* The following call will advance the stored values of purge_trx_no
  1005. and purge_undo_no, therefore we had to store them first */
  1007. undo_rec = trx_purge_get_next_rec(heap);
  1009. mutex_exit(&(purge_sys->mutex));
  1011. return(undo_rec);
  1012. }
  1014. /***********************************************************************
  1015. Releases a reserved purge undo record. */
  1017. void
  1018. trx_purge_rec_release(
  1019. /*==================*/
  1020. trx_undo_inf_t* cell) /* in: storage cell */
  1021. {
  1022. trx_undo_arr_t* arr;
  1024. mutex_enter(&(purge_sys->mutex));
  1026. arr = purge_sys->arr;
  1028. trx_purge_arr_remove_info(cell);
  1030. mutex_exit(&(purge_sys->mutex));
  1031. }
  1033. /***********************************************************************
  1034. This function runs a purge batch. */
  1036. ulint
  1037. trx_purge(void)
  1038. /*===========*/
  1039. /* out: number of undo log pages handled in
  1040. the batch */
  1041. {
  1042. que_thr_t* thr;
  1043. /* que_thr_t* thr2; */
  1044. ulint old_pages_handled;
  1046. mutex_enter(&(purge_sys->mutex));
  1048. if (purge_sys->trx->n_active_thrs > 0) {
  1050. mutex_exit(&(purge_sys->mutex));
  1052. /* Should not happen */
  1054. ut_error;
  1056. return(0);
  1057. }
  1059. rw_lock_x_lock(&(purge_sys->latch));
  1061. mutex_enter(&kernel_mutex);
  1063. /* Close and free the old purge view */
  1065. read_view_close(purge_sys->view);
  1066. purge_sys->view = NULL;
  1067. mem_heap_empty(purge_sys->heap);
  1069. /* Determine how much data manipulation language (DML) statements
  1070. need to be delayed in order to reduce the lagging of the purge
  1071. thread. */
  1072. srv_dml_needed_delay = 0; /* in microseconds; default: no delay */
  1074. /* If we cannot advance the 'purge view' because of an old
  1075. 'consistent read view', then the DML statements cannot be delayed.
  1076. Also, srv_max_purge_lag <= 0 means 'infinity'. */
  1077. if (srv_max_purge_lag > 0
  1078. && !UT_LIST_GET_LAST(trx_sys->view_list)) {
  1079. float ratio = (float) trx_sys->rseg_history_len
  1080. / srv_max_purge_lag;
  1081. if (ratio > ULINT_MAX / 10000) {
  1082. /* Avoid overflow: maximum delay is 4295 seconds */
  1083. srv_dml_needed_delay = ULINT_MAX;
  1084. } else if (ratio > 1) {
  1085. /* If the history list length exceeds the
  1086. innodb_max_purge_lag, the
  1087. data manipulation statements are delayed
  1088. by at least 5000 microseconds. */
  1089. srv_dml_needed_delay = (ulint) ((ratio - .5) * 10000);
  1090. }
  1091. }
  1093. purge_sys->view = read_view_oldest_copy_or_open_new(NULL,
  1094. purge_sys->heap);
  1095. mutex_exit(&kernel_mutex);
  1097. rw_lock_x_unlock(&(purge_sys->latch));
  1099. purge_sys->state = TRX_PURGE_ON;
  1101. /* Handle at most 20 undo log pages in one purge batch */
  1103. purge_sys->handle_limit = purge_sys->n_pages_handled + 20;
  1105. old_pages_handled = purge_sys->n_pages_handled;
  1107. mutex_exit(&(purge_sys->mutex));
  1109. mutex_enter(&kernel_mutex);
  1111. thr = que_fork_start_command(purge_sys->query);
  1113. ut_ad(thr);
  1115. /* thr2 = que_fork_start_command(purge_sys->query);
  1117. ut_ad(thr2); */
  1120. mutex_exit(&kernel_mutex);
  1122. /* srv_que_task_enqueue(thr2); */
  1124. if (srv_print_thread_releases) {
  1126. fputs("Starting purgen", stderr);
  1127. }
  1129. que_run_threads(thr);
  1131. if (srv_print_thread_releases) {
  1133. fprintf(stderr,
  1134. "Purge ends; pages handled %lun",
  1135. (ulong) purge_sys->n_pages_handled);
  1136. }
  1138. return(purge_sys->n_pages_handled - old_pages_handled);
  1139. }
  1141. /**********************************************************************
  1142. Prints information of the purge system to stderr. */
  1144. void
  1145. trx_purge_sys_print(void)
  1146. /*=====================*/
  1147. {
  1148. fprintf(stderr, "InnoDB: Purge system view:n");
  1149. read_view_print(purge_sys->view);
  1151. fprintf(stderr, "InnoDB: Purge trx n:o %lu %lu, undo n_o %lu %lun",
  1152. (ulong) ut_dulint_get_high(purge_sys->purge_trx_no),
  1153. (ulong) ut_dulint_get_low(purge_sys->purge_trx_no),
  1154. (ulong) ut_dulint_get_high(purge_sys->purge_undo_no),
  1155. (ulong) ut_dulint_get_low(purge_sys->purge_undo_no));
  1156. fprintf(stderr,
  1157. "InnoDB: Purge next stored %lu, page_no %lu, offset %lu,n"
  1158. "InnoDB: Purge hdr_page_no %lu, hdr_offset %lun",
  1159. (ulong) purge_sys->next_stored,
  1160. (ulong) purge_sys->page_no,
  1161. (ulong) purge_sys->offset,
  1162. (ulong) purge_sys->hdr_page_no,
  1163. (ulong) purge_sys->hdr_offset);
  1164. }