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

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. The transaction
  3. (c) 1996 Innobase Oy
  4. Created 3/26/1996 Heikki Tuuri
  5. *******************************************************/
  6. #include "trx0trx.h"
  7. #ifdef UNIV_NONINL
  8. #include "trx0trx.ic"
  9. #endif
  10. #include "trx0undo.h"
  11. #include "trx0rseg.h"
  12. #include "log0log.h"
  13. #include "que0que.h"
  14. #include "lock0lock.h"
  15. #include "trx0roll.h"
  16. #include "usr0sess.h"
  17. #include "read0read.h"
  18. #include "srv0srv.h"
  19. #include "thr0loc.h"
  20. #include "btr0sea.h"
  21. #include "os0proc.h"
  22. /* Copy of the prototype for innobase_mysql_print_thd: this
  23. copy MUST be equal to the one in mysql/sql/ha_innodb.cc ! */
  24. void innobase_mysql_print_thd(
  25. FILE* f,
  26. void* thd);
  27. /* Dummy session used currently in MySQL interface */
  28. sess_t* trx_dummy_sess = NULL;
  29. /* Number of transactions currently allocated for MySQL: protected by
  30. the kernel mutex */
  31. ulint trx_n_mysql_transactions = 0;
  32. /*****************************************************************
  33. Starts the transaction if it is not yet started. */
  34. void
  35. trx_start_if_not_started_noninline(
  36. /*===============================*/
  37. trx_t*  trx) /* in: transaction */
  38. {
  39.         trx_start_if_not_started(trx);
  40. }
  41. /********************************************************************
  42. Retrieves the error_info field from a trx. */
  43. void*
  44. trx_get_error_info(
  45. /*===============*/
  46.      /* out: the error info */
  47. trx_t*  trx) /* in: trx object */
  48. {
  49.         return(trx->error_info);
  50. }
  51. /********************************************************************
  52. Creates and initializes a transaction object. */
  53. trx_t*
  54. trx_create(
  55. /*=======*/
  56. /* out, own: the transaction */
  57. sess_t* sess) /* in: session or NULL */
  58. {
  59. trx_t* trx;
  60. #ifdef UNIV_SYNC_DEBUG
  61. ut_ad(mutex_own(&kernel_mutex));
  62. #endif /* UNIV_SYNC_DEBUG */
  63. trx = mem_alloc(sizeof(trx_t));
  64. trx->magic_n = TRX_MAGIC_N;
  65. trx->op_info = "";
  66. trx->type = TRX_USER;
  67. trx->conc_state = TRX_NOT_STARTED;
  68. trx->start_time = time(NULL);
  69. trx->isolation_level = TRX_ISO_REPEATABLE_READ;
  70. trx->id = ut_dulint_zero;
  71. trx->no = ut_dulint_max;
  72. trx->check_foreigns = TRUE;
  73. trx->check_unique_secondary = TRUE;
  74. trx->flush_log_later = FALSE;
  75. trx->must_flush_log_later = FALSE;
  76. trx->dict_operation = FALSE;
  77. trx->mysql_thd = NULL;
  78. trx->mysql_query_str = NULL;
  79. trx->n_mysql_tables_in_use = 0;
  80. trx->mysql_n_tables_locked = 0;
  81. trx->mysql_log_file_name = NULL;
  82. trx->mysql_log_offset = 0;
  83. trx->mysql_master_log_file_name = "";
  84. trx->mysql_master_log_pos = 0;
  85. trx->repl_wait_binlog_name = NULL;
  86. trx->repl_wait_binlog_pos = 0;
  87. mutex_create(&(trx->undo_mutex));
  88. mutex_set_level(&(trx->undo_mutex), SYNC_TRX_UNDO);
  89. trx->rseg = NULL;
  90. trx->undo_no = ut_dulint_zero;
  91. trx->last_sql_stat_start.least_undo_no = ut_dulint_zero;
  92. trx->insert_undo = NULL;
  93. trx->update_undo = NULL;
  94. trx->undo_no_arr = NULL;
  95. trx->error_state = DB_SUCCESS;
  96. trx->sess = sess;
  97. trx->que_state = TRX_QUE_RUNNING;
  98. trx->n_active_thrs = 0;
  99. trx->handling_signals = FALSE;
  100. UT_LIST_INIT(trx->signals);
  101. UT_LIST_INIT(trx->reply_signals);
  102. trx->graph = NULL;
  103. trx->wait_lock = NULL;
  104. trx->was_chosen_as_deadlock_victim = FALSE;
  105. UT_LIST_INIT(trx->wait_thrs);
  106. trx->lock_heap = mem_heap_create_in_buffer(256);
  107. UT_LIST_INIT(trx->trx_locks);
  108. UT_LIST_INIT(trx->trx_savepoints);
  109. trx->dict_operation_lock_mode = 0;
  110. trx->has_search_latch = FALSE;
  111. trx->search_latch_timeout = BTR_SEA_TIMEOUT;
  112. trx->declared_to_be_inside_innodb = FALSE;
  113. trx->n_tickets_to_enter_innodb = 0;
  114. trx->auto_inc_lock = NULL;
  115. trx->n_lock_table_exp = 0;
  116. trx->read_view_heap = mem_heap_create(256);
  117. trx->read_view = NULL;
  118. return(trx);
  119. }
  120. /************************************************************************
  121. Creates a transaction object for MySQL. */
  122. trx_t*
  123. trx_allocate_for_mysql(void)
  124. /*========================*/
  125. /* out, own: transaction object */
  126. {
  127. trx_t* trx;
  128. mutex_enter(&kernel_mutex);
  129. /* Open a dummy session */
  130. if (!trx_dummy_sess) {
  131. trx_dummy_sess = sess_open();
  132. }
  133. trx = trx_create(trx_dummy_sess);
  134. trx_n_mysql_transactions++;
  135. UT_LIST_ADD_FIRST(mysql_trx_list, trx_sys->mysql_trx_list, trx);
  136. mutex_exit(&kernel_mutex);
  137. trx->mysql_thread_id = os_thread_get_curr_id();
  138. trx->mysql_process_no = os_proc_get_number();
  139. return(trx);
  140. }
  141. /************************************************************************
  142. Creates a transaction object for background operations by the master thread. */
  143. trx_t*
  144. trx_allocate_for_background(void)
  145. /*=============================*/
  146. /* out, own: transaction object */
  147. {
  148. trx_t* trx;
  149. mutex_enter(&kernel_mutex);
  150. /* Open a dummy session */
  151. if (!trx_dummy_sess) {
  152. trx_dummy_sess = sess_open();
  153. }
  154. trx = trx_create(trx_dummy_sess);
  155. mutex_exit(&kernel_mutex);
  156. return(trx);
  157. }
  158. /************************************************************************
  159. Releases the search latch if trx has reserved it. */
  160. void
  161. trx_search_latch_release_if_reserved(
  162. /*=================================*/
  163.         trx_t*     trx) /* in: transaction */
  164. {
  165.    if (trx->has_search_latch) {
  166.      rw_lock_s_unlock(&btr_search_latch);
  167.      trx->has_search_latch = FALSE;
  168.    }
  169. }
  170. /************************************************************************
  171. Frees a transaction object. */
  172. void
  173. trx_free(
  174. /*=====*/
  175. trx_t* trx) /* in, own: trx object */
  176. {
  177. #ifdef UNIV_SYNC_DEBUG
  178. ut_ad(mutex_own(&kernel_mutex));
  179. #endif /* UNIV_SYNC_DEBUG */
  180. if (trx->declared_to_be_inside_innodb) {
  181.         ut_print_timestamp(stderr);
  182. fputs(
  183. "  InnoDB: Error: Freeing a trx which is declared to be processingn"
  184. "InnoDB: inside InnoDB.n", stderr);
  185. trx_print(stderr, trx);
  186. putc('n', stderr);
  187. }
  188. if (trx->n_mysql_tables_in_use != 0
  189.     || trx->mysql_n_tables_locked != 0) {
  190. ut_print_timestamp(stderr);
  191. fprintf(stderr,
  192. "  InnoDB: Error: MySQL is freeing a thdn"
  193. "InnoDB: though trx->n_mysql_tables_in_use is %lun"
  194. "InnoDB: and trx->mysql_n_tables_locked is %lu.n",
  195. (ulong)trx->n_mysql_tables_in_use,
  196. (ulong)trx->mysql_n_tables_locked);
  197. trx_print(stderr, trx);
  198. ut_print_buf(stderr, (byte*)trx, sizeof(trx_t));
  199. }
  200. ut_a(trx->magic_n == TRX_MAGIC_N);
  201. trx->magic_n = 11112222;
  202. ut_a(trx->conc_state == TRX_NOT_STARTED);
  203. mutex_free(&(trx->undo_mutex));
  204. ut_a(trx->insert_undo == NULL); 
  205. ut_a(trx->update_undo == NULL); 
  206. if (trx->undo_no_arr) {
  207. trx_undo_arr_free(trx->undo_no_arr);
  208. }
  209. if (trx->repl_wait_binlog_name != NULL) {
  210. mem_free(trx->repl_wait_binlog_name);
  211. }
  212. ut_a(UT_LIST_GET_LEN(trx->signals) == 0);
  213. ut_a(UT_LIST_GET_LEN(trx->reply_signals) == 0);
  214. ut_a(trx->wait_lock == NULL);
  215. ut_a(UT_LIST_GET_LEN(trx->wait_thrs) == 0);
  216. ut_a(!trx->has_search_latch);
  217. ut_a(!trx->auto_inc_lock);
  218. ut_a(!trx->n_lock_table_exp);
  219. ut_a(trx->dict_operation_lock_mode == 0);
  220. if (trx->lock_heap) {
  221. mem_heap_free(trx->lock_heap);
  222. }
  223. ut_a(UT_LIST_GET_LEN(trx->trx_locks) == 0);
  224. if (trx->read_view_heap) {
  225. mem_heap_free(trx->read_view_heap);
  226. }
  227. ut_a(trx->read_view == NULL);
  228. mem_free(trx);
  229. }
  230. /************************************************************************
  231. Frees a transaction object for MySQL. */
  232. void
  233. trx_free_for_mysql(
  234. /*===============*/
  235. trx_t* trx) /* in, own: trx object */
  236. {
  237. thr_local_free(trx->mysql_thread_id);
  238. mutex_enter(&kernel_mutex);
  239. UT_LIST_REMOVE(mysql_trx_list, trx_sys->mysql_trx_list, trx);
  240. trx_free(trx);
  241. ut_a(trx_n_mysql_transactions > 0);
  242. trx_n_mysql_transactions--;
  243. mutex_exit(&kernel_mutex);
  244. }
  245. /************************************************************************
  246. Frees a transaction object of a background operation of the master thread. */
  247. void
  248. trx_free_for_background(
  249. /*====================*/
  250. trx_t* trx) /* in, own: trx object */
  251. {
  252. mutex_enter(&kernel_mutex);
  253. trx_free(trx);
  254. mutex_exit(&kernel_mutex);
  255. }
  256. /********************************************************************
  257. Inserts the trx handle in the trx system trx list in the right position.
  258. The list is sorted on the trx id so that the biggest id is at the list
  259. start. This function is used at the database startup to insert incomplete
  260. transactions to the list. */
  261. static
  262. void
  263. trx_list_insert_ordered(
  264. /*====================*/
  265. trx_t* trx) /* in: trx handle */
  266. {
  267. trx_t* trx2;
  268. #ifdef UNIV_SYNC_DEBUG
  269. ut_ad(mutex_own(&kernel_mutex));
  270. #endif /* UNIV_SYNC_DEBUG */
  271. trx2 = UT_LIST_GET_FIRST(trx_sys->trx_list);
  272. while (trx2 != NULL) {
  273. if (ut_dulint_cmp(trx->id, trx2->id) >= 0) {
  274. ut_ad(ut_dulint_cmp(trx->id, trx2->id) == 1);
  275. break;
  276. }
  277. trx2 = UT_LIST_GET_NEXT(trx_list, trx2);
  278. }
  279. if (trx2 != NULL) {
  280. trx2 = UT_LIST_GET_PREV(trx_list, trx2);
  281. if (trx2 == NULL) {
  282. UT_LIST_ADD_FIRST(trx_list, trx_sys->trx_list, trx);
  283. } else {
  284. UT_LIST_INSERT_AFTER(trx_list, trx_sys->trx_list,
  285. trx2, trx);
  286. }
  287. } else {
  288. UT_LIST_ADD_LAST(trx_list, trx_sys->trx_list, trx);
  289. }
  290. }
  291. /********************************************************************
  292. Creates trx objects for transactions and initializes the trx list of
  293. trx_sys at database start. Rollback segment and undo log lists must
  294. already exist when this function is called, because the lists of
  295. transactions to be rolled back or cleaned up are built based on the
  296. undo log lists. */
  297. void
  298. trx_lists_init_at_db_start(void)
  299. /*============================*/
  300. {
  301. trx_rseg_t* rseg;
  302. trx_undo_t* undo;
  303. trx_t* trx;
  304. UT_LIST_INIT(trx_sys->trx_list);
  305. /* Look from the rollback segments if there exist undo logs for
  306. transactions */
  307. rseg = UT_LIST_GET_FIRST(trx_sys->rseg_list);
  308. while (rseg != NULL) {
  309. undo = UT_LIST_GET_FIRST(rseg->insert_undo_list);
  310. while (undo != NULL) {
  311. trx = trx_create(NULL); 
  312. trx->id = undo->trx_id;
  313. trx->insert_undo = undo;
  314. trx->rseg = rseg;
  315. if (undo->state != TRX_UNDO_ACTIVE) {
  316. trx->conc_state = TRX_COMMITTED_IN_MEMORY;
  317. /* We give a dummy value for the trx no;
  318. this should have no relevance since purge
  319. is not interested in committed transaction
  320. numbers, unless they are in the history
  321. list, in which case it looks the number
  322. from the disk based undo log structure */
  323. trx->no = trx->id;
  324. } else {
  325. trx->conc_state = TRX_ACTIVE;
  326. /* A running transaction always has the number
  327. field inited to ut_dulint_max */
  328. trx->no = ut_dulint_max;
  329. }
  330. if (undo->dict_operation) {
  331. trx->dict_operation = undo->dict_operation;
  332. trx->table_id = undo->table_id;
  333. }
  334. if (!undo->empty) {
  335. trx->undo_no = ut_dulint_add(undo->top_undo_no,
  336. 1);
  337. }
  338. trx_list_insert_ordered(trx);
  339. undo = UT_LIST_GET_NEXT(undo_list, undo);
  340. }
  341. undo = UT_LIST_GET_FIRST(rseg->update_undo_list);
  342. while (undo != NULL) {
  343. trx = trx_get_on_id(undo->trx_id);
  344. if (NULL == trx) {
  345. trx = trx_create(NULL); 
  346. trx->id = undo->trx_id;
  347. if (undo->state != TRX_UNDO_ACTIVE) {
  348. trx->conc_state =
  349. TRX_COMMITTED_IN_MEMORY;
  350. /* We give a dummy value for the trx
  351. number */
  352. trx->no = trx->id;
  353. } else {
  354. trx->conc_state = TRX_ACTIVE;
  355. /* A running transaction always has
  356. the number field inited to
  357. ut_dulint_max */
  358. trx->no = ut_dulint_max;
  359. }
  360. trx->rseg = rseg;
  361. trx_list_insert_ordered(trx);
  362. if (undo->dict_operation) {
  363. trx->dict_operation =
  364. undo->dict_operation;
  365. trx->table_id = undo->table_id;
  366. }
  367. }
  368. trx->update_undo = undo;
  369. if ((!undo->empty)
  370.     && (ut_dulint_cmp(undo->top_undo_no, trx->undo_no)
  371.         >= 0)) {
  372. trx->undo_no = ut_dulint_add(undo->top_undo_no,
  373. 1);
  374. }
  375. undo = UT_LIST_GET_NEXT(undo_list, undo);
  376. }
  377. rseg = UT_LIST_GET_NEXT(rseg_list, rseg);
  378. }
  379. }
  380. /**********************************************************************
  381. Assigns a rollback segment to a transaction in a round-robin fashion.
  382. Skips the SYSTEM rollback segment if another is available. */
  383. UNIV_INLINE
  384. ulint
  385. trx_assign_rseg(void)
  386. /*=================*/
  387. /* out: assigned rollback segment id */
  388. {
  389. trx_rseg_t* rseg = trx_sys->latest_rseg;
  390. #ifdef UNIV_SYNC_DEBUG
  391. ut_ad(mutex_own(&kernel_mutex));
  392. #endif /* UNIV_SYNC_DEBUG */
  393. loop:
  394. /* Get next rseg in a round-robin fashion */
  395. rseg = UT_LIST_GET_NEXT(rseg_list, rseg);
  396. if (rseg == NULL) {
  397. rseg = UT_LIST_GET_FIRST(trx_sys->rseg_list);
  398. }
  399. /* If it is the SYSTEM rollback segment, and there exist others, skip
  400. it */
  401. if ((rseg->id == TRX_SYS_SYSTEM_RSEG_ID) 
  402. && (UT_LIST_GET_LEN(trx_sys->rseg_list) > 1)) {
  403. goto loop;
  404. }
  405. trx_sys->latest_rseg = rseg;
  406. return(rseg->id);
  407. }
  408. /********************************************************************
  409. Starts a new transaction. */
  410. ibool
  411. trx_start_low(
  412. /*==========*/
  413. /* out: TRUE */
  414. trx_t*  trx, /* in: transaction */
  415. ulint rseg_id)/* in: rollback segment id; if ULINT_UNDEFINED
  416. is passed, the system chooses the rollback segment
  417. automatically in a round-robin fashion */
  418. {
  419. trx_rseg_t* rseg;
  420. #ifdef UNIV_SYNC_DEBUG
  421. ut_ad(mutex_own(&kernel_mutex));
  422. #endif /* UNIV_SYNC_DEBUG */
  423. ut_ad(trx->rseg == NULL);
  424. if (trx->type == TRX_PURGE) {
  425. trx->id = ut_dulint_zero;
  426. trx->conc_state = TRX_ACTIVE;
  427. trx->start_time = time(NULL);
  428. return(TRUE);
  429. }
  430. ut_ad(trx->conc_state != TRX_ACTIVE);
  431. if (rseg_id == ULINT_UNDEFINED) {
  432. rseg_id = trx_assign_rseg();
  433. }
  434. rseg = trx_sys_get_nth_rseg(trx_sys, rseg_id);
  435. trx->id = trx_sys_get_new_trx_id();
  436. /* The initial value for trx->no: ut_dulint_max is used in
  437. read_view_open_now: */
  438. trx->no = ut_dulint_max;
  439. trx->rseg = rseg;
  440. trx->conc_state = TRX_ACTIVE;
  441. trx->start_time = time(NULL);
  442. UT_LIST_ADD_FIRST(trx_list, trx_sys->trx_list, trx);
  443. return(TRUE);
  444. }
  445. /********************************************************************
  446. Starts a new transaction. */
  447. ibool
  448. trx_start(
  449. /*======*/
  450. /* out: TRUE */
  451. trx_t*  trx, /* in: transaction */
  452. ulint rseg_id)/* in: rollback segment id; if ULINT_UNDEFINED
  453. is passed, the system chooses the rollback segment
  454. automatically in a round-robin fashion */
  455. {
  456. ibool ret;
  457. mutex_enter(&kernel_mutex);
  458. ret = trx_start_low(trx, rseg_id);
  459. mutex_exit(&kernel_mutex);
  460. return(ret);
  461. }
  462. /********************************************************************
  463. Commits a transaction. */
  464. void
  465. trx_commit_off_kernel(
  466. /*==================*/
  467. trx_t* trx) /* in: transaction */
  468. {
  469. page_t* update_hdr_page;
  470. dulint lsn;
  471. trx_rseg_t* rseg;
  472. trx_undo_t* undo;
  473. ibool must_flush_log = FALSE;
  474. mtr_t mtr;
  475. #ifdef UNIV_SYNC_DEBUG
  476. ut_ad(mutex_own(&kernel_mutex));
  477. #endif /* UNIV_SYNC_DEBUG */
  478. trx->must_flush_log_later = FALSE;
  479. rseg = trx->rseg;
  480. if (trx->insert_undo != NULL || trx->update_undo != NULL) {
  481. mutex_exit(&kernel_mutex);
  482. mtr_start(&mtr);
  483. must_flush_log = TRUE;
  484. /* Change the undo log segment states from TRX_UNDO_ACTIVE
  485. to some other state: these modifications to the file data
  486. structure define the transaction as committed in the file
  487. based world, at the serialization point of the log sequence
  488. number lsn obtained below. */
  489. mutex_enter(&(rseg->mutex));
  490. if (trx->insert_undo != NULL) {
  491. trx_undo_set_state_at_finish(trx, trx->insert_undo,
  492. &mtr);
  493. }
  494. undo = trx->update_undo;
  495. if (undo) {
  496. mutex_enter(&kernel_mutex);
  497. trx->no = trx_sys_get_new_trx_no();
  498. mutex_exit(&kernel_mutex);
  499. /* It is not necessary to obtain trx->undo_mutex here
  500. because only a single OS thread is allowed to do the
  501. transaction commit for this transaction. */
  502. update_hdr_page = trx_undo_set_state_at_finish(trx,
  503. undo, &mtr);
  504. /* We have to do the cleanup for the update log while
  505. holding the rseg mutex because update log headers
  506. have to be put to the history list in the order of
  507. the trx number. */
  508. trx_undo_update_cleanup(trx, update_hdr_page, &mtr);
  509. }
  510. mutex_exit(&(rseg->mutex));
  511. /* Update the latest MySQL binlog name and offset info
  512. in trx sys header if MySQL binlogging is on or the database
  513. server is a MySQL replication slave */
  514. if (trx->mysql_log_file_name) {
  515. trx_sys_update_mysql_binlog_offset(
  516. trx->mysql_log_file_name,
  517. trx->mysql_log_offset,
  518. TRX_SYS_MYSQL_LOG_INFO, &mtr);
  519. trx->mysql_log_file_name = NULL;
  520. }
  521. if (trx->mysql_master_log_file_name[0] != '') {
  522. /* This database server is a MySQL replication slave */ 
  523. trx_sys_update_mysql_binlog_offset(
  524. trx->mysql_master_log_file_name,
  525. trx->mysql_master_log_pos,
  526. TRX_SYS_MYSQL_MASTER_LOG_INFO, &mtr);
  527. }
  528. /* The following call commits the mini-transaction, making the
  529. whole transaction committed in the file-based world, at this
  530. log sequence number. The transaction becomes 'durable' when
  531. we write the log to disk, but in the logical sense the commit
  532. in the file-based data structures (undo logs etc.) happens
  533. here.
  534. NOTE that transaction numbers, which are assigned only to
  535. transactions with an update undo log, do not necessarily come
  536. in exactly the same order as commit lsn's, if the transactions
  537. have different rollback segments. To get exactly the same
  538. order we should hold the kernel mutex up to this point,
  539. adding to to the contention of the kernel mutex. However, if
  540. a transaction T2 is able to see modifications made by
  541. a transaction T1, T2 will always get a bigger transaction
  542. number and a bigger commit lsn than T1. */
  543. /*--------------*/
  544.   mtr_commit(&mtr);
  545.   /*--------------*/
  546.   lsn = mtr.end_lsn;
  547. mutex_enter(&kernel_mutex);
  548. }
  549. ut_ad(trx->conc_state == TRX_ACTIVE);
  550. #ifdef UNIV_SYNC_DEBUG
  551. ut_ad(mutex_own(&kernel_mutex));
  552. #endif /* UNIV_SYNC_DEBUG */
  553. /* The following assignment makes the transaction committed in memory
  554. and makes its changes to data visible to other transactions.
  555. NOTE that there is a small discrepancy from the strict formal
  556. visibility rules here: a human user of the database can see
  557. modifications made by another transaction T even before the necessary
  558. log segment has been flushed to the disk. If the database happens to
  559. crash before the flush, the user has seen modifications from T which
  560. will never be a committed transaction. However, any transaction T2
  561. which sees the modifications of the committing transaction T, and
  562. which also itself makes modifications to the database, will get an lsn
  563. larger than the committing transaction T. In the case where the log
  564. flush fails, and T never gets committed, also T2 will never get
  565. committed. */
  566. /*--------------------------------------*/
  567. trx->conc_state = TRX_COMMITTED_IN_MEMORY;
  568. /*--------------------------------------*/
  569. lock_release_off_kernel(trx);
  570. if (trx->read_view) {
  571. read_view_close(trx->read_view);
  572. mem_heap_empty(trx->read_view_heap);
  573. trx->read_view = NULL;
  574. }
  575. /* fprintf(stderr, "Trx %lu commit finishedn",
  576. ut_dulint_get_low(trx->id)); */
  577. if (must_flush_log) {
  578. mutex_exit(&kernel_mutex);
  579. if (trx->insert_undo != NULL) {
  580. trx_undo_insert_cleanup(trx);
  581. }
  582. /* NOTE that we could possibly make a group commit more
  583. efficient here: call os_thread_yield here to allow also other
  584. trxs to come to commit! */
  585. /*-------------------------------------*/
  586.                 /* Depending on the my.cnf options, we may now write the log
  587.                 buffer to the log files, making the transaction durable if
  588.                 the OS does not crash. We may also flush the log files to
  589.                 disk, making the transaction durable also at an OS crash or a
  590.                 power outage.
  591.                 The idea in InnoDB's group commit is that a group of
  592.                 transactions gather behind a trx doing a physical disk write
  593.                 to log files, and when that physical write has been completed,
  594.                 one of those transactions does a write which commits the whole
  595.                 group. Note that this group commit will only bring benefit if
  596.                 there are > 2 users in the database. Then at least 2 users can
  597.                 gather behind one doing the physical log write to disk.
  598.                 If we are calling trx_commit() under MySQL's binlog mutex, we
  599.                 will delay possible log write and flush to a separate function
  600.                 trx_commit_complete_for_mysql(), which is only called when the
  601.                 thread has released the binlog mutex. This is to make the
  602.                 group commit algorithm to work. Otherwise, the MySQL binlog
  603.                 mutex would serialize all commits and prevent a group of
  604.                 transactions from gathering. */
  605.                 if (trx->flush_log_later) {
  606.                         /* Do nothing yet */
  607. trx->must_flush_log_later = TRUE;
  608.                 } else if (srv_flush_log_at_trx_commit == 0) {
  609.                         /* Do nothing */
  610.                 } else if (srv_flush_log_at_trx_commit == 1) {
  611.                         if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {
  612.                                /* Write the log but do not flush it to disk */
  613.                                log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE);
  614.                         } else {
  615.                                /* Write the log to the log files AND flush
  616.                                them to disk */
  617.                                log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);
  618.                         }
  619.                 } else if (srv_flush_log_at_trx_commit == 2) {
  620.                         /* Write the log but do not flush it to disk */
  621.                         log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE);
  622.                 } else {
  623.                         ut_error;
  624.                 }
  625. trx->commit_lsn = lsn;
  626. /*-------------------------------------*/
  627. mutex_enter(&kernel_mutex);
  628. }
  629. /* Free savepoints */
  630. trx_roll_savepoints_free(trx, NULL);
  631. trx->conc_state = TRX_NOT_STARTED;
  632. trx->rseg = NULL;
  633. trx->undo_no = ut_dulint_zero;
  634. trx->last_sql_stat_start.least_undo_no = ut_dulint_zero;
  635. ut_ad(UT_LIST_GET_LEN(trx->wait_thrs) == 0);
  636. ut_ad(UT_LIST_GET_LEN(trx->trx_locks) == 0);
  637. UT_LIST_REMOVE(trx_list, trx_sys->trx_list, trx);
  638. }
  639. /********************************************************************
  640. Cleans up a transaction at database startup. The cleanup is needed if
  641. the transaction already got to the middle of a commit when the database
  642. crashed, andf we cannot roll it back. */
  643. void
  644. trx_cleanup_at_db_startup(
  645. /*======================*/
  646. trx_t* trx) /* in: transaction */
  647. {
  648. if (trx->insert_undo != NULL) {
  649. trx_undo_insert_cleanup(trx);
  650. }
  651. trx->conc_state = TRX_NOT_STARTED;
  652. trx->rseg = NULL;
  653. trx->undo_no = ut_dulint_zero;
  654. trx->last_sql_stat_start.least_undo_no = ut_dulint_zero;
  655. UT_LIST_REMOVE(trx_list, trx_sys->trx_list, trx);
  656. }
  657. /************************************************************************
  658. Assigns a read view for a consistent read query. All the consistent reads
  659. within the same transaction will get the same read view, which is created
  660. when this function is first called for a new started transaction. */
  661. read_view_t*
  662. trx_assign_read_view(
  663. /*=================*/
  664. /* out: consistent read view */
  665. trx_t* trx) /* in: active transaction */
  666. {
  667. ut_ad(trx->conc_state == TRX_ACTIVE);
  668. if (trx->read_view) {
  669. return(trx->read_view);
  670. }
  671. mutex_enter(&kernel_mutex);
  672. if (!trx->read_view) {
  673. trx->read_view = read_view_open_now(trx, trx->read_view_heap);
  674. }
  675. mutex_exit(&kernel_mutex);
  676. return(trx->read_view);
  677. }
  678. /********************************************************************
  679. Commits a transaction. NOTE that the kernel mutex is temporarily released. */
  680. static
  681. void
  682. trx_handle_commit_sig_off_kernel(
  683. /*=============================*/
  684. trx_t* trx, /* in: transaction */
  685. que_thr_t** next_thr) /* in/out: next query thread to run;
  686. if the value which is passed in is
  687. a pointer to a NULL pointer, then the
  688. calling function can start running
  689. a new query thread */
  690. {
  691. trx_sig_t* sig;
  692. trx_sig_t* next_sig;
  693. #ifdef UNIV_SYNC_DEBUG
  694. ut_ad(mutex_own(&kernel_mutex));
  695. #endif /* UNIV_SYNC_DEBUG */
  696. trx->que_state = TRX_QUE_COMMITTING;
  697. trx_commit_off_kernel(trx);
  698. ut_ad(UT_LIST_GET_LEN(trx->wait_thrs) == 0);
  699. /* Remove all TRX_SIG_COMMIT signals from the signal queue and send
  700. reply messages to them */
  701. sig = UT_LIST_GET_FIRST(trx->signals);
  702. while (sig != NULL) {
  703. next_sig = UT_LIST_GET_NEXT(signals, sig);
  704. if (sig->type == TRX_SIG_COMMIT) {
  705. trx_sig_reply(sig, next_thr);
  706. trx_sig_remove(trx, sig);
  707. }
  708. sig = next_sig;
  709. }
  710. trx->que_state = TRX_QUE_RUNNING;
  711. }
  712. /***************************************************************
  713. The transaction must be in the TRX_QUE_LOCK_WAIT state. Puts it to
  714. the TRX_QUE_RUNNING state and releases query threads which were
  715. waiting for a lock in the wait_thrs list. */
  716. void
  717. trx_end_lock_wait(
  718. /*==============*/
  719. trx_t* trx) /* in: transaction */
  720. {
  721. que_thr_t* thr;
  722. #ifdef UNIV_SYNC_DEBUG
  723. ut_ad(mutex_own(&kernel_mutex));
  724. #endif /* UNIV_SYNC_DEBUG */
  725. ut_ad(trx->que_state == TRX_QUE_LOCK_WAIT);
  726. thr = UT_LIST_GET_FIRST(trx->wait_thrs);
  727. while (thr != NULL) {
  728. que_thr_end_wait_no_next_thr(thr);
  729. UT_LIST_REMOVE(trx_thrs, trx->wait_thrs, thr);
  730. thr = UT_LIST_GET_FIRST(trx->wait_thrs);
  731. }
  732. trx->que_state = TRX_QUE_RUNNING;
  733. }
  734. /***************************************************************
  735. Moves the query threads in the lock wait list to the SUSPENDED state and puts
  736. the transaction to the TRX_QUE_RUNNING state. */
  737. static
  738. void
  739. trx_lock_wait_to_suspended(
  740. /*=======================*/
  741. trx_t* trx) /* in: transaction in the TRX_QUE_LOCK_WAIT state */
  742. {
  743. que_thr_t* thr;
  744. #ifdef UNIV_SYNC_DEBUG
  745. ut_ad(mutex_own(&kernel_mutex));
  746. #endif /* UNIV_SYNC_DEBUG */
  747. ut_ad(trx->que_state == TRX_QUE_LOCK_WAIT);
  748. thr = UT_LIST_GET_FIRST(trx->wait_thrs);
  749. while (thr != NULL) {
  750. thr->state = QUE_THR_SUSPENDED;
  751. UT_LIST_REMOVE(trx_thrs, trx->wait_thrs, thr);
  752. thr = UT_LIST_GET_FIRST(trx->wait_thrs);
  753. }
  754. trx->que_state = TRX_QUE_RUNNING;
  755. }
  756. /***************************************************************
  757. Moves the query threads in the sig reply wait list of trx to the SUSPENDED
  758. state. */
  759. static
  760. void
  761. trx_sig_reply_wait_to_suspended(
  762. /*============================*/
  763. trx_t* trx) /* in: transaction */
  764. {
  765. trx_sig_t* sig;
  766. que_thr_t* thr;
  767. #ifdef UNIV_SYNC_DEBUG
  768. ut_ad(mutex_own(&kernel_mutex));
  769. #endif /* UNIV_SYNC_DEBUG */
  770. sig = UT_LIST_GET_FIRST(trx->reply_signals);
  771. while (sig != NULL) {
  772. thr = sig->receiver;
  773. ut_ad(thr->state == QUE_THR_SIG_REPLY_WAIT);
  774. thr->state = QUE_THR_SUSPENDED;
  775. sig->receiver = NULL;
  776. UT_LIST_REMOVE(reply_signals, trx->reply_signals, sig);
  777. sig = UT_LIST_GET_FIRST(trx->reply_signals);
  778. }
  779. }
  780. /*********************************************************************
  781. Checks the compatibility of a new signal with the other signals in the
  782. queue. */
  783. static
  784. ibool
  785. trx_sig_is_compatible(
  786. /*==================*/
  787. /* out: TRUE if the signal can be queued */
  788. trx_t* trx, /* in: trx handle */
  789. ulint type, /* in: signal type */
  790. ulint sender) /* in: TRX_SIG_SELF or TRX_SIG_OTHER_SESS */
  791. {
  792. trx_sig_t* sig;
  793. #ifdef UNIV_SYNC_DEBUG
  794. ut_ad(mutex_own(&kernel_mutex));
  795. #endif /* UNIV_SYNC_DEBUG */
  796. if (UT_LIST_GET_LEN(trx->signals) == 0) {
  797. return(TRUE);
  798. }
  799. if (sender == TRX_SIG_SELF) {
  800. if (type == TRX_SIG_ERROR_OCCURRED) {
  801. return(TRUE);
  802. } else if (type == TRX_SIG_BREAK_EXECUTION) {
  803. return(TRUE);
  804. } else {
  805. return(FALSE);
  806. }
  807. }
  808. ut_ad(sender == TRX_SIG_OTHER_SESS);
  809. sig = UT_LIST_GET_FIRST(trx->signals);
  810. if (type == TRX_SIG_COMMIT) {
  811. while (sig != NULL) {
  812. if (sig->type == TRX_SIG_TOTAL_ROLLBACK) {
  813. return(FALSE);
  814. }
  815. sig = UT_LIST_GET_NEXT(signals, sig);
  816. }
  817.   return(TRUE);
  818. } else if (type == TRX_SIG_TOTAL_ROLLBACK) {
  819. while (sig != NULL) {
  820. if (sig->type == TRX_SIG_COMMIT) {
  821. return(FALSE);
  822. }
  823. sig = UT_LIST_GET_NEXT(signals, sig);
  824. }
  825. return(TRUE);
  826. } else if (type == TRX_SIG_BREAK_EXECUTION) {
  827. return(TRUE);
  828. } else {
  829. ut_error;
  830. return(FALSE);
  831. }
  832. }
  833. /********************************************************************
  834. Sends a signal to a trx object. */
  835. ibool
  836. trx_sig_send(
  837. /*=========*/
  838. /* out: TRUE if the signal was
  839. successfully delivered */
  840. trx_t* trx, /* in: trx handle */
  841. ulint type, /* in: signal type */
  842. ulint sender, /* in: TRX_SIG_SELF or
  843. TRX_SIG_OTHER_SESS */
  844. que_thr_t* receiver_thr, /* in: query thread which wants the
  845. reply, or NULL; if type is
  846. TRX_SIG_END_WAIT, this must be NULL */
  847. trx_savept_t*  savept, /* in: possible rollback savepoint, or
  848. NULL */
  849. que_thr_t** next_thr) /* in/out: next query thread to run;
  850. if the value which is passed in is
  851. a pointer to a NULL pointer, then the
  852. calling function can start running
  853. a new query thread; if the parameter
  854. is NULL, it is ignored */
  855. {
  856. trx_sig_t* sig;
  857. trx_t* receiver_trx;
  858. ut_ad(trx);
  859. #ifdef UNIV_SYNC_DEBUG
  860. ut_ad(mutex_own(&kernel_mutex));
  861. #endif /* UNIV_SYNC_DEBUG */
  862. if (!trx_sig_is_compatible(trx, type, sender)) {
  863. /* The signal is not compatible with the other signals in
  864. the queue: do nothing */
  865. ut_error;
  866. return(FALSE);
  867. }
  868. /* Queue the signal object */
  869. if (UT_LIST_GET_LEN(trx->signals) == 0) {
  870. /* The signal list is empty: the 'sig' slot must be unused
  871. (we improve performance a bit by avoiding mem_alloc) */
  872. sig = &(trx->sig);
  873.   } else {
  874. /* It might be that the 'sig' slot is unused also in this
  875. case, but we choose the easy way of using mem_alloc */
  876.  
  877. sig = mem_alloc(sizeof(trx_sig_t));
  878. }
  879. UT_LIST_ADD_LAST(signals, trx->signals, sig);
  880. sig->type = type;
  881. sig->state = TRX_SIG_WAITING;
  882. sig->sender = sender;
  883. sig->receiver = receiver_thr;
  884. if (savept) {
  885. sig->savept = *savept;
  886. }
  887. if (receiver_thr) {
  888. receiver_trx = thr_get_trx(receiver_thr);
  889. UT_LIST_ADD_LAST(reply_signals, receiver_trx->reply_signals,
  890. sig);
  891. }
  892. if (trx->sess->state == SESS_ERROR) {
  893. trx_sig_reply_wait_to_suspended(trx);
  894. }
  895. if ((sender != TRX_SIG_SELF) || (type == TRX_SIG_BREAK_EXECUTION)) {
  896. /* The following call will add a TRX_SIG_ERROR_OCCURRED
  897. signal to the end of the queue, if the session is not yet
  898. in the error state: */
  899. ut_error;
  900. }
  901. /* If there were no other signals ahead in the queue, try to start
  902. handling of the signal */
  903. if (UT_LIST_GET_FIRST(trx->signals) == sig) {
  904. trx_sig_start_handle(trx, next_thr);
  905. }
  906. return(TRUE);
  907. }
  908. /********************************************************************
  909. Ends signal handling. If the session is in the error state, and
  910. trx->graph_before_signal_handling != NULL, then returns control to the error
  911. handling routine of the graph (currently just returns the control to the
  912. graph root which then will send an error message to the client). */
  913. void
  914. trx_end_signal_handling(
  915. /*====================*/
  916. trx_t* trx) /* in: trx */
  917. {
  918. #ifdef UNIV_SYNC_DEBUG
  919. ut_ad(mutex_own(&kernel_mutex));
  920. #endif /* UNIV_SYNC_DEBUG */
  921. ut_ad(trx->handling_signals == TRUE);
  922. trx->handling_signals = FALSE;
  923. trx->graph = trx->graph_before_signal_handling;
  924. if (trx->graph && (trx->sess->state == SESS_ERROR)) {
  925. que_fork_error_handle(trx, trx->graph);
  926. }
  927. }
  928. /********************************************************************
  929. Starts handling of a trx signal. */
  930. void
  931. trx_sig_start_handle(
  932. /*=================*/
  933. trx_t* trx, /* in: trx handle */
  934. que_thr_t** next_thr) /* in/out: next query thread to run;
  935. if the value which is passed in is
  936. a pointer to a NULL pointer, then the
  937. calling function can start running
  938. a new query thread; if the parameter
  939. is NULL, it is ignored */
  940. {
  941. trx_sig_t* sig;
  942. ulint type;
  943. loop:
  944. /* We loop in this function body as long as there are queued signals
  945. we can process immediately */
  946. ut_ad(trx);
  947. #ifdef UNIV_SYNC_DEBUG
  948. ut_ad(mutex_own(&kernel_mutex));
  949. #endif /* UNIV_SYNC_DEBUG */
  950. if (trx->handling_signals && (UT_LIST_GET_LEN(trx->signals) == 0)) {
  951. trx_end_signal_handling(trx);
  952. return;
  953. }
  954. if (trx->conc_state == TRX_NOT_STARTED) {
  955. trx_start_low(trx, ULINT_UNDEFINED);
  956. }
  957. /* If the trx is in a lock wait state, moves the waiting query threads
  958. to the suspended state */
  959. if (trx->que_state == TRX_QUE_LOCK_WAIT) {
  960. trx_lock_wait_to_suspended(trx);
  961. }
  962. /* If the session is in the error state and this trx has threads
  963. waiting for reply from signals, moves these threads to the suspended
  964. state, canceling wait reservations; note that if the transaction has
  965. sent a commit or rollback signal to itself, and its session is not in
  966. the error state, then nothing is done here. */
  967. if (trx->sess->state == SESS_ERROR) {
  968. trx_sig_reply_wait_to_suspended(trx);
  969. }
  970. /* If there are no running query threads, we can start processing of a
  971. signal, otherwise we have to wait until all query threads of this
  972. transaction are aware of the arrival of the signal. */
  973. if (trx->n_active_thrs > 0) {
  974. return;
  975. }
  976. if (trx->handling_signals == FALSE) {
  977. trx->graph_before_signal_handling = trx->graph;
  978. trx->handling_signals = TRUE;
  979. }
  980. sig = UT_LIST_GET_FIRST(trx->signals);
  981. type = sig->type;
  982. if (type == TRX_SIG_COMMIT) {
  983. trx_handle_commit_sig_off_kernel(trx, next_thr);
  984. } else if ((type == TRX_SIG_TOTAL_ROLLBACK)
  985. || (type == TRX_SIG_ROLLBACK_TO_SAVEPT)) { 
  986. trx_rollback(trx, sig, next_thr);
  987. /* No further signals can be handled until the rollback
  988. completes, therefore we return */
  989. return;
  990. } else if (type == TRX_SIG_ERROR_OCCURRED) {
  991. trx_rollback(trx, sig, next_thr);
  992. /* No further signals can be handled until the rollback
  993. completes, therefore we return */
  994. return;
  995. } else if (type == TRX_SIG_BREAK_EXECUTION) {
  996. trx_sig_reply(sig, next_thr);
  997. trx_sig_remove(trx, sig);
  998. } else {
  999. ut_error;
  1000. }
  1001. goto loop;
  1002. }
  1003. /********************************************************************
  1004. Send the reply message when a signal in the queue of the trx has been
  1005. handled. */
  1006. void
  1007. trx_sig_reply(
  1008. /*==========*/
  1009. trx_sig_t* sig, /* in: signal */
  1010. que_thr_t** next_thr) /* in/out: next query thread to run;
  1011. if the value which is passed in is
  1012. a pointer to a NULL pointer, then the
  1013. calling function can start running
  1014. a new query thread */
  1015. {
  1016. trx_t* receiver_trx;
  1017. ut_ad(sig);
  1018. #ifdef UNIV_SYNC_DEBUG
  1019. ut_ad(mutex_own(&kernel_mutex));
  1020. #endif /* UNIV_SYNC_DEBUG */
  1021. if (sig->receiver != NULL) {
  1022. ut_ad((sig->receiver)->state == QUE_THR_SIG_REPLY_WAIT);
  1023. receiver_trx = thr_get_trx(sig->receiver);
  1024. UT_LIST_REMOVE(reply_signals, receiver_trx->reply_signals,
  1025. sig);
  1026. ut_ad(receiver_trx->sess->state != SESS_ERROR);
  1027. que_thr_end_wait(sig->receiver, next_thr);
  1028. sig->receiver = NULL;
  1029. }
  1030. }
  1031. /********************************************************************
  1032. Removes a signal object from the trx signal queue. */
  1033. void
  1034. trx_sig_remove(
  1035. /*===========*/
  1036. trx_t* trx, /* in: trx handle */
  1037. trx_sig_t* sig) /* in, own: signal */
  1038. {
  1039. ut_ad(trx && sig);
  1040. #ifdef UNIV_SYNC_DEBUG
  1041. ut_ad(mutex_own(&kernel_mutex));
  1042. #endif /* UNIV_SYNC_DEBUG */
  1043. ut_ad(sig->receiver == NULL);
  1044. UT_LIST_REMOVE(signals, trx->signals, sig);
  1045. sig->type = 0; /* reset the field to catch possible bugs */
  1046. if (sig != &(trx->sig)) {
  1047. mem_free(sig);
  1048. }
  1049. }
  1050. /*************************************************************************
  1051. Creates a commit command node struct. */
  1052. commit_node_t*
  1053. commit_node_create(
  1054. /*===============*/
  1055. /* out, own: commit node struct */
  1056. mem_heap_t* heap) /* in: mem heap where created */
  1057. {
  1058. commit_node_t* node;
  1059. node = mem_heap_alloc(heap, sizeof(commit_node_t));
  1060. node->common.type  = QUE_NODE_COMMIT;
  1061. node->state = COMMIT_NODE_SEND;
  1062. return(node);
  1063. }
  1064. /***************************************************************
  1065. Performs an execution step for a commit type node in a query graph. */
  1066. que_thr_t*
  1067. trx_commit_step(
  1068. /*============*/
  1069. /* out: query thread to run next, or NULL */
  1070. que_thr_t* thr) /* in: query thread */
  1071. {
  1072. commit_node_t* node;
  1073. que_thr_t* next_thr;
  1074. ibool success;
  1075. node = thr->run_node;
  1076. ut_ad(que_node_get_type(node) == QUE_NODE_COMMIT);
  1077. if (thr->prev_node == que_node_get_parent(node)) {
  1078. node->state = COMMIT_NODE_SEND;
  1079. }
  1080. if (node->state == COMMIT_NODE_SEND) {
  1081. mutex_enter(&kernel_mutex);
  1082. node->state = COMMIT_NODE_WAIT;
  1083. next_thr = NULL;
  1084. thr->state = QUE_THR_SIG_REPLY_WAIT;
  1085. /* Send the commit signal to the transaction */
  1086. success = trx_sig_send(thr_get_trx(thr), TRX_SIG_COMMIT,
  1087. TRX_SIG_SELF, thr, NULL, &next_thr);
  1088. mutex_exit(&kernel_mutex);
  1089. if (!success) {
  1090. /* Error in delivering the commit signal */
  1091. que_thr_handle_error(thr, DB_ERROR, NULL, 0);
  1092. }
  1093. return(next_thr);
  1094. }
  1095. ut_ad(node->state == COMMIT_NODE_WAIT);
  1096. node->state = COMMIT_NODE_SEND;
  1097. thr->run_node = que_node_get_parent(node);
  1098. return(thr);
  1099. }
  1100. /**************************************************************************
  1101. Does the transaction commit for MySQL. */
  1102. ulint
  1103. trx_commit_for_mysql(
  1104. /*=================*/
  1105. /* out: 0 or error number */
  1106. trx_t* trx) /* in: trx handle */
  1107. {
  1108. /* Because we do not do the commit by sending an Innobase
  1109. sig to the transaction, we must here make sure that trx has been
  1110. started. */
  1111. ut_a(trx);
  1112. trx->op_info = "committing";
  1113. trx_start_if_not_started(trx);
  1114. mutex_enter(&kernel_mutex);
  1115. trx_commit_off_kernel(trx);
  1116. mutex_exit(&kernel_mutex);
  1117. trx->op_info = "";
  1118. return(0);
  1119. }
  1120. /**************************************************************************
  1121. If required, flushes the log to disk if we called trx_commit_for_mysql()
  1122. with trx->flush_log_later == TRUE. */
  1123. ulint
  1124. trx_commit_complete_for_mysql(
  1125. /*==========================*/
  1126. /* out: 0 or error number */
  1127. trx_t* trx) /* in: trx handle */
  1128. {
  1129.         dulint  lsn     = trx->commit_lsn;
  1130.         ut_a(trx);
  1131. trx->op_info = "flushing log";
  1132. if (!trx->must_flush_log_later) {
  1133.                 /* Do nothing */
  1134.         } else if (srv_flush_log_at_trx_commit == 0) {
  1135.                 /* Do nothing */
  1136.         } else if (srv_flush_log_at_trx_commit == 1) {
  1137.                 if (srv_unix_file_flush_method == SRV_UNIX_NOSYNC) {
  1138.                         /* Write the log but do not flush it to disk */
  1139.                         log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE);
  1140.                 } else {
  1141.                         /* Write the log to the log files AND flush them to
  1142.                         disk */
  1143.                         log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, TRUE);
  1144.                 }
  1145.         } else if (srv_flush_log_at_trx_commit == 2) {
  1146.                 /* Write the log but do not flush it to disk */
  1147.                 log_write_up_to(lsn, LOG_WAIT_ONE_GROUP, FALSE);
  1148.         } else {
  1149.                 ut_error;
  1150.         }
  1151. trx->must_flush_log_later = FALSE;
  1152. trx->op_info = "";
  1153.         return(0);
  1154. }
  1155. /**************************************************************************
  1156. Marks the latest SQL statement ended. */
  1157. void
  1158. trx_mark_sql_stat_end(
  1159. /*==================*/
  1160. trx_t* trx) /* in: trx handle */
  1161. {
  1162. ut_a(trx);
  1163. if (trx->conc_state == TRX_NOT_STARTED) {
  1164. trx->undo_no = ut_dulint_zero;
  1165. }
  1166. trx->last_sql_stat_start.least_undo_no = trx->undo_no;
  1167. }
  1168. /**************************************************************************
  1169. Prints info about a transaction to the standard output. The caller must
  1170. own the kernel mutex and must have called
  1171. innobase_mysql_prepare_print_arbitrary_thd(), unless he knows that MySQL or
  1172. InnoDB cannot meanwhile change the info printed here. */
  1173. void
  1174. trx_print(
  1175. /*======*/
  1176. FILE* f, /* in: output stream */
  1177. trx_t* trx) /* in: transaction */
  1178. {
  1179. ibool newline;
  1180. fprintf(f, "TRANSACTION %lu %lu",
  1181. (ulong) ut_dulint_get_high(trx->id),
  1182.  (ulong) ut_dulint_get_low(trx->id));
  1183.    switch (trx->conc_state) {
  1184. case TRX_NOT_STARTED:
  1185. fputs(", not started", f);
  1186. break;
  1187. case TRX_ACTIVE:
  1188. fprintf(f, ", ACTIVE %lu sec",
  1189. (ulong)difftime(time(NULL), trx->start_time));
  1190. break;
  1191. case TRX_COMMITTED_IN_MEMORY:
  1192. fputs(", COMMITTED IN MEMORY", f);
  1193. break;
  1194. default:
  1195. fprintf(f, " state %lu", (ulong) trx->conc_state);
  1196.    }
  1197. #ifdef UNIV_LINUX
  1198. fprintf(f, ", process no %lu", trx->mysql_process_no);
  1199. #endif
  1200. fprintf(f, ", OS thread id %lu",
  1201.        (ulong) os_thread_pf(trx->mysql_thread_id));
  1202. if (*trx->op_info) {
  1203. putc(' ', f);
  1204. fputs(trx->op_info, f);
  1205. }
  1206.    if (trx->type != TRX_USER) {
  1207. fputs(" purge trx", f);
  1208.    }
  1209. if (trx->declared_to_be_inside_innodb) {
  1210. fprintf(f, ", thread declared inside InnoDB %lu",
  1211.        (ulong) trx->n_tickets_to_enter_innodb);
  1212. }
  1213. putc('n', f);
  1214.   
  1215.         if (trx->n_mysql_tables_in_use > 0 || trx->mysql_n_tables_locked > 0) {
  1216.                 fprintf(f, "mysql tables in use %lu, locked %lun",
  1217.                            (ulong) trx->n_mysql_tables_in_use,
  1218.                            (ulong) trx->mysql_n_tables_locked);
  1219.         }
  1220. newline = TRUE;
  1221.    switch (trx->que_state) {
  1222. case TRX_QUE_RUNNING:
  1223. newline = FALSE; break;
  1224. case TRX_QUE_LOCK_WAIT:
  1225. fputs("LOCK WAIT ", f); break;
  1226. case TRX_QUE_ROLLING_BACK:
  1227. fputs("ROLLING BACK ", f); break;
  1228. case TRX_QUE_COMMITTING:
  1229. fputs("COMMITTING ", f); break;
  1230. default:
  1231. fprintf(f, "que state %lu ", (ulong) trx->que_state);
  1232.    }
  1233.    if (0 < UT_LIST_GET_LEN(trx->trx_locks) ||
  1234.     mem_heap_get_size(trx->lock_heap) > 400) {
  1235. newline = TRUE;
  1236. fprintf(f, "%lu lock struct(s), heap size %lu",
  1237.        (ulong) UT_LIST_GET_LEN(trx->trx_locks),
  1238.        (ulong) mem_heap_get_size(trx->lock_heap));
  1239. }
  1240.    if (trx->has_search_latch) {
  1241. newline = TRUE;
  1242. fputs(", holds adaptive hash latch", f);
  1243.    }
  1244. if (ut_dulint_cmp(trx->undo_no, ut_dulint_zero) != 0) {
  1245. newline = TRUE;
  1246. fprintf(f, ", undo log entries %lu",
  1247. (ulong) ut_dulint_get_low(trx->undo_no));
  1248. }
  1249. if (newline) {
  1250. putc('n', f);
  1251. }
  1252.    if (trx->mysql_thd != NULL) {
  1253. innobase_mysql_print_thd(f, trx->mysql_thd);
  1254.    }  
  1255. }