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

MySQL数据库

开发平台:

Visual C++

  1. /*   Innobase relational database engine; Copyright (C) 2001 Innobase Oy
  2.      
  3.      This program is free software; you can redistribute it and/or modify
  4.      it under the terms of the GNU General Public License 2
  5.      as published by the Free Software Foundation in June 1991.
  6.      
  7.      This program is distributed in the hope that it will be useful,
  8.      but WITHOUT ANY WARRANTY; without even the implied warranty of
  9.      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10.      GNU General Public License for more details.
  11.      
  12.      You should have received a copy of the GNU General Public License 2
  13.      along with this program (in file COPYING); if not, write to the Free
  14.      Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
  15. /******************************************************
  16. The database buffer buf_pool
  17. (c) 1995 Innobase Oy
  18. Created 11/5/1995 Heikki Tuuri
  19. *******************************************************/
  20. #include "buf0buf.h"
  21. #ifdef UNIV_NONINL
  22. #include "buf0buf.ic"
  23. #endif
  24. #include "mem0mem.h"
  25. #include "btr0btr.h"
  26. #include "fil0fil.h"
  27. #include "lock0lock.h"
  28. #include "btr0sea.h"
  29. #include "ibuf0ibuf.h"
  30. #include "dict0dict.h"
  31. #include "log0recv.h"
  32. #include "log0log.h"
  33. #include "trx0undo.h"
  34. #include "srv0srv.h"
  35. /*
  36. IMPLEMENTATION OF THE BUFFER POOL
  37. =================================
  38. Performance improvement: 
  39. ------------------------
  40. Thread scheduling in NT may be so slow that the OS wait mechanism should
  41. not be used even in waiting for disk reads to complete.
  42. Rather, we should put waiting query threads to the queue of
  43. waiting jobs, and let the OS thread do something useful while the i/o
  44. is processed. In this way we could remove most OS thread switches in
  45. an i/o-intensive benchmark like TPC-C.
  46. A possibility is to put a user space thread library between the database
  47. and NT. User space thread libraries might be very fast.
  48. SQL Server 7.0 can be configured to use 'fibers' which are lightweight
  49. threads in NT. These should be studied.
  50. Buffer frames and blocks
  51. ------------------------
  52. Following the terminology of Gray and Reuter, we call the memory
  53. blocks where file pages are loaded buffer frames. For each buffer
  54. frame there is a control block, or shortly, a block, in the buffer
  55. control array. The control info which does not need to be stored
  56. in the file along with the file page, resides in the control block.
  57. Buffer pool struct
  58. ------------------
  59. The buffer buf_pool contains a single mutex which protects all the
  60. control data structures of the buf_pool. The content of a buffer frame is
  61. protected by a separate read-write lock in its control block, though.
  62. These locks can be locked and unlocked without owning the buf_pool mutex.
  63. The OS events in the buf_pool struct can be waited for without owning the
  64. buf_pool mutex.
  65. The buf_pool mutex is a hot-spot in main memory, causing a lot of
  66. memory bus traffic on multiprocessor systems when processors
  67. alternately access the mutex. On our Pentium, the mutex is accessed
  68. maybe every 10 microseconds. We gave up the solution to have mutexes
  69. for each control block, for instance, because it seemed to be
  70. complicated.
  71. A solution to reduce mutex contention of the buf_pool mutex is to
  72. create a separate mutex for the page hash table. On Pentium,
  73. accessing the hash table takes 2 microseconds, about half
  74. of the total buf_pool mutex hold time.
  75. Control blocks
  76. --------------
  77. The control block contains, for instance, the bufferfix count
  78. which is incremented when a thread wants a file page to be fixed
  79. in a buffer frame. The bufferfix operation does not lock the
  80. contents of the frame, however. For this purpose, the control
  81. block contains a read-write lock.
  82. The buffer frames have to be aligned so that the start memory
  83. address of a frame is divisible by the universal page size, which
  84. is a power of two.
  85. We intend to make the buffer buf_pool size on-line reconfigurable,
  86. that is, the buf_pool size can be changed without closing the database.
  87. Then the database administarator may adjust it to be bigger
  88. at night, for example. The control block array must
  89. contain enough control blocks for the maximum buffer buf_pool size
  90. which is used in the particular database.
  91. If the buf_pool size is cut, we exploit the virtual memory mechanism of
  92. the OS, and just refrain from using frames at high addresses. Then the OS
  93. can swap them to disk.
  94. The control blocks containing file pages are put to a hash table
  95. according to the file address of the page.
  96. We could speed up the access to an individual page by using
  97. "pointer swizzling": we could replace the page references on
  98. non-leaf index pages by direct pointers to the page, if it exists
  99. in the buf_pool. We could make a separate hash table where we could
  100. chain all the page references in non-leaf pages residing in the buf_pool,
  101. using the page reference as the hash key,
  102. and at the time of reading of a page update the pointers accordingly.
  103. Drawbacks of this solution are added complexity and,
  104. possibly, extra space required on non-leaf pages for memory pointers.
  105. A simpler solution is just to speed up the hash table mechanism
  106. in the database, using tables whose size is a power of 2.
  107. Lists of blocks
  108. ---------------
  109. There are several lists of control blocks. The free list contains
  110. blocks which are currently not used.
  111. The LRU-list contains all the blocks holding a file page
  112. except those for which the bufferfix count is non-zero.
  113. The pages are in the LRU list roughly in the order of the last
  114. access to the page, so that the oldest pages are at the end of the
  115. list. We also keep a pointer to near the end of the LRU list,
  116. which we can use when we want to artificially age a page in the
  117. buf_pool. This is used if we know that some page is not needed
  118. again for some time: we insert the block right after the pointer,
  119. causing it to be replaced sooner than would noramlly be the case.
  120. Currently this aging mechanism is used for read-ahead mechanism
  121. of pages, and it can also be used when there is a scan of a full
  122. table which cannot fit in the memory. Putting the pages near the
  123. of the LRU list, we make sure that most of the buf_pool stays in the
  124. main memory, undisturbed.
  125. The chain of modified blocks contains the blocks
  126. holding file pages that have been modified in the memory
  127. but not written to disk yet. The block with the oldest modification
  128. which has not yet been written to disk is at the end of the chain.
  129. Loading a file page
  130. -------------------
  131. First, a victim block for replacement has to be found in the
  132. buf_pool. It is taken from the free list or searched for from the
  133. end of the LRU-list. An exclusive lock is reserved for the frame,
  134. the io_fix field is set in the block fixing the block in buf_pool,
  135. and the io-operation for loading the page is queued. The io-handler thread
  136. releases the X-lock on the frame and resets the io_fix field
  137. when the io operation completes.
  138. A thread may request the above operation using the buf_page_get-
  139. function. It may then continue to request a lock on the frame.
  140. The lock is granted when the io-handler releases the x-lock.
  141. Read-ahead
  142. ----------
  143. The read-ahead mechanism is intended to be intelligent and
  144. isolated from the semantically higher levels of the database
  145. index management. From the higher level we only need the
  146. information if a file page has a natural successor or
  147. predecessor page. On the leaf level of a B-tree index,
  148. these are the next and previous pages in the natural
  149. order of the pages.
  150. Let us first explain the read-ahead mechanism when the leafs
  151. of a B-tree are scanned in an ascending or descending order.
  152. When a read page is the first time referenced in the buf_pool,
  153. the buffer manager checks if it is at the border of a so-called
  154. linear read-ahead area. The tablespace is divided into these
  155. areas of size 64 blocks, for example. So if the page is at the
  156. border of such an area, the read-ahead mechanism checks if
  157. all the other blocks in the area have been accessed in an
  158. ascending or descending order. If this is the case, the system
  159. looks at the natural successor or predecessor of the page,
  160. checks if that is at the border of another area, and in this case
  161. issues read-requests for all the pages in that area. Maybe
  162. we could relax the condition that all the pages in the area
  163. have to be accessed: if data is deleted from a table, there may
  164. appear holes of unused pages in the area.
  165. A different read-ahead mechanism is used when there appears
  166. to be a random access pattern to a file.
  167. If a new page is referenced in the buf_pool, and several pages
  168. of its random access area (for instance, 32 consecutive pages
  169. in a tablespace) have recently been referenced, we may predict
  170. that the whole area may be needed in the near future, and issue
  171. the read requests for the whole area.
  172. AWE implementation
  173. ------------------
  174. By a 'block' we mean the buffer header of type buf_block_t. By a 'page'
  175. we mean the physical 16 kB memory area allocated from RAM for that block.
  176. By a 'frame' we mean a 16 kB area in the virtual address space of the
  177. process, in the frame_mem of buf_pool.
  178. We can map pages to the frames of the buffer pool.
  179. 1) A buffer block allocated to use as a non-data page, e.g., to the lock
  180. table, is always mapped to a frame.
  181. 2) A bufferfixed or io-fixed data page is always mapped to a frame.
  182. 3) When we need to map a block to frame, we look from the list
  183. awe_LRU_free_mapped and try to unmap its last block, but note that
  184. bufferfixed or io-fixed pages cannot be unmapped.
  185. 4) For every frame in the buffer pool there is always a block whose page is
  186. mapped to it. When we create the buffer pool, we map the first elements
  187. in the free list to the frames.
  188. 5) When we have AWE enabled, we disable adaptive hash indexes.
  189. */
  190. buf_pool_t* buf_pool = NULL; /* The buffer buf_pool of the database */
  191. ulint buf_dbg_counter = 0; /* This is used to insert validation
  192. operations in excution in the
  193. debug version */
  194. ibool buf_debug_prints = FALSE; /* If this is set TRUE,
  195. the program prints info whenever
  196. read-ahead or flush occurs */
  197. /************************************************************************
  198. Calculates a page checksum which is stored to the page when it is written
  199. to a file. Note that we must be careful to calculate the same value on
  200. 32-bit and 64-bit architectures. */
  201. ulint
  202. buf_calc_page_new_checksum(
  203. /*=======================*/
  204.        /* out: checksum */
  205. byte*    page) /* in: buffer page */
  206. {
  207.    ulint checksum;
  208.         /* Since the field FIL_PAGE_FILE_FLUSH_LSN, and in versions <= 4.1.x
  209.         ..._ARCH_LOG_NO, are written outside the buffer pool to the first
  210.         pages of data files, we have to skip them in the page checksum
  211.         calculation.
  212. We must also skip the field FIL_PAGE_SPACE_OR_CHKSUM where the
  213. checksum is stored, and also the last 8 bytes of page because
  214. there we store the old formula checksum. */
  215.   
  216.    checksum = ut_fold_binary(page + FIL_PAGE_OFFSET,
  217.  FIL_PAGE_FILE_FLUSH_LSN - FIL_PAGE_OFFSET)
  218.       + ut_fold_binary(page + FIL_PAGE_DATA, 
  219.            UNIV_PAGE_SIZE - FIL_PAGE_DATA
  220.            - FIL_PAGE_END_LSN_OLD_CHKSUM);
  221.    checksum = checksum & 0xFFFFFFFFUL;
  222.    return(checksum);
  223. }
  224. /************************************************************************
  225. In versions < 4.0.14 and < 4.1.1 there was a bug that the checksum only
  226. looked at the first few bytes of the page. This calculates that old
  227. checksum. 
  228. NOTE: we must first store the new formula checksum to
  229. FIL_PAGE_SPACE_OR_CHKSUM before calculating and storing this old checksum
  230. because this takes that field as an input! */
  231. ulint
  232. buf_calc_page_old_checksum(
  233. /*=======================*/
  234.        /* out: checksum */
  235. byte*    page) /* in: buffer page */
  236. {
  237.    ulint checksum;
  238.   
  239.    checksum = ut_fold_binary(page, FIL_PAGE_FILE_FLUSH_LSN);
  240.    checksum = checksum & 0xFFFFFFFFUL;
  241.    return(checksum);
  242. }
  243. /************************************************************************
  244. Checks if a page is corrupt. */
  245. ibool
  246. buf_page_is_corrupted(
  247. /*==================*/
  248. /* out: TRUE if corrupted */
  249. byte* read_buf) /* in: a database page */
  250. {
  251. ulint checksum;
  252. ulint old_checksum;
  253. ulint checksum_field;
  254. ulint old_checksum_field;
  255. #ifndef UNIV_HOTBACKUP
  256. dulint current_lsn;
  257. #endif
  258. if (mach_read_from_4(read_buf + FIL_PAGE_LSN + 4)
  259.      != mach_read_from_4(read_buf + UNIV_PAGE_SIZE
  260. - FIL_PAGE_END_LSN_OLD_CHKSUM + 4)) {
  261. /* Stored log sequence numbers at the start and the end
  262. of page do not match */
  263. return(TRUE);
  264. }
  265. #ifndef UNIV_HOTBACKUP
  266. if (recv_lsn_checks_on && log_peek_lsn(&current_lsn)) {
  267. if (ut_dulint_cmp(current_lsn,
  268.   mach_read_from_8(read_buf + FIL_PAGE_LSN))
  269.  < 0) {
  270. ut_print_timestamp(stderr);
  271. fprintf(stderr,
  272. "  InnoDB: Error: page %lu log sequence number %lu %lun"
  273. "InnoDB: is in the future! Current system log sequence number %lu %lu.n"
  274. "InnoDB: Your database may be corrupt.n",
  275.         (ulong) mach_read_from_4(read_buf + FIL_PAGE_OFFSET),
  276. (ulong) ut_dulint_get_high(
  277. mach_read_from_8(read_buf + FIL_PAGE_LSN)),
  278. (ulong) ut_dulint_get_low(
  279. mach_read_from_8(read_buf + FIL_PAGE_LSN)),
  280. (ulong) ut_dulint_get_high(current_lsn),
  281. (ulong) ut_dulint_get_low(current_lsn));
  282. }
  283. }
  284. #endif
  285. old_checksum = buf_calc_page_old_checksum(read_buf);
  286. old_checksum_field = mach_read_from_4(read_buf + UNIV_PAGE_SIZE
  287. - FIL_PAGE_END_LSN_OLD_CHKSUM);
  288. /* There are 2 valid formulas for old_checksum_field:
  289. 1. Very old versions of InnoDB only stored 8 byte lsn to the start
  290. and the end of the page.
  291. 2. Newer InnoDB versions store the old formula checksum there. */
  292. if (old_checksum_field != mach_read_from_4(read_buf + FIL_PAGE_LSN)
  293.     && old_checksum_field != old_checksum) {
  294. return(TRUE);
  295. }
  296. checksum = buf_calc_page_new_checksum(read_buf);
  297. checksum_field = mach_read_from_4(read_buf + FIL_PAGE_SPACE_OR_CHKSUM);
  298. /* InnoDB versions < 4.0.14 and < 4.1.1 stored the space id
  299. (always equal to 0), to FIL_PAGE_SPACE_SPACE_OR_CHKSUM */
  300. if (checksum_field != 0 && checksum_field != checksum) {
  301.         return(TRUE);
  302. }
  303. return(FALSE);
  304. }
  305. /************************************************************************
  306. Prints a page to stderr. */
  307. void
  308. buf_page_print(
  309. /*===========*/
  310. byte* read_buf) /* in: a database page */
  311. {
  312. dict_index_t* index;
  313. ulint checksum;
  314. ulint old_checksum;
  315. ut_print_timestamp(stderr);
  316. fprintf(stderr, "  InnoDB: Page dump in ascii and hex (%lu bytes):n",
  317. (ulint)UNIV_PAGE_SIZE);
  318. ut_print_buf(stderr, read_buf, UNIV_PAGE_SIZE);
  319. fputs("InnoDB: End of page dumpn", stderr);
  320. checksum = buf_calc_page_new_checksum(read_buf);
  321. old_checksum = buf_calc_page_old_checksum(read_buf);
  322. ut_print_timestamp(stderr);
  323. fprintf(stderr, 
  324. "  InnoDB: Page checksum %lu, prior-to-4.0.14-form checksum %lun"
  325. "InnoDB: stored checksum %lu, prior-to-4.0.14-form stored checksum %lun",
  326. (ulong) checksum, (ulong) old_checksum,
  327. (ulong) mach_read_from_4(read_buf + FIL_PAGE_SPACE_OR_CHKSUM),
  328. (ulong) mach_read_from_4(read_buf + UNIV_PAGE_SIZE
  329. - FIL_PAGE_END_LSN_OLD_CHKSUM));
  330. fprintf(stderr,
  331. "InnoDB: Page lsn %lu %lu, low 4 bytes of lsn at page end %lun"
  332. "InnoDB: Page number (if stored to page already) %lu,n"
  333. "InnoDB: space id (if created with >= MySQL-4.1.1 and stored already) %lun",
  334. (ulong) mach_read_from_4(read_buf + FIL_PAGE_LSN),
  335. (ulong) mach_read_from_4(read_buf + FIL_PAGE_LSN + 4),
  336. (ulong) mach_read_from_4(read_buf + UNIV_PAGE_SIZE
  337. - FIL_PAGE_END_LSN_OLD_CHKSUM + 4),
  338. (ulong) mach_read_from_4(read_buf + FIL_PAGE_OFFSET),
  339. (ulong) mach_read_from_4(read_buf + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID));
  340. if (mach_read_from_2(read_buf + TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_TYPE)
  341.     == TRX_UNDO_INSERT) {
  342.      fprintf(stderr,
  343. "InnoDB: Page may be an insert undo log pagen");
  344. } else if (mach_read_from_2(read_buf + TRX_UNDO_PAGE_HDR
  345. + TRX_UNDO_PAGE_TYPE)
  346.      == TRX_UNDO_UPDATE) {
  347.      fprintf(stderr,
  348. "InnoDB: Page may be an update undo log pagen");
  349. }
  350. if (fil_page_get_type(read_buf) == FIL_PAGE_INDEX) {
  351.      fprintf(stderr,
  352. "InnoDB: Page may be an index page where index id is %lu %lun",
  353. (ulong) ut_dulint_get_high(btr_page_get_index_id(read_buf)),
  354. (ulong) ut_dulint_get_low(btr_page_get_index_id(read_buf)));
  355. /* If the code is in ibbackup, dict_sys may be uninitialized,
  356. i.e., NULL */
  357. if (dict_sys != NULL) {
  358.         index = dict_index_find_on_id_low(
  359. btr_page_get_index_id(read_buf));
  360.         if (index) {
  361. fputs("InnoDB: (", stderr);
  362. dict_index_name_print(stderr, NULL, index);
  363. fputs(")n", stderr);
  364. }
  365. }
  366. } else if (fil_page_get_type(read_buf) == FIL_PAGE_INODE) {
  367. fputs("InnoDB: Page may be an 'inode' pagen", stderr);
  368. } else if (fil_page_get_type(read_buf) == FIL_PAGE_IBUF_FREE_LIST) {
  369. fputs("InnoDB: Page may be an insert buffer free list pagen",
  370. stderr);
  371. }
  372. }
  373. /************************************************************************
  374. Initializes a buffer control block when the buf_pool is created. */
  375. static
  376. void
  377. buf_block_init(
  378. /*===========*/
  379. buf_block_t* block, /* in: pointer to control block */
  380. byte* frame) /* in: pointer to buffer frame, or NULL if in
  381. the case of AWE there is no frame */
  382. {
  383. block->state = BUF_BLOCK_NOT_USED;
  384. block->frame = frame;
  385. block->awe_info = NULL;
  386. block->modify_clock = ut_dulint_zero;
  387. block->file_page_was_freed = FALSE;
  388. block->check_index_page_at_flush = FALSE;
  389. block->in_free_list = FALSE;
  390. block->in_LRU_list = FALSE;
  391. block->n_pointers = 0;
  392. rw_lock_create(&(block->lock));
  393. ut_ad(rw_lock_validate(&(block->lock)));
  394. #ifdef UNIV_SYNC_DEBUG
  395. rw_lock_create(&(block->debug_latch));
  396. rw_lock_set_level(&(block->debug_latch), SYNC_NO_ORDER_CHECK);
  397. #endif /* UNIV_SYNC_DEBUG */
  398. }
  399. /************************************************************************
  400. Creates the buffer pool. */
  401. buf_pool_t*
  402. buf_pool_init(
  403. /*==========*/
  404. /* out, own: buf_pool object, NULL if not
  405. enough memory or error */
  406. ulint max_size, /* in: maximum size of the buf_pool in
  407. blocks */
  408. ulint curr_size, /* in: current size to use, must be <=
  409. max_size, currently must be equal to
  410. max_size */
  411. ulint n_frames) /* in: number of frames; if AWE is used,
  412. this is the size of the address space window
  413. where physical memory pages are mapped; if
  414. AWE is not used then this must be the same
  415. as max_size */
  416. {
  417. byte* frame;
  418. ulint i;
  419. buf_block_t* block;
  420. ut_a(max_size == curr_size);
  421. ut_a(srv_use_awe || n_frames == max_size);
  422. if (n_frames > curr_size) {
  423.         fprintf(stderr,
  424. "InnoDB: AWE: Error: you must specify in my.cnf .._awe_mem_mb largern"
  425. "InnoDB: than .._buffer_pool_size. Now the former is %lu pages,n"
  426. "InnoDB: the latter %lu pages.n", (ulong) curr_size, (ulong) n_frames);
  427. return(NULL);
  428. }
  429. buf_pool = mem_alloc(sizeof(buf_pool_t));
  430. /* 1. Initialize general fields
  431.    ---------------------------- */
  432. mutex_create(&(buf_pool->mutex));
  433. mutex_set_level(&(buf_pool->mutex), SYNC_BUF_POOL);
  434. mutex_enter(&(buf_pool->mutex));
  435. if (srv_use_awe) {
  436. /*----------------------------------------*/
  437. /* Allocate the virtual address space window, i.e., the
  438. buffer pool frames */
  439. buf_pool->frame_mem = os_awe_allocate_virtual_mem_window(
  440. UNIV_PAGE_SIZE * (n_frames + 1));
  441. /* Allocate the physical memory for AWE and the AWE info array
  442. for buf_pool */
  443. if ((curr_size % ((1024 * 1024) / UNIV_PAGE_SIZE)) != 0) {
  444.         fprintf(stderr,
  445. "InnoDB: AWE: Error: physical memory must be allocated in full megabytes.n"
  446. "InnoDB: Trying to allocate %lu database pages.n", 
  447.   (ulong) curr_size);
  448.         return(NULL);
  449. }
  450. if (!os_awe_allocate_physical_mem(&(buf_pool->awe_info),
  451. curr_size / ((1024 * 1024) / UNIV_PAGE_SIZE))) {
  452. return(NULL);
  453. }
  454. /*----------------------------------------*/
  455. } else {
  456. buf_pool->frame_mem = ut_malloc_low(
  457. UNIV_PAGE_SIZE * (n_frames + 1),
  458. TRUE, FALSE);
  459. }
  460. if (buf_pool->frame_mem == NULL) {
  461. return(NULL);
  462. }
  463. buf_pool->blocks = ut_malloc(sizeof(buf_block_t) * max_size);
  464. if (buf_pool->blocks == NULL) {
  465. return(NULL);
  466. }
  467. buf_pool->max_size = max_size;
  468. buf_pool->curr_size = curr_size;
  469. buf_pool->n_frames = n_frames;
  470. /* Align pointer to the first frame */
  471. frame = ut_align(buf_pool->frame_mem, UNIV_PAGE_SIZE);
  472. buf_pool->frame_zero = frame;
  473. buf_pool->high_end = frame + UNIV_PAGE_SIZE * n_frames;
  474. if (srv_use_awe) {
  475. /*----------------------------------------*/
  476. /* Map an initial part of the allocated physical memory to
  477. the window */
  478. os_awe_map_physical_mem_to_window(buf_pool->frame_zero,
  479. n_frames *
  480. (UNIV_PAGE_SIZE / OS_AWE_X86_PAGE_SIZE),
  481. buf_pool->awe_info);
  482. /*----------------------------------------*/
  483. }
  484. buf_pool->blocks_of_frames = ut_malloc(sizeof(void*) * n_frames);
  485. if (buf_pool->blocks_of_frames == NULL) {
  486. return(NULL);
  487. }
  488. /* Init block structs and assign frames for them; in the case of
  489. AWE there are less frames than blocks. Then we assign the frames
  490. to the first blocks (we already mapped the memory above). We also
  491. init the awe_info for every block. */
  492. for (i = 0; i < max_size; i++) {
  493. block = buf_pool_get_nth_block(buf_pool, i);
  494. if (i < n_frames) {
  495. frame = buf_pool->frame_zero + i * UNIV_PAGE_SIZE;
  496. *(buf_pool->blocks_of_frames + i) = block;
  497. } else {
  498. frame = NULL;
  499. }
  500. buf_block_init(block, frame);
  501. if (srv_use_awe) {
  502. /*----------------------------------------*/
  503. block->awe_info = buf_pool->awe_info
  504. + i * (UNIV_PAGE_SIZE / OS_AWE_X86_PAGE_SIZE);
  505. /*----------------------------------------*/
  506. }
  507. }
  508. buf_pool->page_hash = hash_create(2 * max_size);
  509. buf_pool->n_pend_reads = 0;
  510. buf_pool->last_printout_time = time(NULL);
  511. buf_pool->n_pages_read = 0;
  512. buf_pool->n_pages_written = 0;
  513. buf_pool->n_pages_created = 0;
  514. buf_pool->n_pages_awe_remapped = 0;
  515. buf_pool->n_page_gets = 0;
  516. buf_pool->n_page_gets_old = 0;
  517. buf_pool->n_pages_read_old = 0;
  518. buf_pool->n_pages_written_old = 0;
  519. buf_pool->n_pages_created_old = 0;
  520. buf_pool->n_pages_awe_remapped_old = 0;
  521. /* 2. Initialize flushing fields
  522.    ---------------------------- */
  523. UT_LIST_INIT(buf_pool->flush_list);
  524. for (i = BUF_FLUSH_LRU; i <= BUF_FLUSH_LIST; i++) {
  525. buf_pool->n_flush[i] = 0;
  526. buf_pool->init_flush[i] = FALSE;
  527. buf_pool->no_flush[i] = os_event_create(NULL);
  528. }
  529. buf_pool->LRU_flush_ended = 0;
  530. buf_pool->ulint_clock = 1;
  531. buf_pool->freed_page_clock = 0;
  532. /* 3. Initialize LRU fields
  533.    ---------------------------- */
  534. UT_LIST_INIT(buf_pool->LRU);
  535. buf_pool->LRU_old = NULL;
  536. UT_LIST_INIT(buf_pool->awe_LRU_free_mapped);
  537. /* Add control blocks to the free list */
  538. UT_LIST_INIT(buf_pool->free);
  539. for (i = 0; i < curr_size; i++) {
  540. block = buf_pool_get_nth_block(buf_pool, i);
  541. if (block->frame) {
  542. /* Wipe contents of frame to eliminate a Purify
  543. warning */
  544. #ifdef HAVE_purify
  545. memset(block->frame, '', UNIV_PAGE_SIZE);
  546. #endif
  547. if (srv_use_awe) {
  548. /* Add to the list of blocks mapped to
  549. frames */
  550. UT_LIST_ADD_LAST(awe_LRU_free_mapped,
  551. buf_pool->awe_LRU_free_mapped, block);
  552. }
  553. }
  554. UT_LIST_ADD_LAST(free, buf_pool->free, block);
  555. block->in_free_list = TRUE;
  556. }
  557. mutex_exit(&(buf_pool->mutex));
  558. if (srv_use_adaptive_hash_indexes) {
  559.    btr_search_sys_create(
  560.   curr_size * UNIV_PAGE_SIZE / sizeof(void*) / 64);
  561. } else {
  562.         /* Create only a small dummy system */
  563.         btr_search_sys_create(1000);
  564. }
  565. return(buf_pool);
  566. }
  567. /************************************************************************
  568. Maps the page of block to a frame, if not mapped yet. Unmaps some page
  569. from the end of the awe_LRU_free_mapped. */
  570. void
  571. buf_awe_map_page_to_frame(
  572. /*======================*/
  573. buf_block_t* block, /* in: block whose page should be
  574. mapped to a frame */
  575. ibool add_to_mapped_list) /* in: TRUE if we in the case
  576. we need to map the page should also
  577. add the block to the
  578. awe_LRU_free_mapped list */
  579. {
  580. buf_block_t* bck;
  581. #ifdef UNIV_SYNC_DEBUG
  582. ut_ad(mutex_own(&(buf_pool->mutex)));
  583. #endif /* UNIV_SYNC_DEBUG */
  584. ut_ad(block);
  585. if (block->frame) {
  586. return;
  587. }
  588. /* Scan awe_LRU_free_mapped from the end and try to find a block
  589. which is not bufferfixed or io-fixed */
  590. bck = UT_LIST_GET_LAST(buf_pool->awe_LRU_free_mapped);
  591. while (bck) {
  592. if (bck->state == BUF_BLOCK_FILE_PAGE
  593.          && (bck->buf_fix_count != 0 || bck->io_fix != 0)) {
  594. /* We have to skip this */
  595. bck = UT_LIST_GET_PREV(awe_LRU_free_mapped, bck);
  596. } else {
  597. /* We can map block to the frame of bck */
  598. os_awe_map_physical_mem_to_window(
  599. bck->frame,
  600. UNIV_PAGE_SIZE / OS_AWE_X86_PAGE_SIZE,
  601. block->awe_info);
  602. block->frame = bck->frame;
  603. *(buf_pool->blocks_of_frames
  604. + (((ulint)(block->frame
  605. - buf_pool->frame_zero))
  606. >> UNIV_PAGE_SIZE_SHIFT))
  607. = block;
  608. bck->frame = NULL;
  609. UT_LIST_REMOVE(awe_LRU_free_mapped,
  610. buf_pool->awe_LRU_free_mapped,
  611. bck);
  612. if (add_to_mapped_list) {
  613. UT_LIST_ADD_FIRST(awe_LRU_free_mapped,
  614. buf_pool->awe_LRU_free_mapped,
  615. block);
  616. }
  617. buf_pool->n_pages_awe_remapped++;
  618. return;
  619. }
  620. }
  621. fprintf(stderr,
  622. "InnoDB: AWE: Fatal error: cannot find a page to unmapn"
  623. "InnoDB: awe_LRU_free_mapped list length %lun",
  624. (ulong) UT_LIST_GET_LEN(buf_pool->awe_LRU_free_mapped));
  625. ut_a(0);
  626. }
  627. /************************************************************************
  628. Allocates a buffer block. */
  629. UNIV_INLINE
  630. buf_block_t*
  631. buf_block_alloc(void)
  632. /*=================*/
  633. /* out, own: the allocated block; also if AWE
  634. is used it is guaranteed that the page is
  635. mapped to a frame */
  636. {
  637. buf_block_t* block;
  638. block = buf_LRU_get_free_block();
  639. return(block);
  640. }
  641. /************************************************************************
  642. Moves to the block to the start of the LRU list if there is a danger
  643. that the block would drift out of the buffer pool. */
  644. UNIV_INLINE
  645. void
  646. buf_block_make_young(
  647. /*=================*/
  648. buf_block_t* block) /* in: block to make younger */
  649. {
  650. if (buf_pool->freed_page_clock >= block->freed_page_clock 
  651. + 1 + (buf_pool->curr_size / 1024)) {
  652. /* There has been freeing activity in the LRU list:
  653. best to move to the head of the LRU list */
  654. buf_LRU_make_block_young(block);
  655. }
  656. }
  657. /************************************************************************
  658. Moves a page to the start of the buffer pool LRU list. This high-level
  659. function can be used to prevent an important page from from slipping out of
  660. the buffer pool. */
  661. void
  662. buf_page_make_young(
  663. /*=================*/
  664. buf_frame_t* frame) /* in: buffer frame of a file page */
  665. {
  666. buf_block_t* block;
  667. mutex_enter(&(buf_pool->mutex));
  668. block = buf_block_align(frame);
  669. ut_a(block->state == BUF_BLOCK_FILE_PAGE);
  670. buf_LRU_make_block_young(block);
  671. mutex_exit(&(buf_pool->mutex));
  672. }
  673. /************************************************************************
  674. Frees a buffer block which does not contain a file page. */
  675. UNIV_INLINE
  676. void
  677. buf_block_free(
  678. /*===========*/
  679. buf_block_t* block) /* in, own: block to be freed */
  680. {
  681. ut_a(block->state != BUF_BLOCK_FILE_PAGE);
  682. mutex_enter(&(buf_pool->mutex));
  683. buf_LRU_block_free_non_file_page(block);
  684. mutex_exit(&(buf_pool->mutex));
  685. }
  686. /*************************************************************************
  687. Allocates a buffer frame. */
  688. buf_frame_t*
  689. buf_frame_alloc(void)
  690. /*=================*/
  691. /* out: buffer frame */
  692. {
  693. return(buf_block_alloc()->frame);
  694. }
  695. /*************************************************************************
  696. Frees a buffer frame which does not contain a file page. */
  697. void
  698. buf_frame_free(
  699. /*===========*/
  700. buf_frame_t* frame) /* in: buffer frame */
  701. {
  702. buf_block_free(buf_block_align(frame));
  703. }
  704. /************************************************************************
  705. Returns the buffer control block if the page can be found in the buffer
  706. pool. NOTE that it is possible that the page is not yet read
  707. from disk, though. This is a very low-level function: use with care! */
  708. buf_block_t*
  709. buf_page_peek_block(
  710. /*================*/
  711. /* out: control block if found from page hash table,
  712. otherwise NULL; NOTE that the page is not necessarily
  713. yet read from disk! */
  714. ulint space, /* in: space id */
  715. ulint offset) /* in: page number */
  716. {
  717. buf_block_t* block;
  718. mutex_enter_fast(&(buf_pool->mutex));
  719. block = buf_page_hash_get(space, offset);
  720. mutex_exit(&(buf_pool->mutex));
  721. return(block);
  722. }
  723. /************************************************************************
  724. Resets the check_index_page_at_flush field of a page if found in the buffer
  725. pool. */
  726. void
  727. buf_reset_check_index_page_at_flush(
  728. /*================================*/
  729. ulint space, /* in: space id */
  730. ulint offset) /* in: page number */
  731. {
  732. buf_block_t* block;
  733. mutex_enter_fast(&(buf_pool->mutex));
  734. block = buf_page_hash_get(space, offset);
  735. if (block) {
  736. block->check_index_page_at_flush = FALSE;
  737. }
  738. mutex_exit(&(buf_pool->mutex));
  739. }
  740. /************************************************************************
  741. Returns the current state of is_hashed of a page. FALSE if the page is
  742. not in the pool. NOTE that this operation does not fix the page in the
  743. pool if it is found there. */
  744. ibool
  745. buf_page_peek_if_search_hashed(
  746. /*===========================*/
  747. /* out: TRUE if page hash index is built in search
  748. system */
  749. ulint space, /* in: space id */
  750. ulint offset) /* in: page number */
  751. {
  752. buf_block_t* block;
  753. ibool is_hashed;
  754. mutex_enter_fast(&(buf_pool->mutex));
  755. block = buf_page_hash_get(space, offset);
  756. if (!block) {
  757. is_hashed = FALSE;
  758. } else {
  759. is_hashed = block->is_hashed;
  760. }
  761. mutex_exit(&(buf_pool->mutex));
  762. return(is_hashed);
  763. }
  764. /************************************************************************
  765. Returns TRUE if the page can be found in the buffer pool hash table. NOTE
  766. that it is possible that the page is not yet read from disk, though. */
  767. ibool
  768. buf_page_peek(
  769. /*==========*/
  770. /* out: TRUE if found from page hash table,
  771. NOTE that the page is not necessarily yet read
  772. from disk! */
  773. ulint space, /* in: space id */
  774. ulint offset) /* in: page number */
  775. {
  776. if (buf_page_peek_block(space, offset)) {
  777. return(TRUE);
  778. }
  779. return(FALSE);
  780. }
  781. /************************************************************************
  782. Sets file_page_was_freed TRUE if the page is found in the buffer pool.
  783. This function should be called when we free a file page and want the
  784. debug version to check that it is not accessed any more unless
  785. reallocated. */
  786. buf_block_t*
  787. buf_page_set_file_page_was_freed(
  788. /*=============================*/
  789. /* out: control block if found from page hash table,
  790. otherwise NULL */
  791. ulint space, /* in: space id */
  792. ulint offset) /* in: page number */
  793. {
  794. buf_block_t* block;
  795. mutex_enter_fast(&(buf_pool->mutex));
  796. block = buf_page_hash_get(space, offset);
  797. if (block) {
  798. block->file_page_was_freed = TRUE;
  799. }
  800. mutex_exit(&(buf_pool->mutex));
  801. return(block);
  802. }
  803. /************************************************************************
  804. Sets file_page_was_freed FALSE if the page is found in the buffer pool.
  805. This function should be called when we free a file page and want the
  806. debug version to check that it is not accessed any more unless
  807. reallocated. */
  808. buf_block_t*
  809. buf_page_reset_file_page_was_freed(
  810. /*===============================*/
  811. /* out: control block if found from page hash table,
  812. otherwise NULL */
  813. ulint space, /* in: space id */
  814. ulint offset) /* in: page number */
  815. {
  816. buf_block_t* block;
  817. mutex_enter_fast(&(buf_pool->mutex));
  818. block = buf_page_hash_get(space, offset);
  819. if (block) {
  820. block->file_page_was_freed = FALSE;
  821. }
  822. mutex_exit(&(buf_pool->mutex));
  823. return(block);
  824. }
  825. /************************************************************************
  826. This is the general function used to get access to a database page. */
  827. buf_frame_t*
  828. buf_page_get_gen(
  829. /*=============*/
  830. /* out: pointer to the frame or NULL */
  831. ulint space, /* in: space id */
  832. ulint offset, /* in: page number */
  833. ulint rw_latch,/* in: RW_S_LATCH, RW_X_LATCH, RW_NO_LATCH */
  834. buf_frame_t* guess, /* in: guessed frame or NULL */
  835. ulint mode, /* in: BUF_GET, BUF_GET_IF_IN_POOL,
  836. BUF_GET_NO_LATCH, BUF_GET_NOWAIT */
  837. const char* file, /* in: file name */
  838. ulint line, /* in: line where called */
  839. mtr_t* mtr) /* in: mini-transaction */
  840. {
  841. buf_block_t* block;
  842. ibool accessed;
  843. ulint fix_type;
  844. ibool success;
  845. ibool must_read;
  846. ut_ad(mtr);
  847. ut_ad((rw_latch == RW_S_LATCH)
  848.       || (rw_latch == RW_X_LATCH)
  849.       || (rw_latch == RW_NO_LATCH));
  850. ut_ad((mode != BUF_GET_NO_LATCH) || (rw_latch == RW_NO_LATCH));
  851. ut_ad((mode == BUF_GET) || (mode == BUF_GET_IF_IN_POOL)
  852.       || (mode == BUF_GET_NO_LATCH) || (mode == BUF_GET_NOWAIT));
  853. #ifndef UNIV_LOG_DEBUG
  854. ut_ad(!ibuf_inside() || ibuf_page(space, offset));
  855. #endif
  856. buf_pool->n_page_gets++;
  857. loop:
  858. mutex_enter_fast(&(buf_pool->mutex));
  859. block = NULL;
  860. if (guess) {
  861. block = buf_block_align(guess);
  862. if ((offset != block->offset) || (space != block->space)
  863. || (block->state != BUF_BLOCK_FILE_PAGE)) {
  864. block = NULL;
  865. }
  866. }
  867. if (block == NULL) {
  868. block = buf_page_hash_get(space, offset);
  869. }
  870. if (block == NULL) {
  871. /* Page not in buf_pool: needs to be read from file */
  872. mutex_exit(&(buf_pool->mutex));
  873. if (mode == BUF_GET_IF_IN_POOL) {
  874. return(NULL);
  875. }
  876. buf_read_page(space, offset);
  877. #ifdef UNIV_DEBUG
  878. buf_dbg_counter++;
  879. if (buf_dbg_counter % 37 == 0) {
  880. ut_ad(buf_validate());
  881. }
  882. #endif
  883. goto loop;
  884. }
  885. ut_a(block->state == BUF_BLOCK_FILE_PAGE);
  886. must_read = FALSE;
  887. if (block->io_fix == BUF_IO_READ) {
  888. must_read = TRUE;
  889. if (mode == BUF_GET_IF_IN_POOL) {
  890. /* The page is only being read to buffer */
  891. mutex_exit(&(buf_pool->mutex));
  892. return(NULL);
  893. }
  894. }
  895. /* If AWE is enabled and the page is not mapped to a frame, then
  896. map it */
  897. if (block->frame == NULL) {
  898. ut_a(srv_use_awe);
  899. /* We set second parameter TRUE because the block is in the
  900. LRU list and we must put it to awe_LRU_free_mapped list once
  901. mapped to a frame */
  902. buf_awe_map_page_to_frame(block, TRUE);
  903. }
  904. #ifdef UNIV_SYNC_DEBUG
  905. buf_block_buf_fix_inc_debug(block, file, line);
  906. #else
  907. buf_block_buf_fix_inc(block);
  908. #endif
  909. buf_block_make_young(block);
  910. /* Check if this is the first access to the page */
  911. accessed = block->accessed;
  912. block->accessed = TRUE;
  913. #ifdef UNIV_DEBUG_FILE_ACCESSES
  914. ut_a(block->file_page_was_freed == FALSE);
  915. #endif
  916. mutex_exit(&(buf_pool->mutex));
  917. #ifdef UNIV_DEBUG
  918. buf_dbg_counter++;
  919. if (buf_dbg_counter % 5771 == 0) {
  920. ut_ad(buf_validate());
  921. }
  922. #endif
  923. ut_ad(block->buf_fix_count > 0);
  924. ut_ad(block->state == BUF_BLOCK_FILE_PAGE);
  925. if (mode == BUF_GET_NOWAIT) {
  926. if (rw_latch == RW_S_LATCH) {
  927. success = rw_lock_s_lock_func_nowait(&(block->lock),
  928. file, line);
  929. fix_type = MTR_MEMO_PAGE_S_FIX;
  930. } else {
  931. ut_ad(rw_latch == RW_X_LATCH);
  932. success = rw_lock_x_lock_func_nowait(&(block->lock),
  933. file, line);
  934. fix_type = MTR_MEMO_PAGE_X_FIX;
  935. }
  936. if (!success) {
  937. mutex_enter(&(buf_pool->mutex));
  938. block->buf_fix_count--;
  939. #ifdef UNIV_SYNC_DEBUG
  940. rw_lock_s_unlock(&(block->debug_latch));
  941. #endif
  942. mutex_exit(&(buf_pool->mutex));
  943. return(NULL);
  944. }
  945. } else if (rw_latch == RW_NO_LATCH) {
  946. if (must_read) {
  947.         /* Let us wait until the read operation
  948. completes */
  949.         for (;;) {
  950.         mutex_enter(&(buf_pool->mutex));
  951.                 if (block->io_fix == BUF_IO_READ) {
  952.         mutex_exit(&(buf_pool->mutex));
  953.   
  954.         /* Sleep 20 milliseconds */
  955.         os_thread_sleep(20000);
  956. } else {
  957.   
  958.        mutex_exit(&(buf_pool->mutex));
  959.        break;
  960. }
  961. }
  962. }
  963. fix_type = MTR_MEMO_BUF_FIX;
  964. } else if (rw_latch == RW_S_LATCH) {
  965. rw_lock_s_lock_func(&(block->lock), 0, file, line);
  966. fix_type = MTR_MEMO_PAGE_S_FIX;
  967. } else {
  968. rw_lock_x_lock_func(&(block->lock), 0, file, line);
  969. fix_type = MTR_MEMO_PAGE_X_FIX;
  970. }
  971. mtr_memo_push(mtr, block, fix_type);
  972. if (!accessed) {
  973. /* In the case of a first access, try to apply linear
  974. read-ahead */
  975. buf_read_ahead_linear(space, offset);
  976. }
  977. #ifdef UNIV_IBUF_DEBUG
  978. ut_a(ibuf_count_get(block->space, block->offset) == 0);
  979. #endif
  980. return(block->frame);
  981. }
  982. /************************************************************************
  983. This is the general function used to get optimistic access to a database
  984. page. */
  985. ibool
  986. buf_page_optimistic_get_func(
  987. /*=========================*/
  988. /* out: TRUE if success */
  989. ulint rw_latch,/* in: RW_S_LATCH, RW_X_LATCH */
  990. buf_block_t* block, /* in: guessed buffer block */
  991. buf_frame_t* guess, /* in: guessed frame; note that AWE may move
  992. frames */
  993. dulint modify_clock,/* in: modify clock value if mode is
  994. ..._GUESS_ON_CLOCK */
  995. const char* file, /* in: file name */
  996. ulint line, /* in: line where called */
  997. mtr_t* mtr) /* in: mini-transaction */
  998. {
  999. ibool accessed;
  1000. ibool success;
  1001. ulint fix_type;
  1002. ut_ad(mtr && block);
  1003. ut_ad((rw_latch == RW_S_LATCH) || (rw_latch == RW_X_LATCH));
  1004. mutex_enter(&(buf_pool->mutex));
  1005. /* If AWE is used, block may have a different frame now, e.g., NULL */
  1006. if (block->state != BUF_BLOCK_FILE_PAGE || block->frame != guess) {
  1007. mutex_exit(&(buf_pool->mutex));
  1008. return(FALSE);
  1009. }
  1010. #ifdef UNIV_SYNC_DEBUG
  1011. buf_block_buf_fix_inc_debug(block, file, line);
  1012. #else
  1013. buf_block_buf_fix_inc(block);
  1014. #endif
  1015. buf_block_make_young(block);
  1016. /* Check if this is the first access to the page */
  1017. accessed = block->accessed;
  1018. block->accessed = TRUE;
  1019. mutex_exit(&(buf_pool->mutex));
  1020. ut_ad(!ibuf_inside() || ibuf_page(block->space, block->offset));
  1021. if (rw_latch == RW_S_LATCH) {
  1022. success = rw_lock_s_lock_func_nowait(&(block->lock),
  1023. file, line);
  1024. fix_type = MTR_MEMO_PAGE_S_FIX;
  1025. } else {
  1026. success = rw_lock_x_lock_func_nowait(&(block->lock),
  1027. file, line);
  1028. fix_type = MTR_MEMO_PAGE_X_FIX;
  1029. }
  1030. if (!success) {
  1031. mutex_enter(&(buf_pool->mutex));
  1032. block->buf_fix_count--;
  1033. #ifdef UNIV_SYNC_DEBUG
  1034. rw_lock_s_unlock(&(block->debug_latch));
  1035. #endif
  1036. mutex_exit(&(buf_pool->mutex));
  1037. return(FALSE);
  1038. }
  1039. if (!UT_DULINT_EQ(modify_clock, block->modify_clock)) {
  1040. #ifdef UNIV_SYNC_DEBUG
  1041. buf_page_dbg_add_level(block->frame, SYNC_NO_ORDER_CHECK);
  1042. #endif /* UNIV_SYNC_DEBUG */
  1043. if (rw_latch == RW_S_LATCH) {
  1044. rw_lock_s_unlock(&(block->lock));
  1045. } else {
  1046. rw_lock_x_unlock(&(block->lock));
  1047. }
  1048. mutex_enter(&(buf_pool->mutex));
  1049. block->buf_fix_count--;
  1050. #ifdef UNIV_SYNC_DEBUG
  1051. rw_lock_s_unlock(&(block->debug_latch));
  1052. #endif
  1053. mutex_exit(&(buf_pool->mutex));
  1054. return(FALSE);
  1055. }
  1056. mtr_memo_push(mtr, block, fix_type);
  1057. #ifdef UNIV_DEBUG
  1058. buf_dbg_counter++;
  1059. if (buf_dbg_counter % 5771 == 0) {
  1060. ut_ad(buf_validate());
  1061. }
  1062. #endif
  1063. ut_ad(block->buf_fix_count > 0);
  1064. ut_ad(block->state == BUF_BLOCK_FILE_PAGE);
  1065. #ifdef UNIV_DEBUG_FILE_ACCESSES
  1066. ut_a(block->file_page_was_freed == FALSE);
  1067. #endif
  1068. if (!accessed) {
  1069. /* In the case of a first access, try to apply linear
  1070. read-ahead */
  1071. buf_read_ahead_linear(buf_frame_get_space_id(guess),
  1072. buf_frame_get_page_no(guess));
  1073. }
  1074. #ifdef UNIV_IBUF_DEBUG
  1075. ut_a(ibuf_count_get(block->space, block->offset) == 0);
  1076. #endif
  1077. buf_pool->n_page_gets++;
  1078. return(TRUE);
  1079. }
  1080. /************************************************************************
  1081. This is used to get access to a known database page, when no waiting can be
  1082. done. For example, if a search in an adaptive hash index leads us to this
  1083. frame. */
  1084. ibool
  1085. buf_page_get_known_nowait(
  1086. /*======================*/
  1087. /* out: TRUE if success */
  1088. ulint rw_latch,/* in: RW_S_LATCH, RW_X_LATCH */
  1089. buf_frame_t* guess, /* in: the known page frame */
  1090. ulint mode, /* in: BUF_MAKE_YOUNG or BUF_KEEP_OLD */
  1091. const char* file, /* in: file name */
  1092. ulint line, /* in: line where called */
  1093. mtr_t* mtr) /* in: mini-transaction */
  1094. {
  1095. buf_block_t* block;
  1096. ibool success;
  1097. ulint fix_type;
  1098. ut_ad(mtr);
  1099. ut_ad((rw_latch == RW_S_LATCH) || (rw_latch == RW_X_LATCH));
  1100. mutex_enter(&(buf_pool->mutex));
  1101. block = buf_block_align(guess);
  1102. if (block->state == BUF_BLOCK_REMOVE_HASH) {
  1103.         /* Another thread is just freeing the block from the LRU list
  1104.         of the buffer pool: do not try to access this page; this
  1105. attempt to access the page can only come through the hash
  1106. index because when the buffer block state is ..._REMOVE_HASH,
  1107. we have already removed it from the page address hash table
  1108. of the buffer pool. */
  1109.         mutex_exit(&(buf_pool->mutex));
  1110. return(FALSE);
  1111. }
  1112. ut_a(block->state == BUF_BLOCK_FILE_PAGE);
  1113. #ifdef UNIV_SYNC_DEBUG
  1114. buf_block_buf_fix_inc_debug(block, file, line);
  1115. #else
  1116. buf_block_buf_fix_inc(block);
  1117. #endif
  1118. if (mode == BUF_MAKE_YOUNG) {
  1119. buf_block_make_young(block);
  1120. }
  1121. mutex_exit(&(buf_pool->mutex));
  1122. ut_ad(!ibuf_inside() || (mode == BUF_KEEP_OLD));
  1123. if (rw_latch == RW_S_LATCH) {
  1124. success = rw_lock_s_lock_func_nowait(&(block->lock),
  1125. file, line);
  1126. fix_type = MTR_MEMO_PAGE_S_FIX;
  1127. } else {
  1128. success = rw_lock_x_lock_func_nowait(&(block->lock),
  1129. file, line);
  1130. fix_type = MTR_MEMO_PAGE_X_FIX;
  1131. }
  1132. if (!success) {
  1133. mutex_enter(&(buf_pool->mutex));
  1134. block->buf_fix_count--;
  1135. #ifdef UNIV_SYNC_DEBUG
  1136. rw_lock_s_unlock(&(block->debug_latch));
  1137. #endif
  1138. mutex_exit(&(buf_pool->mutex));
  1139. return(FALSE);
  1140. }
  1141. mtr_memo_push(mtr, block, fix_type);
  1142. #ifdef UNIV_DEBUG
  1143. buf_dbg_counter++;
  1144. if (buf_dbg_counter % 5771 == 0) {
  1145. ut_ad(buf_validate());
  1146. }
  1147. #endif
  1148. ut_ad(block->buf_fix_count > 0);
  1149. ut_ad(block->state == BUF_BLOCK_FILE_PAGE);
  1150. #ifdef UNIV_DEBUG_FILE_ACCESSES
  1151. ut_a(block->file_page_was_freed == FALSE);
  1152. #endif
  1153. #ifdef UNIV_IBUF_DEBUG
  1154. ut_a((mode == BUF_KEEP_OLD)
  1155. || (ibuf_count_get(block->space, block->offset) == 0));
  1156. #endif
  1157. buf_pool->n_page_gets++;
  1158. return(TRUE);
  1159. }
  1160. /************************************************************************
  1161. Inits a page to the buffer buf_pool, for use in ibbackup --restore. */
  1162. void
  1163. buf_page_init_for_backup_restore(
  1164. /*=============================*/
  1165. ulint space, /* in: space id */
  1166. ulint offset, /* in: offset of the page within space
  1167. in units of a page */
  1168. buf_block_t* block) /* in: block to init */
  1169. {
  1170. /* Set the state of the block */
  1171. block->magic_n = BUF_BLOCK_MAGIC_N;
  1172. block->state  = BUF_BLOCK_FILE_PAGE;
  1173. block->space  = space;
  1174. block->offset  = offset;
  1175. block->lock_hash_val = 0;
  1176. block->lock_mutex = NULL;
  1177. block->freed_page_clock = 0;
  1178. block->newest_modification = ut_dulint_zero;
  1179. block->oldest_modification = ut_dulint_zero;
  1180. block->accessed = FALSE;
  1181. block->buf_fix_count  = 0;
  1182. block->io_fix = 0;
  1183. block->n_hash_helps = 0;
  1184. block->is_hashed = FALSE;
  1185. block->n_fields         = 1;
  1186. block->n_bytes          = 0;
  1187. block->side             = BTR_SEARCH_LEFT_SIDE;
  1188. block->file_page_was_freed = FALSE;
  1189. }
  1190. /************************************************************************
  1191. Inits a page to the buffer buf_pool. */
  1192. static
  1193. void
  1194. buf_page_init(
  1195. /*==========*/
  1196. ulint space, /* in: space id */
  1197. ulint offset, /* in: offset of the page within space
  1198. in units of a page */
  1199. buf_block_t* block) /* in: block to init */
  1200. {
  1201. #ifdef UNIV_SYNC_DEBUG
  1202. ut_ad(mutex_own(&(buf_pool->mutex)));
  1203. #endif /* UNIV_SYNC_DEBUG */
  1204. ut_a(block->state != BUF_BLOCK_FILE_PAGE);
  1205. /* Set the state of the block */
  1206. block->magic_n = BUF_BLOCK_MAGIC_N;
  1207. block->state  = BUF_BLOCK_FILE_PAGE;
  1208. block->space  = space;
  1209. block->offset  = offset;
  1210. block->check_index_page_at_flush = FALSE;
  1211. block->lock_hash_val = lock_rec_hash(space, offset);
  1212. block->lock_mutex = NULL;
  1213. /* Insert into the hash table of file pages */
  1214.         if (buf_page_hash_get(space, offset)) {
  1215.                 fprintf(stderr,
  1216. "InnoDB: Error: page %lu %lu already found from the hash tablen",
  1217. (ulong) space,
  1218. (ulong) offset);
  1219. #ifdef UNIV_DEBUG
  1220.                 buf_print();
  1221.                 buf_LRU_print();
  1222.                 buf_validate();
  1223.                 buf_LRU_validate();
  1224. #endif /* UNIV_DEBUG */
  1225.                 ut_a(0);
  1226.         }
  1227. HASH_INSERT(buf_block_t, hash, buf_pool->page_hash,
  1228. buf_page_address_fold(space, offset), block);
  1229. block->freed_page_clock = 0;
  1230. block->newest_modification = ut_dulint_zero;
  1231. block->oldest_modification = ut_dulint_zero;
  1232. block->accessed = FALSE;
  1233. block->buf_fix_count  = 0;
  1234. block->io_fix = 0;
  1235. block->n_hash_helps = 0;
  1236. block->is_hashed = FALSE;
  1237. block->n_fields         = 1;
  1238. block->n_bytes          = 0;
  1239. block->side             = BTR_SEARCH_LEFT_SIDE;
  1240. block->file_page_was_freed = FALSE;
  1241. }
  1242. /************************************************************************
  1243. Function which inits a page for read to the buffer buf_pool. If the page is
  1244. (1) already in buf_pool, or
  1245. (2) if we specify to read only ibuf pages and the page is not an ibuf page, or
  1246. (3) if the space is deleted or being deleted,
  1247. then this function does nothing.
  1248. Sets the io_fix flag to BUF_IO_READ and sets a non-recursive exclusive lock
  1249. on the buffer frame. The io-handler must take care that the flag is cleared
  1250. and the lock released later. This is one of the functions which perform the
  1251. state transition NOT_USED => FILE_PAGE to a block (the other is
  1252. buf_page_create). */ 
  1253. buf_block_t*
  1254. buf_page_init_for_read(
  1255. /*===================*/
  1256. /* out: pointer to the block or NULL */
  1257. ulint* err, /* out: DB_SUCCESS or DB_TABLESPACE_DELETED */
  1258. ulint mode, /* in: BUF_READ_IBUF_PAGES_ONLY, ... */
  1259. ulint space, /* in: space id */
  1260. ib_longlong tablespace_version,/* in: prevents reading from a wrong
  1261. version of the tablespace in case we have done
  1262. DISCARD + IMPORT */
  1263. ulint offset) /* in: page number */
  1264. {
  1265. buf_block_t* block;
  1266. mtr_t mtr;
  1267. ut_ad(buf_pool);
  1268. *err = DB_SUCCESS;
  1269. if (mode == BUF_READ_IBUF_PAGES_ONLY) {
  1270. /* It is a read-ahead within an ibuf routine */
  1271. ut_ad(!ibuf_bitmap_page(offset));
  1272. ut_ad(ibuf_inside());
  1273. mtr_start(&mtr);
  1274. if (!ibuf_page_low(space, offset, &mtr)) {
  1275. mtr_commit(&mtr);
  1276. return(NULL);
  1277. }
  1278. } else {
  1279. ut_ad(mode == BUF_READ_ANY_PAGE);
  1280. }
  1281. block = buf_block_alloc();
  1282. ut_a(block);
  1283. mutex_enter(&(buf_pool->mutex));
  1284. if (fil_tablespace_deleted_or_being_deleted_in_mem(space,
  1285. tablespace_version)) {
  1286. *err = DB_TABLESPACE_DELETED;
  1287. }
  1288. if (*err == DB_TABLESPACE_DELETED
  1289.     || NULL != buf_page_hash_get(space, offset)) {
  1290. /* The page belongs to a space which has been deleted or is
  1291. being deleted, or the page is already in buf_pool, return */
  1292. mutex_exit(&(buf_pool->mutex));
  1293. buf_block_free(block);
  1294. if (mode == BUF_READ_IBUF_PAGES_ONLY) {
  1295. mtr_commit(&mtr);
  1296. }
  1297. return(NULL);
  1298. }
  1299. ut_ad(block);
  1300. buf_page_init(space, offset, block);
  1301. /* The block must be put to the LRU list, to the old blocks */
  1302. buf_LRU_add_block(block, TRUE);  /* TRUE == to old blocks */
  1303. block->io_fix = BUF_IO_READ;
  1304. buf_pool->n_pend_reads++;
  1305. /* We set a pass-type x-lock on the frame because then the same
  1306. thread which called for the read operation (and is running now at
  1307. this point of code) can wait for the read to complete by waiting
  1308. for the x-lock on the frame; if the x-lock were recursive, the
  1309. same thread would illegally get the x-lock before the page read
  1310. is completed. The x-lock is cleared by the io-handler thread. */
  1311. rw_lock_x_lock_gen(&(block->lock), BUF_IO_READ);
  1312.   mutex_exit(&(buf_pool->mutex));
  1313. if (mode == BUF_READ_IBUF_PAGES_ONLY) {
  1314. mtr_commit(&mtr);
  1315. }
  1316. return(block);
  1317. }
  1318. /************************************************************************
  1319. Initializes a page to the buffer buf_pool. The page is usually not read
  1320. from a file even if it cannot be found in the buffer buf_pool. This is one
  1321. of the functions which perform to a block a state transition NOT_USED =>
  1322. FILE_PAGE (the other is buf_page_init_for_read above). */
  1323. buf_frame_t*
  1324. buf_page_create(
  1325. /*============*/
  1326. /* out: pointer to the frame, page bufferfixed */
  1327. ulint space, /* in: space id */
  1328. ulint offset, /* in: offset of the page within space in units of
  1329. a page */
  1330. mtr_t* mtr) /* in: mini-transaction handle */
  1331. {
  1332. buf_frame_t* frame;
  1333. buf_block_t* block;
  1334. buf_block_t* free_block = NULL;
  1335. ut_ad(mtr);
  1336. free_block = buf_LRU_get_free_block();
  1337. mutex_enter(&(buf_pool->mutex));
  1338. block = buf_page_hash_get(space, offset);
  1339. if (block != NULL) {
  1340. #ifdef UNIV_IBUF_DEBUG
  1341. ut_a(ibuf_count_get(block->space, block->offset) == 0);
  1342. #endif
  1343. block->file_page_was_freed = FALSE;
  1344. /* Page can be found in buf_pool */
  1345. mutex_exit(&(buf_pool->mutex));
  1346. buf_block_free(free_block);
  1347. frame = buf_page_get_with_no_latch(space, offset, mtr);
  1348. return(frame);
  1349. }
  1350. /* If we get here, the page was not in buf_pool: init it there */
  1351. if (buf_debug_prints) {
  1352. fprintf(stderr, "Creating space %lu page %lu to buffern",
  1353. (ulong) space, (ulong) offset);
  1354. }
  1355. block = free_block;
  1356. buf_page_init(space, offset, block);
  1357. /* The block must be put to the LRU list */
  1358. buf_LRU_add_block(block, FALSE);
  1359. #ifdef UNIV_SYNC_DEBUG
  1360. buf_block_buf_fix_inc_debug(block, __FILE__, __LINE__);
  1361. #else
  1362. buf_block_buf_fix_inc(block);
  1363. #endif
  1364. mtr_memo_push(mtr, block, MTR_MEMO_BUF_FIX);
  1365. block->accessed = TRUE;
  1366. buf_pool->n_pages_created++;
  1367. mutex_exit(&(buf_pool->mutex));
  1368. /* Delete possible entries for the page from the insert buffer:
  1369. such can exist if the page belonged to an index which was dropped */
  1370. ibuf_merge_or_delete_for_page(NULL, space, offset, TRUE);
  1371. /* Flush pages from the end of the LRU list if necessary */
  1372. buf_flush_free_margin();
  1373. frame = block->frame;
  1374. /* Reset to zero the file flush lsn field in the page; if the first
  1375. page of an ibdata file is 'created' in this function into the buffer
  1376. pool then we lose the original contents of the file flush lsn stamp.
  1377. Then InnoDB could in a crash recovery print a big, false, corruption
  1378. warning if the stamp contains an lsn bigger than the ib_logfile lsn. */
  1379. memset(frame + FIL_PAGE_FILE_FLUSH_LSN, 0, 8);
  1380. #ifdef UNIV_DEBUG
  1381. buf_dbg_counter++;
  1382. if (buf_dbg_counter % 357 == 0) {
  1383. ut_ad(buf_validate());
  1384. }
  1385. #endif
  1386. #ifdef UNIV_IBUF_DEBUG
  1387. ut_a(ibuf_count_get(block->space, block->offset) == 0);
  1388. #endif
  1389. return(frame);
  1390. }
  1391. /************************************************************************
  1392. Completes an asynchronous read or write request of a file page to or from
  1393. the buffer pool. */
  1394. void
  1395. buf_page_io_complete(
  1396. /*=================*/
  1397. buf_block_t* block) /* in: pointer to the block in question */
  1398. {
  1399. ulint io_type;
  1400. ulint read_page_no;
  1401. ut_ad(block);
  1402. ut_a(block->state == BUF_BLOCK_FILE_PAGE);
  1403. io_type = block->io_fix;
  1404. if (io_type == BUF_IO_READ) {
  1405. /* If this page is not uninitialized and not in the
  1406. doublewrite buffer, then the page number should be the
  1407. same as in block */
  1408. read_page_no = mach_read_from_4((block->frame)
  1409. + FIL_PAGE_OFFSET);
  1410. if (read_page_no != 0
  1411. && !trx_doublewrite_page_inside(read_page_no)
  1412.      && read_page_no != block->offset) {
  1413. fprintf(stderr,
  1414. "InnoDB: Error: page n:o stored in the page read in is %lu, should be %lu!n",
  1415. (ulong) read_page_no, (ulong) block->offset);
  1416. }
  1417. /* From version 3.23.38 up we store the page checksum
  1418.    to the 4 first bytes of the page end lsn field */
  1419. if (buf_page_is_corrupted(block->frame)) {
  1420.    fprintf(stderr,
  1421. "InnoDB: Database page corruption on disk or a failedn"
  1422. "InnoDB: file read of page %lu.n", (ulong) block->offset);
  1423.   
  1424. fputs(
  1425. "InnoDB: You may have to recover from a backup.n", stderr);
  1426. buf_page_print(block->frame);
  1427.    fprintf(stderr,
  1428. "InnoDB: Database page corruption on disk or a failedn"
  1429. "InnoDB: file read of page %lu.n", (ulong) block->offset);
  1430. fputs(
  1431. "InnoDB: You may have to recover from a backup.n", stderr);
  1432. fputs(
  1433. "InnoDB: It is also possible that your operatingn"
  1434. "InnoDB: system has corrupted its own file cachen"
  1435. "InnoDB: and rebooting your computer removes then"
  1436. "InnoDB: error.n"
  1437. "InnoDB: If the corrupt page is an index pagen"
  1438. "InnoDB: you can also try to fix the corruptionn"
  1439. "InnoDB: by dumping, dropping, and reimportingn"
  1440. "InnoDB: the corrupt table. You can use CHECKn"
  1441. "InnoDB: TABLE to scan your table for corruption.n"
  1442. "InnoDB: See also "
  1443. "http://dev.mysql.com/doc/mysql/en/Forcing_recovery.htmln"
  1444. "InnoDB: about forcing recovery.n", stderr);
  1445.   
  1446. if (srv_force_recovery < SRV_FORCE_IGNORE_CORRUPT) {
  1447. fputs(
  1448. "InnoDB: Ending processing because of a corrupt database page.n",
  1449. stderr);
  1450.    exit(1);
  1451.    }
  1452. }
  1453. if (recv_recovery_is_on()) {
  1454. recv_recover_page(FALSE, TRUE, block->frame,
  1455. block->space, block->offset);
  1456. }
  1457. if (!recv_no_ibuf_operations) {
  1458. ibuf_merge_or_delete_for_page(block->frame,
  1459. block->space, block->offset, TRUE);
  1460. }
  1461. }
  1462. #ifdef UNIV_IBUF_DEBUG
  1463. ut_a(ibuf_count_get(block->space, block->offset) == 0);
  1464. #endif
  1465. mutex_enter(&(buf_pool->mutex));
  1466. /* Because this thread which does the unlocking is not the same that
  1467. did the locking, we use a pass value != 0 in unlock, which simply
  1468. removes the newest lock debug record, without checking the thread
  1469. id. */
  1470. block->io_fix = 0;
  1471. if (io_type == BUF_IO_READ) {
  1472. /* NOTE that the call to ibuf may have moved the ownership of
  1473. the x-latch to this OS thread: do not let this confuse you in
  1474. debugging! */
  1475. ut_ad(buf_pool->n_pend_reads > 0);
  1476. buf_pool->n_pend_reads--;
  1477. buf_pool->n_pages_read++;
  1478. rw_lock_x_unlock_gen(&(block->lock), BUF_IO_READ);
  1479. if (buf_debug_prints) {
  1480. fputs("Has read ", stderr);
  1481. }
  1482. } else {
  1483. ut_ad(io_type == BUF_IO_WRITE);
  1484. /* Write means a flush operation: call the completion
  1485. routine in the flush system */
  1486. buf_flush_write_complete(block);
  1487. rw_lock_s_unlock_gen(&(block->lock), BUF_IO_WRITE);
  1488. buf_pool->n_pages_written++;
  1489. if (buf_debug_prints) {
  1490. fputs("Has written ", stderr);
  1491. }
  1492. }
  1493. mutex_exit(&(buf_pool->mutex));
  1494. if (buf_debug_prints) {
  1495. fprintf(stderr, "page space %lu page no %lun",
  1496. (ulong) block->space, (ulong) block->offset);
  1497. }
  1498. }
  1499. /*************************************************************************
  1500. Invalidates the file pages in the buffer pool when an archive recovery is
  1501. completed. All the file pages buffered must be in a replaceable state when
  1502. this function is called: not latched and not modified. */
  1503. void
  1504. buf_pool_invalidate(void)
  1505. /*=====================*/
  1506. {
  1507. ibool freed;
  1508. ut_ad(buf_all_freed());
  1509. freed = TRUE;
  1510. while (freed) {
  1511. freed = buf_LRU_search_and_free_block(100);
  1512. }
  1513. mutex_enter(&(buf_pool->mutex));
  1514. ut_ad(UT_LIST_GET_LEN(buf_pool->LRU) == 0);
  1515. mutex_exit(&(buf_pool->mutex));
  1516. }
  1517. /*************************************************************************
  1518. Validates the buffer buf_pool data structure. */
  1519. ibool
  1520. buf_validate(void)
  1521. /*==============*/
  1522. {
  1523. buf_block_t* block;
  1524. ulint i;
  1525. ulint n_single_flush = 0;
  1526. ulint n_lru_flush = 0;
  1527. ulint n_list_flush = 0;
  1528. ulint n_lru = 0;
  1529. ulint n_flush = 0;
  1530. ulint n_free = 0;
  1531. ulint n_page = 0;
  1532. ut_ad(buf_pool);
  1533. mutex_enter(&(buf_pool->mutex));
  1534. for (i = 0; i < buf_pool->curr_size; i++) {
  1535. block = buf_pool_get_nth_block(buf_pool, i);
  1536. if (block->state == BUF_BLOCK_FILE_PAGE) {
  1537. ut_a(buf_page_hash_get(block->space,
  1538. block->offset) == block);
  1539. n_page++;
  1540. #ifdef UNIV_IBUF_DEBUG
  1541. ut_a((block->io_fix == BUF_IO_READ)
  1542.      || ibuf_count_get(block->space, block->offset)
  1543. == 0);
  1544. #endif
  1545. if (block->io_fix == BUF_IO_WRITE) {
  1546. if (block->flush_type == BUF_FLUSH_LRU) {
  1547. n_lru_flush++;
  1548. ut_a(rw_lock_is_locked(&(block->lock),
  1549. RW_LOCK_SHARED));
  1550. } else if (block->flush_type ==
  1551. BUF_FLUSH_LIST) {
  1552. n_list_flush++;
  1553. } else if (block->flush_type ==
  1554. BUF_FLUSH_SINGLE_PAGE) {
  1555. n_single_flush++;
  1556. } else {
  1557. ut_error;
  1558. }
  1559. } else if (block->io_fix == BUF_IO_READ) {
  1560. ut_a(rw_lock_is_locked(&(block->lock),
  1561. RW_LOCK_EX));
  1562. }
  1563. n_lru++;
  1564. if (ut_dulint_cmp(block->oldest_modification,
  1565. ut_dulint_zero) > 0) {
  1566. n_flush++;
  1567. }
  1568. } else if (block->state == BUF_BLOCK_NOT_USED) {
  1569. n_free++;
  1570. }
  1571.   }
  1572. if (n_lru + n_free > buf_pool->curr_size) {
  1573. fprintf(stderr, "n LRU %lu, n free %lun", (ulong) n_lru, (ulong) n_free);
  1574. ut_error;
  1575. }
  1576. ut_a(UT_LIST_GET_LEN(buf_pool->LRU) == n_lru);
  1577. if (UT_LIST_GET_LEN(buf_pool->free) != n_free) {
  1578. fprintf(stderr, "Free list len %lu, free blocks %lun",
  1579. (ulong) UT_LIST_GET_LEN(buf_pool->free), (ulong) n_free);
  1580. ut_error;
  1581. }
  1582. ut_a(UT_LIST_GET_LEN(buf_pool->flush_list) == n_flush);
  1583. ut_a(buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE] == n_single_flush);
  1584. ut_a(buf_pool->n_flush[BUF_FLUSH_LIST] == n_list_flush);
  1585. ut_a(buf_pool->n_flush[BUF_FLUSH_LRU] == n_lru_flush);
  1586. mutex_exit(&(buf_pool->mutex));
  1587. ut_a(buf_LRU_validate());
  1588. ut_a(buf_flush_validate());
  1589. return(TRUE);
  1590. }
  1591. /*************************************************************************
  1592. Prints info of the buffer buf_pool data structure. */
  1593. void
  1594. buf_print(void)
  1595. /*===========*/
  1596. {
  1597. dulint* index_ids;
  1598. ulint* counts;
  1599. ulint size;
  1600. ulint i;
  1601. ulint j;
  1602. dulint id;
  1603. ulint n_found;
  1604. buf_frame_t*  frame;
  1605. dict_index_t* index;
  1606. ut_ad(buf_pool);
  1607. size = buf_pool->curr_size;
  1608. index_ids = mem_alloc(sizeof(dulint) * size);
  1609. counts = mem_alloc(sizeof(ulint) * size);
  1610. mutex_enter(&(buf_pool->mutex));
  1611. fprintf(stderr,
  1612. "buf_pool size %lun"
  1613. "database pages %lun"
  1614. "free pages %lun"
  1615. "modified database pages %lun"
  1616. "n pending reads %lun"
  1617. "n pending flush LRU %lu list %lu single page %lun"
  1618. "pages read %lu, created %lu, written %lun",
  1619. (ulong) size,
  1620. (ulong) UT_LIST_GET_LEN(buf_pool->LRU),
  1621. (ulong) UT_LIST_GET_LEN(buf_pool->free),
  1622. (ulong) UT_LIST_GET_LEN(buf_pool->flush_list),
  1623. (ulong) buf_pool->n_pend_reads,
  1624. (ulong) buf_pool->n_flush[BUF_FLUSH_LRU],
  1625. (ulong) buf_pool->n_flush[BUF_FLUSH_LIST],
  1626. (ulong) buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE],
  1627. (ulong) buf_pool->n_pages_read, buf_pool->n_pages_created,
  1628. (ulong) buf_pool->n_pages_written);
  1629. /* Count the number of blocks belonging to each index in the buffer */
  1630. n_found = 0;
  1631. for (i = 0 ; i < size; i++) {
  1632. counts[i] = 0;
  1633. }
  1634. for (i = 0; i < size; i++) {
  1635. frame = buf_pool_get_nth_block(buf_pool, i)->frame;
  1636. if (fil_page_get_type(frame) == FIL_PAGE_INDEX) {
  1637. id = btr_page_get_index_id(frame);
  1638. /* Look for the id in the index_ids array */
  1639. j = 0;
  1640. while (j < n_found) {
  1641. if (ut_dulint_cmp(index_ids[j], id) == 0) {
  1642. (counts[j])++;
  1643. break;
  1644. }
  1645. j++;
  1646. }
  1647. if (j == n_found) {
  1648. n_found++;
  1649. index_ids[j] = id;
  1650. counts[j] = 1;
  1651. }
  1652. }
  1653. }
  1654. mutex_exit(&(buf_pool->mutex));
  1655. for (i = 0; i < n_found; i++) {
  1656. index = dict_index_get_if_in_cache(index_ids[i]);
  1657. fprintf(stderr,
  1658. "Block count for index %lu in buffer is about %lu",
  1659.        (ulong) ut_dulint_get_low(index_ids[i]),
  1660.        (ulong) counts[i]);
  1661. if (index) {
  1662. putc(' ', stderr);
  1663. dict_index_name_print(stderr, NULL, index);
  1664. }
  1665. putc('n', stderr);
  1666. }
  1667. mem_free(index_ids);
  1668. mem_free(counts);
  1669. ut_a(buf_validate());
  1670. }
  1671. /*************************************************************************
  1672. Returns the number of pending buf pool ios. */
  1673. ulint
  1674. buf_get_n_pending_ios(void)
  1675. /*=======================*/
  1676. {
  1677. return(buf_pool->n_pend_reads
  1678. + buf_pool->n_flush[BUF_FLUSH_LRU]
  1679. + buf_pool->n_flush[BUF_FLUSH_LIST]
  1680. + buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]);
  1681. }
  1682. /*************************************************************************
  1683. Returns the ratio in percents of modified pages in the buffer pool /
  1684. database pages in the buffer pool. */
  1685. ulint
  1686. buf_get_modified_ratio_pct(void)
  1687. /*============================*/
  1688. {
  1689. ulint ratio;
  1690. mutex_enter(&(buf_pool->mutex));
  1691. ratio = (100 * UT_LIST_GET_LEN(buf_pool->flush_list))
  1692.      / (1 + UT_LIST_GET_LEN(buf_pool->LRU)
  1693.         + UT_LIST_GET_LEN(buf_pool->free));
  1694.        /* 1 + is there to avoid division by zero */   
  1695. mutex_exit(&(buf_pool->mutex));
  1696. return(ratio);
  1697. }
  1698. /*************************************************************************
  1699. Prints info of the buffer i/o. */
  1700. void
  1701. buf_print_io(
  1702. /*=========*/
  1703. FILE* file) /* in/out: buffer where to print */
  1704. {
  1705. time_t current_time;
  1706. double time_elapsed;
  1707. ulint size;
  1708. ut_ad(buf_pool);
  1709. size = buf_pool->curr_size;
  1710. mutex_enter(&(buf_pool->mutex));
  1711. if (srv_use_awe) {
  1712. fprintf(stderr,
  1713. "AWE: Buffer pool memory frames                        %lun",
  1714. (ulong) buf_pool->n_frames);
  1715. fprintf(stderr,
  1716. "AWE: Database pages and free buffers mapped in frames %lun",
  1717. (ulong) UT_LIST_GET_LEN(buf_pool->awe_LRU_free_mapped));
  1718. }
  1719. fprintf(file,
  1720. "Buffer pool size   %lun"
  1721. "Free buffers       %lun"
  1722. "Database pages     %lun"
  1723. "Modified db pages  %lun"
  1724. "Pending reads %lun"
  1725. "Pending writes: LRU %lu, flush list %lu, single page %lun",
  1726. (ulong) size,
  1727. (ulong) UT_LIST_GET_LEN(buf_pool->free),
  1728. (ulong) UT_LIST_GET_LEN(buf_pool->LRU),
  1729. (ulong) UT_LIST_GET_LEN(buf_pool->flush_list),
  1730. (ulong) buf_pool->n_pend_reads,
  1731. (ulong) buf_pool->n_flush[BUF_FLUSH_LRU]
  1732. + buf_pool->init_flush[BUF_FLUSH_LRU],
  1733. (ulong) buf_pool->n_flush[BUF_FLUSH_LIST]
  1734. + buf_pool->init_flush[BUF_FLUSH_LIST],
  1735. (ulong) buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]);
  1736. current_time = time(NULL);
  1737. time_elapsed = 0.001 + difftime(current_time,
  1738. buf_pool->last_printout_time);
  1739. buf_pool->last_printout_time = current_time;
  1740. fprintf(file,
  1741. "Pages read %lu, created %lu, written %lun"
  1742. "%.2f reads/s, %.2f creates/s, %.2f writes/sn",
  1743. (ulong) buf_pool->n_pages_read,
  1744. (ulong) buf_pool->n_pages_created,
  1745. (ulong) buf_pool->n_pages_written,
  1746. (buf_pool->n_pages_read - buf_pool->n_pages_read_old)
  1747. / time_elapsed,
  1748. (buf_pool->n_pages_created - buf_pool->n_pages_created_old)
  1749. / time_elapsed,
  1750. (buf_pool->n_pages_written - buf_pool->n_pages_written_old)
  1751. / time_elapsed);
  1752. if (srv_use_awe) {
  1753. fprintf(file, "AWE: %.2f page remaps/sn",
  1754. (buf_pool->n_pages_awe_remapped
  1755. - buf_pool->n_pages_awe_remapped_old)
  1756. / time_elapsed);
  1757. }
  1758. if (buf_pool->n_page_gets > buf_pool->n_page_gets_old) {
  1759. fprintf(file, "Buffer pool hit rate %lu / 1000n",
  1760.        (ulong) (1000
  1761. - ((1000 *
  1762.     (buf_pool->n_pages_read - buf_pool->n_pages_read_old))
  1763. / (buf_pool->n_page_gets - buf_pool->n_page_gets_old))));
  1764. } else {
  1765. fputs("No buffer pool page gets since the last printoutn",
  1766. file);
  1767. }
  1768. buf_pool->n_page_gets_old = buf_pool->n_page_gets;
  1769. buf_pool->n_pages_read_old = buf_pool->n_pages_read;
  1770. buf_pool->n_pages_created_old = buf_pool->n_pages_created;
  1771. buf_pool->n_pages_written_old = buf_pool->n_pages_written;
  1772. buf_pool->n_pages_awe_remapped_old = buf_pool->n_pages_awe_remapped;
  1773. mutex_exit(&(buf_pool->mutex));
  1774. }
  1775. /**************************************************************************
  1776. Refreshes the statistics used to print per-second averages. */
  1777. void
  1778. buf_refresh_io_stats(void)
  1779. /*======================*/
  1780. {
  1781.         buf_pool->last_printout_time = time(NULL);
  1782. buf_pool->n_page_gets_old = buf_pool->n_page_gets;
  1783. buf_pool->n_pages_read_old = buf_pool->n_pages_read;
  1784. buf_pool->n_pages_created_old = buf_pool->n_pages_created;
  1785. buf_pool->n_pages_written_old = buf_pool->n_pages_written;
  1786. buf_pool->n_pages_awe_remapped_old = buf_pool->n_pages_awe_remapped; 
  1787. }
  1788. /*************************************************************************
  1789. Checks that all file pages in the buffer are in a replaceable state. */
  1790. ibool
  1791. buf_all_freed(void)
  1792. /*===============*/
  1793. {
  1794. buf_block_t* block;
  1795. ulint i;
  1796. ut_ad(buf_pool);
  1797. mutex_enter(&(buf_pool->mutex));
  1798. for (i = 0; i < buf_pool->curr_size; i++) {
  1799. block = buf_pool_get_nth_block(buf_pool, i);
  1800. if (block->state == BUF_BLOCK_FILE_PAGE) {
  1801. if (!buf_flush_ready_for_replace(block)) {
  1802. fprintf(stderr,
  1803. "Page %lu %lu still fixed or dirtyn",
  1804. (ulong) block->space, (ulong) block->offset);
  1805.      ut_error;
  1806. }
  1807. }
  1808.   }
  1809. mutex_exit(&(buf_pool->mutex));
  1810. return(TRUE);
  1811. }
  1812. /*************************************************************************
  1813. Checks that there currently are no pending i/o-operations for the buffer
  1814. pool. */
  1815. ibool
  1816. buf_pool_check_no_pending_io(void)
  1817. /*==============================*/
  1818. /* out: TRUE if there is no pending i/o */
  1819. {
  1820. ibool ret;
  1821. mutex_enter(&(buf_pool->mutex));
  1822. if (buf_pool->n_pend_reads + buf_pool->n_flush[BUF_FLUSH_LRU]
  1823. + buf_pool->n_flush[BUF_FLUSH_LIST]
  1824. + buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]) {
  1825. ret = FALSE;
  1826. } else {
  1827. ret = TRUE;
  1828. }
  1829. mutex_exit(&(buf_pool->mutex));
  1830. return(ret);
  1831. }
  1832. /*************************************************************************
  1833. Gets the current length of the free list of buffer blocks. */
  1834. ulint
  1835. buf_get_free_list_len(void)
  1836. /*=======================*/
  1837. {
  1838. ulint len;
  1839. mutex_enter(&(buf_pool->mutex));
  1840. len = UT_LIST_GET_LEN(buf_pool->free);
  1841. mutex_exit(&(buf_pool->mutex));
  1842. return(len);
  1843. }