trx0sys.ic
上传用户:tsgydb
上传日期:2007-04-14
资源大小:10674k
文件大小:9k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. Transaction system
  3. (c) 1996 Innobase Oy
  4. Created 3/26/1996 Heikki Tuuri
  5. *******************************************************/
  6. #include "srv0srv.h"
  7. #include "trx0trx.h"
  8. #include "data0type.h"
  9. /* The typedef for rseg slot in the file copy */
  10. typedef byte  trx_sysf_rseg_t;
  11. /* Rollback segment specification slot offsets */
  12. /*-------------------------------------------------------------*/
  13. #define TRX_SYS_RSEG_SPACE 0 /* space where the the segment
  14. header is placed */
  15. #define TRX_SYS_RSEG_PAGE_NO 4 /*  page number where the the segment
  16. header is placed; this is FIL_NULL
  17. if the slot is unused */
  18. /*-------------------------------------------------------------*/
  19. /* Size of a rollback segment specification slot */
  20. #define TRX_SYS_RSEG_SLOT_SIZE 8
  21. /*********************************************************************
  22. Writes the value of max_trx_id to the file based trx system header. */
  23. void
  24. trx_sys_flush_max_trx_id(void);
  25. /*==========================*/
  26. /*******************************************************************
  27. Checks if a page address is the trx sys header page. */
  28. UNIV_INLINE
  29. ibool
  30. trx_sys_hdr_page(
  31. /*=============*/
  32. /* out: TRUE if trx sys header page */
  33. ulint space, /* in: space */
  34. ulint page_no)/* in: page number */
  35. {
  36. if ((space == TRX_SYS_SPACE) && (page_no == TRX_SYS_PAGE_NO)) {
  37. return(TRUE);
  38. }
  39. return(FALSE);
  40. }
  41. /*******************************************************************
  42. Gets the pointer in the nth slot of the rseg array. */
  43. UNIV_INLINE
  44. trx_rseg_t*
  45. trx_sys_get_nth_rseg(
  46. /*=================*/
  47. /* out: pointer to rseg object, NULL if slot
  48. not in use */
  49. trx_sys_t* sys, /* in: trx system */
  50. ulint n) /* in: index of slot */
  51. {
  52. ut_ad(mutex_own(&(kernel_mutex)));
  53. ut_ad(n < TRX_SYS_N_RSEGS);
  54. return(sys->rseg_array[n]);
  55. }
  56. /*******************************************************************
  57. Sets the pointer in the nth slot of the rseg array. */
  58. UNIV_INLINE
  59. void
  60. trx_sys_set_nth_rseg(
  61. /*=================*/
  62. trx_sys_t* sys, /* in: trx system */
  63. ulint n, /* in: index of slot */
  64. trx_rseg_t* rseg) /* in: pointer to rseg object, NULL if slot
  65. not in use */
  66. {
  67. ut_ad(n < TRX_SYS_N_RSEGS);
  68. sys->rseg_array[n] = rseg;
  69. }
  70. /**************************************************************************
  71. Gets a pointer to the transaction system header and x-latches its page. */
  72. UNIV_INLINE
  73. trx_sysf_t*
  74. trx_sysf_get(
  75. /*=========*/
  76. /* out: pointer to system header, page x-latched. */
  77. mtr_t* mtr) /* in: mtr */
  78. {
  79. trx_sysf_t* header;
  80. ut_ad(mutex_own(&(kernel_mutex)));
  81. ut_ad(mtr);
  82. header = TRX_SYS + buf_page_get(TRX_SYS_SPACE, TRX_SYS_PAGE_NO,
  83. RW_X_LATCH, mtr);
  84. buf_page_dbg_add_level(header, SYNC_TRX_SYS_HEADER);
  85. return(header);
  86. }
  87. /*********************************************************************
  88. Gets the space of the nth rollback segment slot in the trx system
  89. file copy. */
  90. UNIV_INLINE
  91. ulint
  92. trx_sysf_rseg_get_space(
  93. /*====================*/
  94. /* out: space id */
  95. trx_sysf_t* sys_header, /* in: trx sys header */
  96. ulint i, /* in: slot index == rseg id */
  97. mtr_t* mtr) /* in: mtr */
  98. {
  99. ut_ad(mutex_own(&(kernel_mutex)));
  100. ut_ad(sys_header);
  101. ut_ad(i < TRX_SYS_N_RSEGS);
  102. return(mtr_read_ulint(sys_header + TRX_SYS_RSEGS
  103. + i * TRX_SYS_RSEG_SLOT_SIZE
  104. + TRX_SYS_RSEG_SPACE, MLOG_4BYTES, mtr));
  105. }
  106. /*********************************************************************
  107. Gets the page number of the nth rollback segment slot in the trx system
  108. header. */
  109. UNIV_INLINE
  110. ulint
  111. trx_sysf_rseg_get_page_no(
  112. /*======================*/
  113. /* out: page number, FIL_NULL
  114. if slot unused */
  115. trx_sysf_t* sys_header, /* in: trx system header */
  116. ulint i, /* in: slot index == rseg id */
  117. mtr_t* mtr) /* in: mtr */
  118. {
  119. ut_ad(sys_header);
  120. ut_ad(mutex_own(&(kernel_mutex)));
  121. ut_ad(i < TRX_SYS_N_RSEGS);
  122. return(mtr_read_ulint(sys_header + TRX_SYS_RSEGS
  123. + i * TRX_SYS_RSEG_SLOT_SIZE
  124. + TRX_SYS_RSEG_PAGE_NO, MLOG_4BYTES, mtr));
  125. }
  126. /*********************************************************************
  127. Sets the space id of the nth rollback segment slot in the trx system
  128. file copy. */
  129. UNIV_INLINE
  130. void
  131. trx_sysf_rseg_set_space(
  132. /*====================*/
  133. trx_sysf_t* sys_header, /* in: trx sys file copy */
  134. ulint i, /* in: slot index == rseg id */
  135. ulint space, /* in: space id */
  136. mtr_t* mtr) /* in: mtr */
  137. {
  138. ut_ad(mutex_own(&(kernel_mutex)));
  139. ut_ad(sys_header);
  140. ut_ad(i < TRX_SYS_N_RSEGS);
  141. mlog_write_ulint(sys_header + TRX_SYS_RSEGS
  142. + i * TRX_SYS_RSEG_SLOT_SIZE
  143. + TRX_SYS_RSEG_SPACE,
  144. space,
  145. MLOG_4BYTES, mtr);
  146. }
  147. /*********************************************************************
  148. Sets the page number of the nth rollback segment slot in the trx system
  149. header. */
  150. UNIV_INLINE
  151. void
  152. trx_sysf_rseg_set_page_no(
  153. /*======================*/
  154. trx_sysf_t* sys_header, /* in: trx sys header */
  155. ulint i, /* in: slot index == rseg id */
  156. ulint page_no, /* in: page number, FIL_NULL if the
  157. slot is reset to unused */
  158. mtr_t* mtr) /* in: mtr */
  159. {
  160. ut_ad(mutex_own(&(kernel_mutex)));
  161. ut_ad(sys_header);
  162. ut_ad(i < TRX_SYS_N_RSEGS);
  163. mlog_write_ulint(sys_header + TRX_SYS_RSEGS
  164. + i * TRX_SYS_RSEG_SLOT_SIZE
  165. + TRX_SYS_RSEG_PAGE_NO,
  166. page_no,
  167. MLOG_4BYTES, mtr);
  168. }
  169. /*********************************************************************
  170. Writes a trx id to an index page. In case that the id size changes in
  171. some future version, this function should be used instead of
  172. mach_write_... */
  173. UNIV_INLINE
  174. void
  175. trx_write_trx_id(
  176. /*=============*/
  177. byte* ptr, /* in: pointer to memory where written */
  178. dulint id) /* in: id */
  179. {
  180. ut_ad(DATA_TRX_ID_LEN == 6);
  181. mach_write_to_6(ptr, id);
  182. }
  183. /*********************************************************************
  184. Reads a trx id from an index page. In case that the id size changes in
  185. some future version, this function should be used instead of
  186. mach_read_... */
  187. UNIV_INLINE
  188. dulint
  189. trx_read_trx_id(
  190. /*============*/
  191. /* out: id */
  192. byte* ptr) /* in: pointer to memory from where to read */
  193. {
  194. ut_ad(DATA_TRX_ID_LEN == 6);
  195. return(mach_read_from_6(ptr));
  196. }
  197. /********************************************************************
  198. Looks for the trx handle with the given id in trx_list. */
  199. UNIV_INLINE
  200. trx_t*
  201. trx_get_on_id(
  202. /*==========*/
  203. /* out: the trx handle or NULL if not found */
  204. dulint trx_id) /* in: trx id to search for */
  205. {
  206. trx_t* trx;
  207. ut_ad(mutex_own(&(kernel_mutex)));
  208. trx = UT_LIST_GET_FIRST(trx_sys->trx_list);
  209. while (trx != NULL) {
  210. if (0 == ut_dulint_cmp(trx_id, trx->id)) {
  211. return(trx);
  212. }
  213. trx = UT_LIST_GET_NEXT(trx_list, trx);
  214. }
  215. return(NULL);
  216. }
  217. /********************************************************************
  218. Returns the minumum trx id in trx list. This is the smallest id for which
  219. the trx can possibly be active. (But, you must look at the trx->conc_state to
  220. find out if the minimum trx id transaction itself is active, or already
  221. committed.) */
  222. UNIV_INLINE
  223. dulint
  224. trx_list_get_min_trx_id(void)
  225. /*=========================*/
  226. /* out: the minimum trx id, or trx_sys->max_trx_id
  227. if the trx list is empty */
  228. {
  229. trx_t* trx;
  230. ut_ad(mutex_own(&(kernel_mutex)));
  231. trx = UT_LIST_GET_LAST(trx_sys->trx_list);
  232. if (trx == NULL) {
  233. return(trx_sys->max_trx_id);
  234. }
  235. return(trx->id);
  236. }
  237. /********************************************************************
  238. Checks if a transaction with the given id is active. */
  239. UNIV_INLINE
  240. ibool
  241. trx_is_active(
  242. /*==========*/
  243. /* out: TRUE if active */
  244. dulint trx_id) /* in: trx id of the transaction */
  245. {
  246. trx_t* trx;
  247. ut_ad(mutex_own(&(kernel_mutex)));
  248. if (ut_dulint_cmp(trx_id, trx_list_get_min_trx_id()) < 0) {
  249. return(FALSE);
  250. }
  251. trx = trx_get_on_id(trx_id);
  252. if (trx && (trx->conc_state == TRX_ACTIVE)) {
  253. return(TRUE);
  254. }
  255. return(FALSE);
  256. }
  257. /*********************************************************************
  258. Allocates a new transaction id. */
  259. UNIV_INLINE
  260. dulint
  261. trx_sys_get_new_trx_id(void)
  262. /*========================*/
  263. /* out: new, allocated trx id */
  264. {
  265. dulint id;
  266. ut_ad(mutex_own(&kernel_mutex));
  267. /* VERY important: after the database is started, max_trx_id value is
  268. divisible by TRX_SYS_TRX_ID_WRITE_MARGIN, and the following if
  269. will evaluate to TRUE when this function is first time called,
  270. and the value for trx id will be written to disk-based header!
  271. Thus trx id values will not overlap when the database is
  272. repeatedly started! */
  273. if (ut_dulint_get_low(trx_sys->max_trx_id)
  274. % TRX_SYS_TRX_ID_WRITE_MARGIN == 0) {
  275. trx_sys_flush_max_trx_id();
  276. }
  277. id = trx_sys->max_trx_id;
  278. UT_DULINT_INC(trx_sys->max_trx_id);
  279. return(id);
  280. }
  281. /*********************************************************************
  282. Allocates a new transaction number. */
  283. UNIV_INLINE
  284. dulint
  285. trx_sys_get_new_trx_no(void)
  286. /*========================*/
  287. /* out: new, allocated trx number */
  288. {
  289. ut_ad(mutex_own(&kernel_mutex));
  290. return(trx_sys_get_new_trx_id());
  291. }