buf0buf.c 65.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
/*   Innobase relational database engine; Copyright (C) 2001 Innobase Oy
     
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License 2
     as published by the Free Software Foundation in June 1991.
     
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     
     You should have received a copy of the GNU General Public License 2
     along with this program (in file COPYING); if not, write to the Free
     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
/******************************************************
The database buffer buf_pool

(c) 1995 Innobase Oy

Created 11/5/1995 Heikki Tuuri
*******************************************************/

#include "buf0buf.h"

#ifdef UNIV_NONINL
#include "buf0buf.ic"
#endif

#include "mem0mem.h"
#include "btr0btr.h"
#include "fil0fil.h"
#include "lock0lock.h"
#include "btr0sea.h"
#include "ibuf0ibuf.h"
#include "dict0dict.h"
#include "log0recv.h"
37
#include "log0log.h"
38 39
#include "trx0undo.h"
#include "srv0srv.h"
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199

/*
		IMPLEMENTATION OF THE BUFFER POOL
		=================================

Performance improvement: 
------------------------
Thread scheduling in NT may be so slow that the OS wait mechanism should
not be used even in waiting for disk reads to complete.
Rather, we should put waiting query threads to the queue of
waiting jobs, and let the OS thread do something useful while the i/o
is processed. In this way we could remove most OS thread switches in
an i/o-intensive benchmark like TPC-C.

A possibility is to put a user space thread library between the database
and NT. User space thread libraries might be very fast.

SQL Server 7.0 can be configured to use 'fibers' which are lightweight
threads in NT. These should be studied.

		Buffer frames and blocks
		------------------------
Following the terminology of Gray and Reuter, we call the memory
blocks where file pages are loaded buffer frames. For each buffer
frame there is a control block, or shortly, a block, in the buffer
control array. The control info which does not need to be stored
in the file along with the file page, resides in the control block.

		Buffer pool struct
		------------------
The buffer buf_pool contains a single mutex which protects all the
control data structures of the buf_pool. The content of a buffer frame is
protected by a separate read-write lock in its control block, though.
These locks can be locked and unlocked without owning the buf_pool mutex.
The OS events in the buf_pool struct can be waited for without owning the
buf_pool mutex.

The buf_pool mutex is a hot-spot in main memory, causing a lot of
memory bus traffic on multiprocessor systems when processors
alternately access the mutex. On our Pentium, the mutex is accessed
maybe every 10 microseconds. We gave up the solution to have mutexes
for each control block, for instance, because it seemed to be
complicated.

A solution to reduce mutex contention of the buf_pool mutex is to
create a separate mutex for the page hash table. On Pentium,
accessing the hash table takes 2 microseconds, about half
of the total buf_pool mutex hold time.

		Control blocks
		--------------

The control block contains, for instance, the bufferfix count
which is incremented when a thread wants a file page to be fixed
in a buffer frame. The bufferfix operation does not lock the
contents of the frame, however. For this purpose, the control
block contains a read-write lock.

The buffer frames have to be aligned so that the start memory
address of a frame is divisible by the universal page size, which
is a power of two.

We intend to make the buffer buf_pool size on-line reconfigurable,
that is, the buf_pool size can be changed without closing the database.
Then the database administarator may adjust it to be bigger
at night, for example. The control block array must
contain enough control blocks for the maximum buffer buf_pool size
which is used in the particular database.
If the buf_pool size is cut, we exploit the virtual memory mechanism of
the OS, and just refrain from using frames at high addresses. Then the OS
can swap them to disk.

The control blocks containing file pages are put to a hash table
according to the file address of the page.
We could speed up the access to an individual page by using
"pointer swizzling": we could replace the page references on
non-leaf index pages by direct pointers to the page, if it exists
in the buf_pool. We could make a separate hash table where we could
chain all the page references in non-leaf pages residing in the buf_pool,
using the page reference as the hash key,
and at the time of reading of a page update the pointers accordingly.
Drawbacks of this solution are added complexity and,
possibly, extra space required on non-leaf pages for memory pointers.
A simpler solution is just to speed up the hash table mechanism
in the database, using tables whose size is a power of 2.

		Lists of blocks
		---------------

There are several lists of control blocks. The free list contains
blocks which are currently not used.

The LRU-list contains all the blocks holding a file page
except those for which the bufferfix count is non-zero.
The pages are in the LRU list roughly in the order of the last
access to the page, so that the oldest pages are at the end of the
list. We also keep a pointer to near the end of the LRU list,
which we can use when we want to artificially age a page in the
buf_pool. This is used if we know that some page is not needed
again for some time: we insert the block right after the pointer,
causing it to be replaced sooner than would noramlly be the case.
Currently this aging mechanism is used for read-ahead mechanism
of pages, and it can also be used when there is a scan of a full
table which cannot fit in the memory. Putting the pages near the
of the LRU list, we make sure that most of the buf_pool stays in the
main memory, undisturbed.

The chain of modified blocks contains the blocks
holding file pages that have been modified in the memory
but not written to disk yet. The block with the oldest modification
which has not yet been written to disk is at the end of the chain.

		Loading a file page
		-------------------

First, a victim block for replacement has to be found in the
buf_pool. It is taken from the free list or searched for from the
end of the LRU-list. An exclusive lock is reserved for the frame,
the io_fix field is set in the block fixing the block in buf_pool,
and the io-operation for loading the page is queued. The io-handler thread
releases the X-lock on the frame and resets the io_fix field
when the io operation completes.

A thread may request the above operation using the buf_page_get-
function. It may then continue to request a lock on the frame.
The lock is granted when the io-handler releases the x-lock.

		Read-ahead
		----------

The read-ahead mechanism is intended to be intelligent and
isolated from the semantically higher levels of the database
index management. From the higher level we only need the
information if a file page has a natural successor or
predecessor page. On the leaf level of a B-tree index,
these are the next and previous pages in the natural
order of the pages.

Let us first explain the read-ahead mechanism when the leafs
of a B-tree are scanned in an ascending or descending order.
When a read page is the first time referenced in the buf_pool,
the buffer manager checks if it is at the border of a so-called
linear read-ahead area. The tablespace is divided into these
areas of size 64 blocks, for example. So if the page is at the
border of such an area, the read-ahead mechanism checks if
all the other blocks in the area have been accessed in an
ascending or descending order. If this is the case, the system
looks at the natural successor or predecessor of the page,
checks if that is at the border of another area, and in this case
issues read-requests for all the pages in that area. Maybe
we could relax the condition that all the pages in the area
have to be accessed: if data is deleted from a table, there may
appear holes of unused pages in the area.

A different read-ahead mechanism is used when there appears
to be a random access pattern to a file.
If a new page is referenced in the buf_pool, and several pages
of its random access area (for instance, 32 consecutive pages
in a tablespace) have recently been referenced, we may predict
that the whole area may be needed in the near future, and issue
unknown's avatar
unknown committed
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222
the read requests for the whole area.

		AWE implementation
		------------------

By a 'block' we mean the buffer header of type buf_block_t. By a 'page'
we mean the physical 16 kB memory area allocated from RAM for that block.
By a 'frame' we mean a 16 kB area in the virtual address space of the
process, in the frame_mem of buf_pool.

We can map pages to the frames of the buffer pool.

1) A buffer block allocated to use as a non-data page, e.g., to the lock
table, is always mapped to a frame.
2) A bufferfixed or io-fixed data page is always mapped to a frame.
3) When we need to map a block to frame, we look from the list
awe_LRU_free_mapped and try to unmap its last block, but note that
bufferfixed or io-fixed pages cannot be unmapped.
4) For every frame in the buffer pool there is always a block whose page is
mapped to it. When we create the buffer pool, we map the first elements
in the free list to the frames.
5) When we have AWE enabled, we disable adaptive hash indexes.
*/
223

224 225 226
/* Value in microseconds */
static const int WAIT_FOR_READ	= 20000;

227 228
buf_pool_t*	buf_pool = NULL; /* The buffer buf_pool of the database */

229
#ifdef UNIV_DEBUG
230
ulint		buf_dbg_counter	= 0; /* This is used to insert validation
231 232 233 234 235
					operations in excution in the
					debug version */
ibool		buf_debug_prints = FALSE; /* If this is set TRUE,
					the program prints info whenever
					read-ahead or flush occurs */
236
#endif /* UNIV_DEBUG */
237 238
/************************************************************************
Calculates a page checksum which is stored to the page when it is written
unknown's avatar
unknown committed
239 240
to a file. Note that we must be careful to calculate the same value on
32-bit and 64-bit architectures. */
241 242

ulint
unknown's avatar
unknown committed
243 244
buf_calc_page_new_checksum(
/*=======================*/
245 246 247
		       /* out: checksum */
	byte*    page) /* in: buffer page */
{
248
  	ulint checksum;
249

unknown's avatar
unknown committed
250 251 252 253
        /* Since the field FIL_PAGE_FILE_FLUSH_LSN, and in versions <= 4.1.x
        ..._ARCH_LOG_NO, are written outside the buffer pool to the first
        pages of data files, we have to skip them in the page checksum
        calculation.
unknown's avatar
unknown committed
254 255 256 257 258 259 260 261 262
	We must also skip the field FIL_PAGE_SPACE_OR_CHKSUM where the
	checksum is stored, and also the last 8 bytes of page because
	there we store the old formula checksum. */
  	
  	checksum = ut_fold_binary(page + FIL_PAGE_OFFSET,
				 FIL_PAGE_FILE_FLUSH_LSN - FIL_PAGE_OFFSET)
  		   + ut_fold_binary(page + FIL_PAGE_DATA, 
				           UNIV_PAGE_SIZE - FIL_PAGE_DATA
				           - FIL_PAGE_END_LSN_OLD_CHKSUM);
unknown's avatar
unknown committed
263
  	checksum = checksum & 0xFFFFFFFFUL;
unknown's avatar
unknown committed
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282

  	return(checksum);
}

/************************************************************************
In versions < 4.0.14 and < 4.1.1 there was a bug that the checksum only
looked at the first few bytes of the page. This calculates that old
checksum. 
NOTE: we must first store the new formula checksum to
FIL_PAGE_SPACE_OR_CHKSUM before calculating and storing this old checksum
because this takes that field as an input! */

ulint
buf_calc_page_old_checksum(
/*=======================*/
		       /* out: checksum */
	byte*    page) /* in: buffer page */
{
  	ulint checksum;
unknown's avatar
unknown committed
283
  	
284
  	checksum = ut_fold_binary(page, FIL_PAGE_FILE_FLUSH_LSN);
unknown's avatar
unknown committed
285

unknown's avatar
unknown committed
286
  	checksum = checksum & 0xFFFFFFFFUL;
287

288 289 290 291 292 293 294 295 296 297 298 299 300
  	return(checksum);
}

/************************************************************************
Checks if a page is corrupt. */

ibool
buf_page_is_corrupted(
/*==================*/
				/* out: TRUE if corrupted */
	byte*	read_buf)	/* in: a database page */
{
	ulint	checksum;
unknown's avatar
unknown committed
301 302 303
	ulint	old_checksum;
	ulint	checksum_field;
	ulint	old_checksum_field;
unknown's avatar
unknown committed
304
#ifndef UNIV_HOTBACKUP
305
	dulint	current_lsn;
unknown's avatar
unknown committed
306
#endif
unknown's avatar
unknown committed
307 308 309
	if (mach_read_from_4(read_buf + FIL_PAGE_LSN + 4)
	     != mach_read_from_4(read_buf + UNIV_PAGE_SIZE
				- FIL_PAGE_END_LSN_OLD_CHKSUM + 4)) {
310

unknown's avatar
unknown committed
311 312 313 314 315 316
		/* Stored log sequence numbers at the start and the end
		of page do not match */

		return(TRUE);
	}

317 318 319 320 321 322 323 324 325 326
#ifndef UNIV_HOTBACKUP
	if (recv_lsn_checks_on && log_peek_lsn(&current_lsn)) {
		if (ut_dulint_cmp(current_lsn,
				  mach_read_from_8(read_buf + FIL_PAGE_LSN))
				 < 0) {
			ut_print_timestamp(stderr);

			fprintf(stderr,
"  InnoDB: Error: page %lu log sequence number %lu %lu\n"
"InnoDB: is in the future! Current system log sequence number %lu %lu.\n"
327 328
"InnoDB: Your database may be corrupt or you may have copied the InnoDB\n"
"InnoDB: tablespace but not the InnoDB log files. See\n"
unknown's avatar
unknown committed
329 330
"InnoDB: http://dev.mysql.com/doc/refman/5.0/en/forcing-recovery.html\n"
"InnoDB: for more information.\n",
331 332
		        (ulong) mach_read_from_4(read_buf + FIL_PAGE_OFFSET),
			(ulong) ut_dulint_get_high(
333
				mach_read_from_8(read_buf + FIL_PAGE_LSN)),
334
			(ulong) ut_dulint_get_low(
335
				mach_read_from_8(read_buf + FIL_PAGE_LSN)),
336 337
			(ulong) ut_dulint_get_high(current_lsn),
			(ulong) ut_dulint_get_low(current_lsn));
338 339 340
		}
	}
#endif
341 342 343 344 345 346 347 348 349 350
  
  /* If we use checksums validation, make additional check before returning
  TRUE to ensure that the checksum is not equal to BUF_NO_CHECKSUM_MAGIC which
  might be stored by InnoDB with checksums disabled.
     Otherwise, skip checksum calculation and return FALSE */
  
  if (srv_use_checksums) {
    old_checksum = buf_calc_page_old_checksum(read_buf); 

    old_checksum_field = mach_read_from_4(read_buf + UNIV_PAGE_SIZE
unknown's avatar
unknown committed
351
					- FIL_PAGE_END_LSN_OLD_CHKSUM);
352

353 354 355 356
    /* There are 2 valid formulas for old_checksum_field:
	  1. Very old versions of InnoDB only stored 8 byte lsn to the start
	  and the end of the page.
	  2. Newer InnoDB versions store the old formula checksum there. */
357
	
358 359 360
    if (old_checksum_field != mach_read_from_4(read_buf + FIL_PAGE_LSN)
        && old_checksum_field != old_checksum
        && old_checksum_field != BUF_NO_CHECKSUM_MAGIC) {
unknown's avatar
unknown committed
361

362 363
      return(TRUE);
    }
364

365 366
    checksum = buf_calc_page_new_checksum(read_buf);
    checksum_field = mach_read_from_4(read_buf + FIL_PAGE_SPACE_OR_CHKSUM);
unknown's avatar
unknown committed
367

368 369
    /* InnoDB versions < 4.0.14 and < 4.1.1 stored the space id
	  (always equal to 0), to FIL_PAGE_SPACE_SPACE_OR_CHKSUM */
unknown's avatar
unknown committed
370

371 372
    if (checksum_field != 0 && checksum_field != checksum
        && checksum_field != BUF_NO_CHECKSUM_MAGIC) {
unknown's avatar
unknown committed
373

374 375 376 377
      return(TRUE);
    }
  }
  
378
	return(FALSE);
379 380
}

381 382 383 384 385 386 387 388 389 390
/************************************************************************
Prints a page to stderr. */

void
buf_page_print(
/*===========*/
	byte*	read_buf)	/* in: a database page */
{
	dict_index_t*	index;
	ulint		checksum;
unknown's avatar
unknown committed
391
	ulint		old_checksum;
392

unknown's avatar
unknown committed
393
	ut_print_timestamp(stderr);
394 395 396 397
	fprintf(stderr, "  InnoDB: Page dump in ascii and hex (%lu bytes):\n",
		(ulint)UNIV_PAGE_SIZE);
	ut_print_buf(stderr, read_buf, UNIV_PAGE_SIZE);
	fputs("InnoDB: End of page dump\n", stderr);
398

399 400 401 402
	checksum = srv_use_checksums ?
    buf_calc_page_new_checksum(read_buf) : BUF_NO_CHECKSUM_MAGIC;
	old_checksum = srv_use_checksums ?
    buf_calc_page_old_checksum(read_buf) : BUF_NO_CHECKSUM_MAGIC;
403

unknown's avatar
unknown committed
404
	ut_print_timestamp(stderr);
unknown's avatar
unknown committed
405 406 407
	fprintf(stderr, 
"  InnoDB: Page checksum %lu, prior-to-4.0.14-form checksum %lu\n"
"InnoDB: stored checksum %lu, prior-to-4.0.14-form stored checksum %lu\n",
408 409 410
			(ulong) checksum, (ulong) old_checksum,
			(ulong) mach_read_from_4(read_buf + FIL_PAGE_SPACE_OR_CHKSUM),
			(ulong) mach_read_from_4(read_buf + UNIV_PAGE_SIZE
unknown's avatar
unknown committed
411
					- FIL_PAGE_END_LSN_OLD_CHKSUM));
412
	fprintf(stderr,
unknown's avatar
unknown committed
413 414 415
"InnoDB: Page lsn %lu %lu, low 4 bytes of lsn at page end %lu\n"
"InnoDB: Page number (if stored to page already) %lu,\n"
"InnoDB: space id (if created with >= MySQL-4.1.1 and stored already) %lu\n",
416 417 418
		(ulong) mach_read_from_4(read_buf + FIL_PAGE_LSN),
		(ulong) mach_read_from_4(read_buf + FIL_PAGE_LSN + 4),
		(ulong) mach_read_from_4(read_buf + UNIV_PAGE_SIZE
unknown's avatar
unknown committed
419
					- FIL_PAGE_END_LSN_OLD_CHKSUM + 4),
420 421
		(ulong) mach_read_from_4(read_buf + FIL_PAGE_OFFSET),
		(ulong) mach_read_from_4(read_buf + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID));
unknown's avatar
unknown committed
422

423 424 425 426 427 428 429 430 431 432 433 434 435
	if (mach_read_from_2(read_buf + TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_TYPE)
	    == TRX_UNDO_INSERT) {
	    	fprintf(stderr,
			"InnoDB: Page may be an insert undo log page\n");
	} else if (mach_read_from_2(read_buf + TRX_UNDO_PAGE_HDR
						+ TRX_UNDO_PAGE_TYPE)
	    	== TRX_UNDO_UPDATE) {
	    	fprintf(stderr,
			"InnoDB: Page may be an update undo log page\n");
	}

	if (fil_page_get_type(read_buf) == FIL_PAGE_INDEX) {
	    	fprintf(stderr,
unknown's avatar
unknown committed
436
"InnoDB: Page may be an index page where index id is %lu %lu\n",
437 438
			(ulong) ut_dulint_get_high(btr_page_get_index_id(read_buf)),
			(ulong) ut_dulint_get_low(btr_page_get_index_id(read_buf)));
439

unknown's avatar
unknown committed
440 441 442 443 444 445
		/* If the code is in ibbackup, dict_sys may be uninitialized,
		i.e., NULL */

		if (dict_sys != NULL) {

		        index = dict_index_find_on_id_low(
446
					btr_page_get_index_id(read_buf));
unknown's avatar
unknown committed
447
		        if (index) {
448
				fputs("InnoDB: (", stderr);
449
				dict_index_name_print(stderr, NULL, index);
450
				fputs(")\n", stderr);
unknown's avatar
unknown committed
451
			}
452
		}
unknown's avatar
unknown committed
453
	} else if (fil_page_get_type(read_buf) == FIL_PAGE_INODE) {
454
		fputs("InnoDB: Page may be an 'inode' page\n", stderr);
unknown's avatar
unknown committed
455
	} else if (fil_page_get_type(read_buf) == FIL_PAGE_IBUF_FREE_LIST) {
456 457
		fputs("InnoDB: Page may be an insert buffer free list page\n",
			stderr);
458 459 460
	}
}

461 462 463 464 465 466 467
/************************************************************************
Initializes a buffer control block when the buf_pool is created. */
static
void
buf_block_init(
/*===========*/
	buf_block_t*	block,	/* in: pointer to control block */
unknown's avatar
unknown committed
468 469
	byte*		frame)	/* in: pointer to buffer frame, or NULL if in
				the case of AWE there is no frame */
470
{
unknown's avatar
unknown committed
471 472
	block->magic_n = 0;

473 474 475 476
	block->state = BUF_BLOCK_NOT_USED;
	
	block->frame = frame;

unknown's avatar
unknown committed
477 478
	block->awe_info = NULL;

unknown's avatar
unknown committed
479 480 481
	block->buf_fix_count = 0;
	block->io_fix = 0;

482 483
	block->modify_clock = ut_dulint_zero;
	
unknown's avatar
unknown committed
484 485
	block->file_page_was_freed = FALSE;

unknown's avatar
unknown committed
486
	block->check_index_page_at_flush = FALSE;
unknown's avatar
unknown committed
487
	block->index = NULL;
unknown's avatar
unknown committed
488

unknown's avatar
unknown committed
489 490 491 492 493
	block->in_free_list = FALSE;
	block->in_LRU_list = FALSE;

	block->n_pointers = 0;

494 495 496
	mutex_create(&block->mutex);
	mutex_set_level(&block->mutex, SYNC_BUF_BLOCK);

497 498 499
	rw_lock_create(&(block->lock));
	ut_ad(rw_lock_validate(&(block->lock)));

unknown's avatar
unknown committed
500
#ifdef UNIV_SYNC_DEBUG
501 502
	rw_lock_create(&(block->debug_latch));
	rw_lock_set_level(&(block->debug_latch), SYNC_NO_ORDER_CHECK);
503
#endif /* UNIV_SYNC_DEBUG */
504 505 506
}

/************************************************************************
unknown's avatar
unknown committed
507 508
Creates the buffer pool. */

509
buf_pool_t*
unknown's avatar
unknown committed
510 511
buf_pool_init(
/*==========*/
512
				/* out, own: buf_pool object, NULL if not
unknown's avatar
unknown committed
513
				enough memory or error */
514 515
	ulint	max_size,	/* in: maximum size of the buf_pool in
				blocks */
unknown's avatar
unknown committed
516
	ulint	curr_size,	/* in: current size to use, must be <=
517 518
				max_size, currently must be equal to
				max_size */
unknown's avatar
unknown committed
519 520 521 522 523
	ulint	n_frames)	/* in: number of frames; if AWE is used,
				this is the size of the address space window
				where physical memory pages are mapped; if
				AWE is not used then this must be the same
				as max_size */
524 525 526 527 528 529
{
	byte*		frame;
	ulint		i;
	buf_block_t*	block;
	
	ut_a(max_size == curr_size);
unknown's avatar
unknown committed
530
	ut_a(srv_use_awe || n_frames == max_size);
531
	
unknown's avatar
unknown committed
532 533 534 535
	if (n_frames > curr_size) {
	        fprintf(stderr,
"InnoDB: AWE: Error: you must specify in my.cnf .._awe_mem_mb larger\n"
"InnoDB: than .._buffer_pool_size. Now the former is %lu pages,\n"
536
"InnoDB: the latter %lu pages.\n", (ulong) curr_size, (ulong) n_frames);
unknown's avatar
unknown committed
537 538 539 540

		return(NULL);
	}

541 542 543 544 545 546 547 548
	buf_pool = mem_alloc(sizeof(buf_pool_t));

	/* 1. Initialize general fields
	   ---------------------------- */
	mutex_create(&(buf_pool->mutex));
	mutex_set_level(&(buf_pool->mutex), SYNC_BUF_POOL);

	mutex_enter(&(buf_pool->mutex));
unknown's avatar
unknown committed
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565

	if (srv_use_awe) {
		/*----------------------------------------*/
		/* Allocate the virtual address space window, i.e., the
		buffer pool frames */

		buf_pool->frame_mem = os_awe_allocate_virtual_mem_window(
					UNIV_PAGE_SIZE * (n_frames + 1));
					
		/* Allocate the physical memory for AWE and the AWE info array
		for buf_pool */

		if ((curr_size % ((1024 * 1024) / UNIV_PAGE_SIZE)) != 0) {

		        fprintf(stderr,
"InnoDB: AWE: Error: physical memory must be allocated in full megabytes.\n"
"InnoDB: Trying to allocate %lu database pages.\n", 
566
			  (ulong) curr_size);
unknown's avatar
unknown committed
567 568 569 570 571 572 573 574 575 576 577

		        return(NULL);
		}

		if (!os_awe_allocate_physical_mem(&(buf_pool->awe_info),
			curr_size / ((1024 * 1024) / UNIV_PAGE_SIZE))) {

			return(NULL);
		}
		/*----------------------------------------*/
	} else {
578
		buf_pool->frame_mem = os_mem_alloc_large(
unknown's avatar
unknown committed
579 580
					UNIV_PAGE_SIZE * (n_frames + 1),
					TRUE, FALSE);
unknown's avatar
unknown committed
581
	}
582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597

	if (buf_pool->frame_mem == NULL) {

		return(NULL);
	}

	buf_pool->blocks = ut_malloc(sizeof(buf_block_t) * max_size);

	if (buf_pool->blocks == NULL) {

		return(NULL);
	}

	buf_pool->max_size = max_size;
	buf_pool->curr_size = curr_size;

unknown's avatar
unknown committed
598 599
	buf_pool->n_frames = n_frames;

600 601 602 603
	/* Align pointer to the first frame */

	frame = ut_align(buf_pool->frame_mem, UNIV_PAGE_SIZE);

unknown's avatar
unknown committed
604
	buf_pool->frame_zero = frame;
605
	buf_pool->high_end = frame + UNIV_PAGE_SIZE * n_frames;
606

unknown's avatar
unknown committed
607 608 609 610 611 612
	if (srv_use_awe) {
		/*----------------------------------------*/
		/* Map an initial part of the allocated physical memory to
		the window */

		os_awe_map_physical_mem_to_window(buf_pool->frame_zero,
unknown's avatar
unknown committed
613 614
				n_frames *
				(UNIV_PAGE_SIZE / OS_AWE_X86_PAGE_SIZE),
unknown's avatar
unknown committed
615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630
					buf_pool->awe_info);
		/*----------------------------------------*/
	}

	buf_pool->blocks_of_frames = ut_malloc(sizeof(void*) * n_frames);
	
	if (buf_pool->blocks_of_frames == NULL) {

		return(NULL);
	}

	/* Init block structs and assign frames for them; in the case of
	AWE there are less frames than blocks. Then we assign the frames
	to the first blocks (we already mapped the memory above). We also
	init the awe_info for every block. */

631 632 633
	for (i = 0; i < max_size; i++) {

		block = buf_pool_get_nth_block(buf_pool, i);
unknown's avatar
unknown committed
634 635 636 637 638 639 640 641

		if (i < n_frames) {
			frame = buf_pool->frame_zero + i * UNIV_PAGE_SIZE;
			*(buf_pool->blocks_of_frames + i) = block;
		} else {
			frame = NULL;
		}
		
642
		buf_block_init(block, frame);
unknown's avatar
unknown committed
643 644 645 646 647 648 649

		if (srv_use_awe) {
			/*----------------------------------------*/
			block->awe_info = buf_pool->awe_info
				+ i * (UNIV_PAGE_SIZE / OS_AWE_X86_PAGE_SIZE);
			/*----------------------------------------*/
		}
650
	}
unknown's avatar
unknown committed
651

unknown's avatar
unknown committed
652
	buf_pool->page_hash = hash0_create(2 * max_size);
653 654

	buf_pool->n_pend_reads = 0;
655 656 657

	buf_pool->last_printout_time = time(NULL);

658 659 660
	buf_pool->n_pages_read = 0;
	buf_pool->n_pages_written = 0;
	buf_pool->n_pages_created = 0;
unknown's avatar
unknown committed
661 662
	buf_pool->n_pages_awe_remapped = 0;
	
663 664 665
	buf_pool->n_page_gets = 0;
	buf_pool->n_page_gets_old = 0;
	buf_pool->n_pages_read_old = 0;
666 667
	buf_pool->n_pages_written_old = 0;
	buf_pool->n_pages_created_old = 0;
unknown's avatar
unknown committed
668
	buf_pool->n_pages_awe_remapped_old = 0;
669
	
670 671 672 673 674 675
	/* 2. Initialize flushing fields
	   ---------------------------- */
	UT_LIST_INIT(buf_pool->flush_list);

	for (i = BUF_FLUSH_LRU; i <= BUF_FLUSH_LIST; i++) {
		buf_pool->n_flush[i] = 0;
676
		buf_pool->init_flush[i] = FALSE;
677 678 679 680 681 682 683 684 685 686 687 688 689 690
		buf_pool->no_flush[i] = os_event_create(NULL);
	}

	buf_pool->LRU_flush_ended = 0;

	buf_pool->ulint_clock = 1;
	buf_pool->freed_page_clock = 0;
	
	/* 3. Initialize LRU fields
	   ---------------------------- */
	UT_LIST_INIT(buf_pool->LRU);

	buf_pool->LRU_old = NULL;

unknown's avatar
unknown committed
691 692
	UT_LIST_INIT(buf_pool->awe_LRU_free_mapped);

693 694
	/* Add control blocks to the free list */
	UT_LIST_INIT(buf_pool->free);
unknown's avatar
unknown committed
695

696 697 698
	for (i = 0; i < curr_size; i++) {

		block = buf_pool_get_nth_block(buf_pool, i);
699

unknown's avatar
unknown committed
700 701 702 703
		if (block->frame) {
			/* Wipe contents of frame to eliminate a Purify
			warning */

unknown's avatar
unknown committed
704
#ifdef HAVE_purify
unknown's avatar
unknown committed
705
			memset(block->frame, '\0', UNIV_PAGE_SIZE);
unknown's avatar
unknown committed
706
#endif
unknown's avatar
unknown committed
707 708 709 710 711 712 713 714
			if (srv_use_awe) {
				/* Add to the list of blocks mapped to
				frames */
				
				UT_LIST_ADD_LAST(awe_LRU_free_mapped,
					buf_pool->awe_LRU_free_mapped, block);
			}
		}
715

unknown's avatar
unknown committed
716
		UT_LIST_ADD_LAST(free, buf_pool->free, block);
unknown's avatar
unknown committed
717
		block->in_free_list = TRUE;
718 719 720 721
	}

	mutex_exit(&(buf_pool->mutex));

unknown's avatar
unknown committed
722 723 724 725 726 727 728
	if (srv_use_adaptive_hash_indexes) {
	  	btr_search_sys_create(
			  curr_size * UNIV_PAGE_SIZE / sizeof(void*) / 64);
	} else {
	        /* Create only a small dummy system */
	        btr_search_sys_create(1000);
	}
729 730 731 732 733

	return(buf_pool);
}	

/************************************************************************
unknown's avatar
unknown committed
734 735
Maps the page of block to a frame, if not mapped yet. Unmaps some page
from the end of the awe_LRU_free_mapped. */
736 737

void
unknown's avatar
unknown committed
738 739 740 741 742 743 744 745
buf_awe_map_page_to_frame(
/*======================*/
	buf_block_t*	block,		/* in: block whose page should be
					mapped to a frame */
	ibool		add_to_mapped_list) /* in: TRUE if we in the case
					we need to map the page should also
					add the block to the
					awe_LRU_free_mapped list */
746
{
unknown's avatar
unknown committed
747 748
	buf_block_t*	bck;

unknown's avatar
unknown committed
749
#ifdef UNIV_SYNC_DEBUG
unknown's avatar
unknown committed
750
	ut_ad(mutex_own(&(buf_pool->mutex)));
unknown's avatar
unknown committed
751
#endif /* UNIV_SYNC_DEBUG */
unknown's avatar
unknown committed
752 753 754 755 756 757 758 759 760 761 762
	ut_ad(block);

	if (block->frame) {

		return;
	}

	/* Scan awe_LRU_free_mapped from the end and try to find a block
	which is not bufferfixed or io-fixed */

	bck = UT_LIST_GET_LAST(buf_pool->awe_LRU_free_mapped);
763

unknown's avatar
unknown committed
764
	while (bck) {	
765 766 767 768 769 770 771 772 773
		ibool skip;

		mutex_enter(&bck->mutex);

		skip = (bck->state == BUF_BLOCK_FILE_PAGE
			&& (bck->buf_fix_count != 0 || bck->io_fix != 0));

		if (skip) {
			mutex_exit(&bck->mutex);
unknown's avatar
unknown committed
774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805

			/* We have to skip this */
			bck = UT_LIST_GET_PREV(awe_LRU_free_mapped, bck);
		} else {
			/* We can map block to the frame of bck */

			os_awe_map_physical_mem_to_window(
				bck->frame,
				UNIV_PAGE_SIZE / OS_AWE_X86_PAGE_SIZE,
				block->awe_info);

			block->frame = bck->frame;

			*(buf_pool->blocks_of_frames
				+ (((ulint)(block->frame
						- buf_pool->frame_zero))
						>> UNIV_PAGE_SIZE_SHIFT))
				= block;
			
			bck->frame = NULL;
			UT_LIST_REMOVE(awe_LRU_free_mapped,
					buf_pool->awe_LRU_free_mapped,
					bck);

			if (add_to_mapped_list) {
				UT_LIST_ADD_FIRST(awe_LRU_free_mapped,
					buf_pool->awe_LRU_free_mapped,
					block);
			}

			buf_pool->n_pages_awe_remapped++;
			
806 807
			mutex_exit(&bck->mutex);

unknown's avatar
unknown committed
808 809 810 811 812 813 814
			return;
		}
	}

	fprintf(stderr,
"InnoDB: AWE: Fatal error: cannot find a page to unmap\n"
"InnoDB: awe_LRU_free_mapped list length %lu\n",
815
		(ulong) UT_LIST_GET_LEN(buf_pool->awe_LRU_free_mapped));
816

unknown's avatar
unknown committed
817
	ut_a(0);
818 819 820 821 822 823 824 825
}

/************************************************************************
Allocates a buffer block. */
UNIV_INLINE
buf_block_t*
buf_block_alloc(void)
/*=================*/
unknown's avatar
unknown committed
826 827 828
				/* out, own: the allocated block; also if AWE
				is used it is guaranteed that the page is
				mapped to a frame */
829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845
{
	buf_block_t*	block;

	block = buf_LRU_get_free_block();

	return(block);
}

/************************************************************************
Moves to the block to the start of the LRU list if there is a danger
that the block would drift out of the buffer pool. */
UNIV_INLINE
void
buf_block_make_young(
/*=================*/
	buf_block_t*	block)	/* in: block to make younger */
{
846 847 848 849 850 851 852
#ifdef UNIV_SYNC_DEBUG
	ut_ad(!mutex_own(&(buf_pool->mutex)));
#endif /* UNIV_SYNC_DEBUG */

	/* Note that we read freed_page_clock's without holding any mutex:
	this is allowed since the result is used only in heuristics */

853
	if (buf_pool->freed_page_clock >= block->freed_page_clock 
854
				+ 1 + (buf_pool->curr_size / 4)) {
855

856
		mutex_enter(&buf_pool->mutex);
857 858 859 860
		/* There has been freeing activity in the LRU list:
		best to move to the head of the LRU list */

		buf_LRU_make_block_young(block);
861
		mutex_exit(&buf_pool->mutex);
862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880
	}
}

/************************************************************************
Moves a page to the start of the buffer pool LRU list. This high-level
function can be used to prevent an important page from from slipping out of
the buffer pool. */

void
buf_page_make_young(
/*=================*/
	buf_frame_t*	frame)	/* in: buffer frame of a file page */
{
	buf_block_t*	block;
	
	mutex_enter(&(buf_pool->mutex));

	block = buf_block_align(frame);

unknown's avatar
unknown committed
881
	ut_a(block->state == BUF_BLOCK_FILE_PAGE);
882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897

	buf_LRU_make_block_young(block);

	mutex_exit(&(buf_pool->mutex));
}

/************************************************************************
Frees a buffer block which does not contain a file page. */
UNIV_INLINE
void
buf_block_free(
/*===========*/
	buf_block_t*	block)	/* in, own: block to be freed */
{
	mutex_enter(&(buf_pool->mutex));

898 899 900 901
	mutex_enter(&block->mutex);

	ut_a(block->state != BUF_BLOCK_FILE_PAGE);

902 903
	buf_LRU_block_free_non_file_page(block);

904 905
	mutex_exit(&block->mutex);

906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955
	mutex_exit(&(buf_pool->mutex));
}

/*************************************************************************
Allocates a buffer frame. */

buf_frame_t*
buf_frame_alloc(void)
/*=================*/
				/* out: buffer frame */
{
	return(buf_block_alloc()->frame);
}

/*************************************************************************
Frees a buffer frame which does not contain a file page. */

void
buf_frame_free(
/*===========*/
	buf_frame_t*	frame)	/* in: buffer frame */
{
	buf_block_free(buf_block_align(frame));
}
	
/************************************************************************
Returns the buffer control block if the page can be found in the buffer
pool. NOTE that it is possible that the page is not yet read
from disk, though. This is a very low-level function: use with care! */

buf_block_t*
buf_page_peek_block(
/*================*/
			/* out: control block if found from page hash table,
			otherwise NULL; NOTE that the page is not necessarily
			yet read from disk! */
	ulint	space,	/* in: space id */
	ulint	offset)	/* in: page number */
{
	buf_block_t*	block;

	mutex_enter_fast(&(buf_pool->mutex));

	block = buf_page_hash_get(space, offset);

	mutex_exit(&(buf_pool->mutex));

	return(block);
}

unknown's avatar
unknown committed
956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978
/************************************************************************
Resets the check_index_page_at_flush field of a page if found in the buffer
pool. */

void
buf_reset_check_index_page_at_flush(
/*================================*/
	ulint	space,	/* in: space id */
	ulint	offset)	/* in: page number */
{
	buf_block_t*	block;

	mutex_enter_fast(&(buf_pool->mutex));

	block = buf_page_hash_get(space, offset);

	if (block) {
		block->check_index_page_at_flush = FALSE;
	}
	
	mutex_exit(&(buf_pool->mutex));
}

979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
/************************************************************************
Returns the current state of is_hashed of a page. FALSE if the page is
not in the pool. NOTE that this operation does not fix the page in the
pool if it is found there. */

ibool
buf_page_peek_if_search_hashed(
/*===========================*/
			/* out: TRUE if page hash index is built in search
			system */
	ulint	space,	/* in: space id */
	ulint	offset)	/* in: page number */
{
	buf_block_t*	block;
	ibool		is_hashed;

	mutex_enter_fast(&(buf_pool->mutex));

	block = buf_page_hash_get(space, offset);

	if (!block) {
		is_hashed = FALSE;
	} else {
		is_hashed = block->is_hashed;
	}

	mutex_exit(&(buf_pool->mutex));

	return(is_hashed);
}

/************************************************************************
Returns TRUE if the page can be found in the buffer pool hash table. NOTE
that it is possible that the page is not yet read from disk, though. */

ibool
buf_page_peek(
/*==========*/
			/* out: TRUE if found from page hash table,
			NOTE that the page is not necessarily yet read
			from disk! */
	ulint	space,	/* in: space id */
	ulint	offset)	/* in: page number */
{
	if (buf_page_peek_block(space, offset)) {

		return(TRUE);
	}

	return(FALSE);
}

unknown's avatar
unknown committed
1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088
/************************************************************************
Sets file_page_was_freed TRUE if the page is found in the buffer pool.
This function should be called when we free a file page and want the
debug version to check that it is not accessed any more unless
reallocated. */

buf_block_t*
buf_page_set_file_page_was_freed(
/*=============================*/
			/* out: control block if found from page hash table,
			otherwise NULL */
	ulint	space,	/* in: space id */
	ulint	offset)	/* in: page number */
{
	buf_block_t*	block;

	mutex_enter_fast(&(buf_pool->mutex));

	block = buf_page_hash_get(space, offset);

	if (block) {
		block->file_page_was_freed = TRUE;
	}

	mutex_exit(&(buf_pool->mutex));

	return(block);
}

/************************************************************************
Sets file_page_was_freed FALSE if the page is found in the buffer pool.
This function should be called when we free a file page and want the
debug version to check that it is not accessed any more unless
reallocated. */

buf_block_t*
buf_page_reset_file_page_was_freed(
/*===============================*/
			/* out: control block if found from page hash table,
			otherwise NULL */
	ulint	space,	/* in: space id */
	ulint	offset)	/* in: page number */
{
	buf_block_t*	block;

	mutex_enter_fast(&(buf_pool->mutex));

	block = buf_page_hash_get(space, offset);

	if (block) {
		block->file_page_was_freed = FALSE;
	}

	mutex_exit(&(buf_pool->mutex));

	return(block);
}

1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
/************************************************************************
This is the general function used to get access to a database page. */

buf_frame_t*
buf_page_get_gen(
/*=============*/
				/* out: pointer to the frame or NULL */
	ulint		space,	/* in: space id */
	ulint		offset,	/* in: page number */
	ulint		rw_latch,/* in: RW_S_LATCH, RW_X_LATCH, RW_NO_LATCH */
	buf_frame_t*	guess,	/* in: guessed frame or NULL */
	ulint		mode,	/* in: BUF_GET, BUF_GET_IF_IN_POOL,
				BUF_GET_NO_LATCH, BUF_GET_NOWAIT */
1102
	const char*	file,	/* in: file name */
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
	ulint		line,	/* in: line where called */
	mtr_t*		mtr)	/* in: mini-transaction */
{
	buf_block_t*	block;
	ibool		accessed;
	ulint		fix_type;
	ibool		success;
	ibool		must_read;
	
	ut_ad(mtr);
	ut_ad((rw_latch == RW_S_LATCH)
	      || (rw_latch == RW_X_LATCH)
	      || (rw_latch == RW_NO_LATCH));
	ut_ad((mode != BUF_GET_NO_LATCH) || (rw_latch == RW_NO_LATCH));
	ut_ad((mode == BUF_GET) || (mode == BUF_GET_IF_IN_POOL)
	      || (mode == BUF_GET_NO_LATCH) || (mode == BUF_GET_NOWAIT));
#ifndef UNIV_LOG_DEBUG
	ut_ad(!ibuf_inside() || ibuf_page(space, offset));
#endif
1122
	buf_pool->n_page_gets++;
1123 1124
loop:
	block = NULL;
1125
	mutex_enter_fast(&(buf_pool->mutex));
1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152
	
	if (guess) {
		block = buf_block_align(guess);

		if ((offset != block->offset) || (space != block->space)
				|| (block->state != BUF_BLOCK_FILE_PAGE)) {

			block = NULL;
		}
	}

	if (block == NULL) {
		block = buf_page_hash_get(space, offset);
	}

	if (block == NULL) {
		/* Page not in buf_pool: needs to be read from file */

		mutex_exit(&(buf_pool->mutex));

		if (mode == BUF_GET_IF_IN_POOL) {

			return(NULL);
		}

		buf_read_page(space, offset);

unknown's avatar
unknown committed
1153
#ifdef UNIV_DEBUG
1154 1155 1156 1157 1158
		buf_dbg_counter++;

		if (buf_dbg_counter % 37 == 0) {
			ut_ad(buf_validate());
		}
unknown's avatar
unknown committed
1159
#endif
1160 1161 1162
		goto loop;
	}

1163 1164
	mutex_enter(&block->mutex);

unknown's avatar
unknown committed
1165 1166
	ut_a(block->state == BUF_BLOCK_FILE_PAGE);

1167 1168 1169 1170 1171 1172 1173 1174
	must_read = FALSE;
	
	if (block->io_fix == BUF_IO_READ) {

		must_read = TRUE;

		if (mode == BUF_GET_IF_IN_POOL) {
			/* The page is only being read to buffer */
1175 1176
			mutex_exit(&buf_pool->mutex);
			mutex_exit(&block->mutex);
1177 1178 1179 1180 1181

			return(NULL);
		}
	}		

unknown's avatar
unknown committed
1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194
	/* If AWE is enabled and the page is not mapped to a frame, then
	map it */

	if (block->frame == NULL) {
		ut_a(srv_use_awe);

		/* We set second parameter TRUE because the block is in the
		LRU list and we must put it to awe_LRU_free_mapped list once
		mapped to a frame */
		
		buf_awe_map_page_to_frame(block, TRUE);
	}
	
1195 1196 1197 1198 1199
#ifdef UNIV_SYNC_DEBUG
	buf_block_buf_fix_inc_debug(block, file, line);
#else
	buf_block_buf_fix_inc(block);
#endif
1200
	mutex_exit(&buf_pool->mutex);
1201 1202 1203 1204 1205 1206 1207

	/* Check if this is the first access to the page */

	accessed = block->accessed;

	block->accessed = TRUE;

1208 1209 1210 1211
	mutex_exit(&block->mutex);

	buf_block_make_young(block);

unknown's avatar
unknown committed
1212 1213 1214
#ifdef UNIV_DEBUG_FILE_ACCESSES
	ut_a(block->file_page_was_freed == FALSE);
#endif	
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227

#ifdef UNIV_DEBUG
	buf_dbg_counter++;

	if (buf_dbg_counter % 5771 == 0) {
		ut_ad(buf_validate());
	}
#endif
	ut_ad(block->buf_fix_count > 0);
	ut_ad(block->state == BUF_BLOCK_FILE_PAGE);

	if (mode == BUF_GET_NOWAIT) {
		if (rw_latch == RW_S_LATCH) {
1228 1229
			success = rw_lock_s_lock_func_nowait(&(block->lock),
								file, line);
1230 1231 1232
			fix_type = MTR_MEMO_PAGE_S_FIX;
		} else {
			ut_ad(rw_latch == RW_X_LATCH);
1233 1234
			success = rw_lock_x_lock_func_nowait(&(block->lock),
					file, line);
1235 1236 1237 1238
			fix_type = MTR_MEMO_PAGE_X_FIX;
		}

		if (!success) {
1239
			mutex_enter(&block->mutex);
1240 1241

			block->buf_fix_count--;
1242 1243

			mutex_exit(&block->mutex);
1244 1245 1246 1247 1248 1249 1250 1251 1252
#ifdef UNIV_SYNC_DEBUG
			rw_lock_s_unlock(&(block->debug_latch));
#endif			

			return(NULL);
		}
	} else if (rw_latch == RW_NO_LATCH) {

		if (must_read) {
1253 1254 1255 1256
		        /* Let us wait until the read operation
			completes */

		        for (;;) {
1257
				mutex_enter(&block->mutex);
1258 1259 1260

		                if (block->io_fix == BUF_IO_READ) {

1261
					mutex_exit(&block->mutex);
1262
				  
1263
					os_thread_sleep(WAIT_FOR_READ);
1264 1265
				} else {
				  
1266
					mutex_exit(&block->mutex);
1267 1268 1269 1270

				       break;
				}
			}
1271 1272 1273 1274 1275
		}

		fix_type = MTR_MEMO_BUF_FIX;
	} else if (rw_latch == RW_S_LATCH) {

1276 1277
		rw_lock_s_lock_func(&(block->lock), 0, file, line);

1278 1279
		fix_type = MTR_MEMO_PAGE_S_FIX;
	} else {
1280 1281
		rw_lock_x_lock_func(&(block->lock), 0, file, line);

1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
		fix_type = MTR_MEMO_PAGE_X_FIX;
	}

	mtr_memo_push(mtr, block, fix_type);

	if (!accessed) {
		/* In the case of a first access, try to apply linear
		read-ahead */

		buf_read_ahead_linear(space, offset);
	}

#ifdef UNIV_IBUF_DEBUG
	ut_a(ibuf_count_get(block->space, block->offset) == 0);
#endif
	return(block->frame);		
}

/************************************************************************
This is the general function used to get optimistic access to a database
page. */

ibool
buf_page_optimistic_get_func(
/*=========================*/
				/* out: TRUE if success */
	ulint		rw_latch,/* in: RW_S_LATCH, RW_X_LATCH */
unknown's avatar
unknown committed
1309 1310 1311
	buf_block_t*	block,	/* in: guessed buffer block */
	buf_frame_t*	guess,	/* in: guessed frame; note that AWE may move
				frames */
1312 1313
	dulint		modify_clock,/* in: modify clock value if mode is
				..._GUESS_ON_CLOCK */
1314
	const char*	file,	/* in: file name */
1315 1316 1317 1318 1319 1320 1321
	ulint		line,	/* in: line where called */
	mtr_t*		mtr)	/* in: mini-transaction */
{
	ibool		accessed;
	ibool		success;
	ulint		fix_type;

unknown's avatar
unknown committed
1322
	ut_ad(mtr && block);
1323 1324
	ut_ad((rw_latch == RW_S_LATCH) || (rw_latch == RW_X_LATCH));

unknown's avatar
unknown committed
1325
	/* If AWE is used, block may have a different frame now, e.g., NULL */
1326 1327 1328

	mutex_enter(&block->mutex);

unknown's avatar
unknown committed
1329
	if (UNIV_UNLIKELY(block->state != BUF_BLOCK_FILE_PAGE)
1330 1331 1332
	    || UNIV_UNLIKELY(block->frame != guess)) {

		mutex_exit(&block->mutex);
1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344

		return(FALSE);
	}

#ifdef UNIV_SYNC_DEBUG
	buf_block_buf_fix_inc_debug(block, file, line);
#else
	buf_block_buf_fix_inc(block);
#endif
	accessed = block->accessed;
	block->accessed = TRUE;

1345 1346 1347 1348 1349
	mutex_exit(&block->mutex);

	buf_block_make_young(block);

	/* Check if this is the first access to the page */
1350 1351 1352 1353

	ut_ad(!ibuf_inside() || ibuf_page(block->space, block->offset));

	if (rw_latch == RW_S_LATCH) {
1354 1355
		success = rw_lock_s_lock_func_nowait(&(block->lock),
								file, line);
1356 1357
		fix_type = MTR_MEMO_PAGE_S_FIX;
	} else {
1358 1359
		success = rw_lock_x_lock_func_nowait(&(block->lock),
								file, line);
1360 1361 1362
		fix_type = MTR_MEMO_PAGE_X_FIX;
	}

unknown's avatar
unknown committed
1363
	if (UNIV_UNLIKELY(!success)) {
1364
		mutex_enter(&block->mutex);
1365 1366
		
		block->buf_fix_count--;
1367 1368 1369

		mutex_exit(&block->mutex);

1370 1371
#ifdef UNIV_SYNC_DEBUG
		rw_lock_s_unlock(&(block->debug_latch));
unknown's avatar
unknown committed
1372
#endif
1373
		return(FALSE);
1374 1375
	}

unknown's avatar
unknown committed
1376
	if (UNIV_UNLIKELY(!UT_DULINT_EQ(modify_clock, block->modify_clock))) {
1377
#ifdef UNIV_SYNC_DEBUG
1378
		buf_page_dbg_add_level(block->frame, SYNC_NO_ORDER_CHECK);
1379
#endif /* UNIV_SYNC_DEBUG */
1380 1381 1382 1383 1384 1385
		if (rw_latch == RW_S_LATCH) {
			rw_lock_s_unlock(&(block->lock));
		} else {
			rw_lock_x_unlock(&(block->lock));
		}

1386
		mutex_enter(&block->mutex);
1387 1388
		
		block->buf_fix_count--;
1389 1390 1391

		mutex_exit(&block->mutex);

1392 1393
#ifdef UNIV_SYNC_DEBUG
		rw_lock_s_unlock(&(block->debug_latch));
unknown's avatar
unknown committed
1394
#endif
1395
		return(FALSE);
1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409
	}

	mtr_memo_push(mtr, block, fix_type);

#ifdef UNIV_DEBUG
	buf_dbg_counter++;

	if (buf_dbg_counter % 5771 == 0) {
		ut_ad(buf_validate());
	}
#endif
	ut_ad(block->buf_fix_count > 0);
	ut_ad(block->state == BUF_BLOCK_FILE_PAGE);

unknown's avatar
unknown committed
1410 1411 1412
#ifdef UNIV_DEBUG_FILE_ACCESSES
	ut_a(block->file_page_was_freed == FALSE);
#endif
unknown's avatar
unknown committed
1413
	if (UNIV_UNLIKELY(!accessed)) {
1414 1415 1416 1417 1418 1419 1420 1421 1422 1423
		/* In the case of a first access, try to apply linear
		read-ahead */

		buf_read_ahead_linear(buf_frame_get_space_id(guess),
					buf_frame_get_page_no(guess));
	}

#ifdef UNIV_IBUF_DEBUG
	ut_a(ibuf_count_get(block->space, block->offset) == 0);
#endif
unknown's avatar
unknown committed
1424 1425
	buf_pool->n_page_gets++;

1426 1427 1428 1429 1430
	return(TRUE);
}

/************************************************************************
This is used to get access to a known database page, when no waiting can be
unknown's avatar
unknown committed
1431 1432
done. For example, if a search in an adaptive hash index leads us to this
frame. */
1433 1434 1435 1436 1437 1438 1439 1440

ibool
buf_page_get_known_nowait(
/*======================*/
				/* out: TRUE if success */
	ulint		rw_latch,/* in: RW_S_LATCH, RW_X_LATCH */
	buf_frame_t*	guess,	/* in: the known page frame */
	ulint		mode,	/* in: BUF_MAKE_YOUNG or BUF_KEEP_OLD */
1441
	const char*	file,	/* in: file name */
1442 1443 1444 1445 1446 1447 1448 1449 1450 1451
	ulint		line,	/* in: line where called */
	mtr_t*		mtr)	/* in: mini-transaction */
{
	buf_block_t*	block;
	ibool		success;
	ulint		fix_type;

	ut_ad(mtr);
	ut_ad((rw_latch == RW_S_LATCH) || (rw_latch == RW_X_LATCH));
	
unknown's avatar
unknown committed
1452 1453
	block = buf_block_align(guess);

1454 1455
	mutex_enter(&block->mutex);

1456 1457 1458 1459 1460 1461 1462 1463
	if (block->state == BUF_BLOCK_REMOVE_HASH) {
	        /* Another thread is just freeing the block from the LRU list
	        of the buffer pool: do not try to access this page; this
		attempt to access the page can only come through the hash
		index because when the buffer block state is ..._REMOVE_HASH,
		we have already removed it from the page address hash table
		of the buffer pool. */

1464
		mutex_exit(&block->mutex);
1465 1466 1467 1468

		return(FALSE);
	}

unknown's avatar
unknown committed
1469 1470
	ut_a(block->state == BUF_BLOCK_FILE_PAGE);

1471 1472 1473 1474 1475
#ifdef UNIV_SYNC_DEBUG
	buf_block_buf_fix_inc_debug(block, file, line);
#else
	buf_block_buf_fix_inc(block);
#endif
1476 1477
	mutex_exit(&block->mutex);

1478 1479 1480 1481 1482 1483 1484
	if (mode == BUF_MAKE_YOUNG) {
		buf_block_make_young(block);
	}

	ut_ad(!ibuf_inside() || (mode == BUF_KEEP_OLD));

	if (rw_latch == RW_S_LATCH) {
1485 1486
		success = rw_lock_s_lock_func_nowait(&(block->lock),
								file, line);
1487 1488
		fix_type = MTR_MEMO_PAGE_S_FIX;
	} else {
1489 1490
		success = rw_lock_x_lock_func_nowait(&(block->lock),
								file, line);
1491 1492 1493 1494
		fix_type = MTR_MEMO_PAGE_X_FIX;
	}
	
	if (!success) {
1495
		mutex_enter(&block->mutex);
1496 1497
		
		block->buf_fix_count--;
1498 1499 1500

		mutex_exit(&block->mutex);

1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518
#ifdef UNIV_SYNC_DEBUG
		rw_lock_s_unlock(&(block->debug_latch));
#endif		

		return(FALSE);
	}

	mtr_memo_push(mtr, block, fix_type);

#ifdef UNIV_DEBUG
	buf_dbg_counter++;

	if (buf_dbg_counter % 5771 == 0) {
		ut_ad(buf_validate());
	}
#endif
	ut_ad(block->buf_fix_count > 0);
	ut_ad(block->state == BUF_BLOCK_FILE_PAGE);
unknown's avatar
unknown committed
1519 1520 1521
#ifdef UNIV_DEBUG_FILE_ACCESSES
	ut_a(block->file_page_was_freed == FALSE);
#endif
1522 1523 1524 1525 1526

#ifdef UNIV_IBUF_DEBUG
	ut_a((mode == BUF_KEEP_OLD)
		|| (ibuf_count_get(block->space, block->offset) == 0));
#endif
unknown's avatar
unknown committed
1527 1528
	buf_pool->n_page_gets++;

1529 1530 1531
	return(TRUE);
}

unknown's avatar
unknown committed
1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550
/************************************************************************
Inits a page to the buffer buf_pool, for use in ibbackup --restore. */

void
buf_page_init_for_backup_restore(
/*=============================*/
	ulint		space,	/* in: space id */
	ulint		offset,	/* in: offset of the page within space
				in units of a page */
	buf_block_t*	block)	/* in: block to init */
{
	/* Set the state of the block */
	block->magic_n		= BUF_BLOCK_MAGIC_N;

	block->state 		= BUF_BLOCK_FILE_PAGE;
	block->space 		= space;
	block->offset 		= offset;

	block->lock_hash_val	= 0;
1551

unknown's avatar
unknown committed
1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569
	block->freed_page_clock = 0;

	block->newest_modification = ut_dulint_zero;
	block->oldest_modification = ut_dulint_zero;
	
	block->accessed		= FALSE;
	block->buf_fix_count 	= 0;
	block->io_fix		= 0;

	block->n_hash_helps	= 0;
	block->is_hashed	= FALSE;
	block->n_fields         = 1;
	block->n_bytes          = 0;
	block->side             = BTR_SEARCH_LEFT_SIDE;

	block->file_page_was_freed = FALSE;
}

1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580
/************************************************************************
Inits a page to the buffer buf_pool. */
static
void
buf_page_init(
/*==========*/
	ulint		space,	/* in: space id */
	ulint		offset,	/* in: offset of the page within space
				in units of a page */
	buf_block_t*	block)	/* in: block to init */
{
1581
#ifdef UNIV_SYNC_DEBUG
1582
	ut_ad(mutex_own(&(buf_pool->mutex)));
1583
	ut_ad(mutex_own(&(block->mutex)));
1584
#endif /* UNIV_SYNC_DEBUG */
unknown's avatar
unknown committed
1585
	ut_a(block->state != BUF_BLOCK_FILE_PAGE);
1586 1587

	/* Set the state of the block */
unknown's avatar
unknown committed
1588 1589
	block->magic_n		= BUF_BLOCK_MAGIC_N;

1590 1591 1592 1593
	block->state 		= BUF_BLOCK_FILE_PAGE;
	block->space 		= space;
	block->offset 		= offset;

unknown's avatar
unknown committed
1594
	block->check_index_page_at_flush = FALSE;
unknown's avatar
unknown committed
1595
	block->index		= NULL;
unknown's avatar
unknown committed
1596
	
1597
	block->lock_hash_val	= lock_rec_hash(space, offset);
1598

1599 1600
	/* Insert into the hash table of file pages */

unknown's avatar
unknown committed
1601 1602
        if (buf_page_hash_get(space, offset)) {
                fprintf(stderr,
1603 1604 1605
"InnoDB: Error: page %lu %lu already found from the hash table\n",
			(ulong) space,
			(ulong) offset);
unknown's avatar
unknown committed
1606
#ifdef UNIV_DEBUG
unknown's avatar
unknown committed
1607 1608 1609 1610
                buf_print();
                buf_LRU_print();
                buf_validate();
                buf_LRU_validate();
unknown's avatar
unknown committed
1611
#endif /* UNIV_DEBUG */
unknown's avatar
unknown committed
1612 1613 1614
                ut_a(0);
        }

1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628
	HASH_INSERT(buf_block_t, hash, buf_pool->page_hash,
				buf_page_address_fold(space, offset), block);

	block->freed_page_clock = 0;

	block->newest_modification = ut_dulint_zero;
	block->oldest_modification = ut_dulint_zero;
	
	block->accessed		= FALSE;
	block->buf_fix_count 	= 0;
	block->io_fix		= 0;

	block->n_hash_helps	= 0;
	block->is_hashed	= FALSE;
unknown's avatar
unknown committed
1629 1630 1631
	block->n_fields         = 1;
	block->n_bytes          = 0;
	block->side             = BTR_SEARCH_LEFT_SIDE;
unknown's avatar
unknown committed
1632 1633

	block->file_page_was_freed = FALSE;
1634 1635 1636 1637
}

/************************************************************************
Function which inits a page for read to the buffer buf_pool. If the page is
unknown's avatar
unknown committed
1638 1639 1640 1641 1642 1643 1644 1645 1646
(1) already in buf_pool, or
(2) if we specify to read only ibuf pages and the page is not an ibuf page, or
(3) if the space is deleted or being deleted,
then this function does nothing.
Sets the io_fix flag to BUF_IO_READ and sets a non-recursive exclusive lock
on the buffer frame. The io-handler must take care that the flag is cleared
and the lock released later. This is one of the functions which perform the
state transition NOT_USED => FILE_PAGE to a block (the other is
buf_page_create). */ 
1647 1648 1649 1650

buf_block_t*
buf_page_init_for_read(
/*===================*/
unknown's avatar
unknown committed
1651 1652 1653 1654 1655 1656 1657 1658
				/* out: pointer to the block or NULL */
	ulint*		err,	/* out: DB_SUCCESS or DB_TABLESPACE_DELETED */
	ulint		mode,	/* in: BUF_READ_IBUF_PAGES_ONLY, ... */
	ulint		space,	/* in: space id */
	ib_longlong	tablespace_version,/* in: prevents reading from a wrong
				version of the tablespace in case we have done
				DISCARD + IMPORT */
	ulint		offset)	/* in: page number */
1659 1660 1661
{
	buf_block_t*	block;
	mtr_t		mtr;
unknown's avatar
unknown committed
1662

1663 1664
	ut_ad(buf_pool);

unknown's avatar
unknown committed
1665 1666
	*err = DB_SUCCESS;

1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686
	if (mode == BUF_READ_IBUF_PAGES_ONLY) {
		/* It is a read-ahead within an ibuf routine */

		ut_ad(!ibuf_bitmap_page(offset));
		ut_ad(ibuf_inside());
	
		mtr_start(&mtr);
	
		if (!ibuf_page_low(space, offset, &mtr)) {

			mtr_commit(&mtr);

			return(NULL);
		}
	} else {
		ut_ad(mode == BUF_READ_ANY_PAGE);
	}
	
	block = buf_block_alloc();

unknown's avatar
unknown committed
1687
	ut_a(block);
1688 1689

	mutex_enter(&(buf_pool->mutex));
1690
	mutex_enter(&block->mutex);
1691

unknown's avatar
unknown committed
1692 1693 1694 1695 1696 1697 1698 1699 1700 1701
	if (fil_tablespace_deleted_or_being_deleted_in_mem(space,
							tablespace_version)) {
		*err = DB_TABLESPACE_DELETED;
	}

	if (*err == DB_TABLESPACE_DELETED
	    || NULL != buf_page_hash_get(space, offset)) {

		/* The page belongs to a space which has been deleted or is
		being deleted, or the page is already in buf_pool, return */
1702

1703
		mutex_exit(&block->mutex);
1704
		mutex_exit(&(buf_pool->mutex));
1705

1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724
		buf_block_free(block);

		if (mode == BUF_READ_IBUF_PAGES_ONLY) {

			mtr_commit(&mtr);
		}

		return(NULL);
	}

	ut_ad(block);
	
	buf_page_init(space, offset, block);

	/* The block must be put to the LRU list, to the old blocks */

	buf_LRU_add_block(block, TRUE); 	/* TRUE == to old blocks */
	
	block->io_fix = BUF_IO_READ;
1725

1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736
	buf_pool->n_pend_reads++;
	
	/* We set a pass-type x-lock on the frame because then the same
	thread which called for the read operation (and is running now at
	this point of code) can wait for the read to complete by waiting
	for the x-lock on the frame; if the x-lock were recursive, the
	same thread would illegally get the x-lock before the page read
	is completed. The x-lock is cleared by the io-handler thread. */
	
	rw_lock_x_lock_gen(&(block->lock), BUF_IO_READ);
	
1737
	mutex_exit(&block->mutex);
1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778
 	mutex_exit(&(buf_pool->mutex));

	if (mode == BUF_READ_IBUF_PAGES_ONLY) {

		mtr_commit(&mtr);
	}

	return(block);
}	

/************************************************************************
Initializes a page to the buffer buf_pool. The page is usually not read
from a file even if it cannot be found in the buffer buf_pool. This is one
of the functions which perform to a block a state transition NOT_USED =>
FILE_PAGE (the other is buf_page_init_for_read above). */

buf_frame_t*
buf_page_create(
/*============*/
			/* out: pointer to the frame, page bufferfixed */
	ulint	space,	/* in: space id */
	ulint	offset,	/* in: offset of the page within space in units of
			a page */
	mtr_t*	mtr)	/* in: mini-transaction handle */
{
	buf_frame_t*	frame;
	buf_block_t*	block;
	buf_block_t*	free_block	= NULL;
	
	ut_ad(mtr);

	free_block = buf_LRU_get_free_block();
	
	mutex_enter(&(buf_pool->mutex));

	block = buf_page_hash_get(space, offset);

	if (block != NULL) {
#ifdef UNIV_IBUF_DEBUG
		ut_a(ibuf_count_get(block->space, block->offset) == 0);
#endif
unknown's avatar
unknown committed
1779 1780
		block->file_page_was_freed = FALSE;

1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792
		/* Page can be found in buf_pool */
		mutex_exit(&(buf_pool->mutex));

		buf_block_free(free_block);

		frame = buf_page_get_with_no_latch(space, offset, mtr);

		return(frame);
	}

	/* If we get here, the page was not in buf_pool: init it there */

1793
#ifdef UNIV_DEBUG
1794
	if (buf_debug_prints) {
1795
		fprintf(stderr, "Creating space %lu page %lu to buffer\n",
unknown's avatar
unknown committed
1796
			(ulong) space, (ulong) offset);
1797
	}
1798
#endif /* UNIV_DEBUG */
1799 1800 1801

	block = free_block;
	
1802 1803
	mutex_enter(&block->mutex);

1804 1805 1806 1807 1808 1809
	buf_page_init(space, offset, block);

	/* The block must be put to the LRU list */
	buf_LRU_add_block(block, FALSE);
		
#ifdef UNIV_SYNC_DEBUG
1810
	buf_block_buf_fix_inc_debug(block, __FILE__, __LINE__);
1811 1812 1813
#else
	buf_block_buf_fix_inc(block);
#endif
1814 1815 1816 1817
	buf_pool->n_pages_created++;

	mutex_exit(&(buf_pool->mutex));

1818 1819 1820 1821
	mtr_memo_push(mtr, block, MTR_MEMO_BUF_FIX);

	block->accessed = TRUE;
	
1822
	mutex_exit(&block->mutex);
1823

unknown's avatar
unknown committed
1824 1825 1826
	/* Delete possible entries for the page from the insert buffer:
	such can exist if the page belonged to an index which was dropped */

unknown's avatar
unknown committed
1827
	ibuf_merge_or_delete_for_page(NULL, space, offset, TRUE);
unknown's avatar
unknown committed
1828

1829 1830 1831 1832
	/* Flush pages from the end of the LRU list if necessary */
	buf_flush_free_margin();

	frame = block->frame;
unknown's avatar
unknown committed
1833 1834 1835 1836 1837 1838 1839 1840 1841

	/* Reset to zero the file flush lsn field in the page; if the first
	page of an ibdata file is 'created' in this function into the buffer
	pool then we lose the original contents of the file flush lsn stamp.
	Then InnoDB could in a crash recovery print a big, false, corruption
	warning if the stamp contains an lsn bigger than the ib_logfile lsn. */

	memset(frame + FIL_PAGE_FILE_FLUSH_LSN, 0, 8);

1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864
#ifdef UNIV_DEBUG
	buf_dbg_counter++;

	if (buf_dbg_counter % 357 == 0) {
		ut_ad(buf_validate());
	}
#endif
#ifdef UNIV_IBUF_DEBUG
	ut_a(ibuf_count_get(block->space, block->offset) == 0);
#endif
	return(frame);
}

/************************************************************************
Completes an asynchronous read or write request of a file page to or from
the buffer pool. */

void
buf_page_io_complete(
/*=================*/
	buf_block_t*	block)	/* in: pointer to the block in question */
{
	ulint		io_type;
unknown's avatar
unknown committed
1865 1866
	ulint		read_page_no;
	
1867 1868
	ut_ad(block);

unknown's avatar
unknown committed
1869 1870
	ut_a(block->state == BUF_BLOCK_FILE_PAGE);

1871 1872 1873 1874 1875 1876
	/* We do not need protect block->io_fix here by block->mutex to read
	it because this is the only function where we can change the value
	from BUF_IO_READ or BUF_IO_WRITE to some other value, and our code
	ensures that this is the only thread that handles the i/o for this
	block. */

1877 1878 1879
	io_type = block->io_fix;

	if (io_type == BUF_IO_READ) {
unknown's avatar
unknown committed
1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891
		/* If this page is not uninitialized and not in the
		doublewrite buffer, then the page number should be the
		same as in block */

		read_page_no = mach_read_from_4((block->frame)
						+ FIL_PAGE_OFFSET);
		if (read_page_no != 0
			&& !trx_doublewrite_page_inside(read_page_no)
	    		&& read_page_no != block->offset) {

			fprintf(stderr,
"InnoDB: Error: page n:o stored in the page read in is %lu, should be %lu!\n",
1892
				(ulong) read_page_no, (ulong) block->offset);
unknown's avatar
unknown committed
1893
		}
1894
		/* From version 3.23.38 up we store the page checksum
unknown's avatar
unknown committed
1895
		   to the 4 first bytes of the page end lsn field */
1896

1897 1898
		if (buf_page_is_corrupted(block->frame)) {
		  	fprintf(stderr,
unknown's avatar
unknown committed
1899
		"InnoDB: Database page corruption on disk or a failed\n"
1900
		"InnoDB: file read of page %lu.\n", (ulong) block->offset);
1901
			  
1902 1903
			fputs(
		"InnoDB: You may have to recover from a backup.\n", stderr);
1904 1905 1906 1907

			buf_page_print(block->frame);

		  	fprintf(stderr,
unknown's avatar
unknown committed
1908
		"InnoDB: Database page corruption on disk or a failed\n"
1909
		"InnoDB: file read of page %lu.\n", (ulong) block->offset);
1910 1911 1912
			fputs(
		"InnoDB: You may have to recover from a backup.\n", stderr);
			fputs(
unknown's avatar
unknown committed
1913 1914 1915 1916 1917 1918 1919 1920 1921
		"InnoDB: It is also possible that your operating\n"
		"InnoDB: system has corrupted its own file cache\n"
		"InnoDB: and rebooting your computer removes the\n"
		"InnoDB: error.\n"
		"InnoDB: If the corrupt page is an index page\n"
		"InnoDB: you can also try to fix the corruption\n"
		"InnoDB: by dumping, dropping, and reimporting\n"
		"InnoDB: the corrupt table. You can use CHECK\n"
		"InnoDB: TABLE to scan your table for corruption.\n"
1922
		"InnoDB: See also "
unknown's avatar
unknown committed
1923
"InnoDB: http://dev.mysql.com/doc/refman/5.0/en/forcing-recovery.html\n"
1924
		"InnoDB: about forcing recovery.\n", stderr);
1925
			  
unknown's avatar
unknown committed
1926
			if (srv_force_recovery < SRV_FORCE_IGNORE_CORRUPT) {
1927 1928 1929
				fputs(
	"InnoDB: Ending processing because of a corrupt database page.\n",
					stderr);
1930 1931
		  		exit(1);
		  	}
1932 1933
		}

1934
		if (recv_recovery_is_on()) {
unknown's avatar
unknown committed
1935 1936
			recv_recover_page(FALSE, TRUE, block->frame,
						block->space, block->offset);
1937 1938 1939 1940
		}

		if (!recv_no_ibuf_operations) {
			ibuf_merge_or_delete_for_page(block->frame,
unknown's avatar
unknown committed
1941
					block->space, block->offset, TRUE);
1942 1943 1944
		}
	}
	
1945 1946 1947
	mutex_enter(&(buf_pool->mutex));
	mutex_enter(&block->mutex);

1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968
#ifdef UNIV_IBUF_DEBUG
	ut_a(ibuf_count_get(block->space, block->offset) == 0);
#endif
	/* Because this thread which does the unlocking is not the same that
	did the locking, we use a pass value != 0 in unlock, which simply
	removes the newest lock debug record, without checking the thread
	id. */

	block->io_fix = 0;
	
	if (io_type == BUF_IO_READ) {
		/* NOTE that the call to ibuf may have moved the ownership of
		the x-latch to this OS thread: do not let this confuse you in
		debugging! */		
	
		ut_ad(buf_pool->n_pend_reads > 0);
		buf_pool->n_pend_reads--;
		buf_pool->n_pages_read++;

		rw_lock_x_unlock_gen(&(block->lock), BUF_IO_READ);

1969
#ifdef UNIV_DEBUG
1970
		if (buf_debug_prints) {
1971
			fputs("Has read ", stderr);
1972
		}
1973
#endif /* UNIV_DEBUG */
1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985
	} else {
		ut_ad(io_type == BUF_IO_WRITE);

		/* Write means a flush operation: call the completion
		routine in the flush system */

		buf_flush_write_complete(block);

		rw_lock_s_unlock_gen(&(block->lock), BUF_IO_WRITE);

		buf_pool->n_pages_written++;

1986
#ifdef UNIV_DEBUG
1987
		if (buf_debug_prints) {
1988
			fputs("Has written ", stderr);
1989
		}
1990
#endif /* UNIV_DEBUG */
1991 1992
	}
	
1993
	mutex_exit(&block->mutex);
1994 1995
	mutex_exit(&(buf_pool->mutex));

1996
#ifdef UNIV_DEBUG
1997
	if (buf_debug_prints) {
1998
		fprintf(stderr, "page space %lu page no %lu\n",
unknown's avatar
unknown committed
1999
			(ulong) block->space, (ulong) block->offset);
2000
	}
2001
#endif /* UNIV_DEBUG */
2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019
}

/*************************************************************************
Invalidates the file pages in the buffer pool when an archive recovery is
completed. All the file pages buffered must be in a replaceable state when
this function is called: not latched and not modified. */

void
buf_pool_invalidate(void)
/*=====================*/
{
	ibool	freed;

	ut_ad(buf_all_freed());
	
	freed = TRUE;

	while (freed) {
2020
		freed = buf_LRU_search_and_free_block(100);
2021 2022 2023 2024 2025 2026 2027 2028 2029
	}
	
	mutex_enter(&(buf_pool->mutex));

	ut_ad(UT_LIST_GET_LEN(buf_pool->LRU) == 0);

	mutex_exit(&(buf_pool->mutex));
}

2030
#ifdef UNIV_DEBUG
2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055
/*************************************************************************
Validates the buffer buf_pool data structure. */

ibool
buf_validate(void)
/*==============*/
{
	buf_block_t*	block;
	ulint		i;
	ulint		n_single_flush	= 0;
	ulint		n_lru_flush	= 0;
	ulint		n_list_flush	= 0;
	ulint		n_lru		= 0;
	ulint		n_flush		= 0;
	ulint		n_free		= 0;
	ulint		n_page		= 0;
	
	ut_ad(buf_pool);

	mutex_enter(&(buf_pool->mutex));

	for (i = 0; i < buf_pool->curr_size; i++) {

		block = buf_pool_get_nth_block(buf_pool, i);

2056 2057
		mutex_enter(&block->mutex);

2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100
		if (block->state == BUF_BLOCK_FILE_PAGE) {

			ut_a(buf_page_hash_get(block->space,
						block->offset) == block);
			n_page++;

#ifdef UNIV_IBUF_DEBUG
			ut_a((block->io_fix == BUF_IO_READ)
			     || ibuf_count_get(block->space, block->offset)
								== 0);
#endif
			if (block->io_fix == BUF_IO_WRITE) {

				if (block->flush_type == BUF_FLUSH_LRU) {
					n_lru_flush++;
					ut_a(rw_lock_is_locked(&(block->lock),
							RW_LOCK_SHARED));
				} else if (block->flush_type ==
						BUF_FLUSH_LIST) {
					n_list_flush++;
				} else if (block->flush_type ==
						BUF_FLUSH_SINGLE_PAGE) {
					n_single_flush++;
				} else {
					ut_error;
				}

			} else if (block->io_fix == BUF_IO_READ) {

				ut_a(rw_lock_is_locked(&(block->lock),
							RW_LOCK_EX));
			}
			
			n_lru++;

			if (ut_dulint_cmp(block->oldest_modification,
						ut_dulint_zero) > 0) {
					n_flush++;
			}	
		
		} else if (block->state == BUF_BLOCK_NOT_USED) {
			n_free++;
		}
2101 2102

		mutex_exit(&block->mutex);
2103 2104 2105
 	}

	if (n_lru + n_free > buf_pool->curr_size) {
unknown's avatar
unknown committed
2106
		fprintf(stderr, "n LRU %lu, n free %lu\n", (ulong) n_lru, (ulong) n_free);
2107 2108 2109 2110 2111
		ut_error;
	}

	ut_a(UT_LIST_GET_LEN(buf_pool->LRU) == n_lru);
	if (UT_LIST_GET_LEN(buf_pool->free) != n_free) {
2112
		fprintf(stderr, "Free list len %lu, free blocks %lu\n",
unknown's avatar
unknown committed
2113
			(ulong) UT_LIST_GET_LEN(buf_pool->free), (ulong) n_free);
2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148
		ut_error;
	}
	ut_a(UT_LIST_GET_LEN(buf_pool->flush_list) == n_flush);

	ut_a(buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE] == n_single_flush);
	ut_a(buf_pool->n_flush[BUF_FLUSH_LIST] == n_list_flush);
	ut_a(buf_pool->n_flush[BUF_FLUSH_LRU] == n_lru_flush);
	
	mutex_exit(&(buf_pool->mutex));

	ut_a(buf_LRU_validate());
	ut_a(buf_flush_validate());

	return(TRUE);
}	

/*************************************************************************
Prints info of the buffer buf_pool data structure. */

void
buf_print(void)
/*===========*/
{
	dulint*		index_ids;
	ulint*		counts;
	ulint		size;
	ulint		i;
	ulint		j;
	dulint		id;
	ulint		n_found;
	buf_frame_t* 	frame;
	dict_index_t*	index;
	
	ut_ad(buf_pool);

unknown's avatar
unknown committed
2149
	size = buf_pool->curr_size;
2150 2151 2152 2153 2154 2155

	index_ids = mem_alloc(sizeof(dulint) * size);
	counts = mem_alloc(sizeof(ulint) * size);

	mutex_enter(&(buf_pool->mutex));
	
2156
	fprintf(stderr,
unknown's avatar
unknown committed
2157 2158 2159 2160 2161
		"buf_pool size %lu\n"
		"database pages %lu\n"
		"free pages %lu\n"
		"modified database pages %lu\n"
		"n pending reads %lu\n"
2162 2163
		"n pending flush LRU %lu list %lu single page %lu\n"
		"pages read %lu, created %lu, written %lu\n",
unknown's avatar
unknown committed
2164 2165 2166 2167 2168 2169 2170 2171 2172 2173
		(ulong) size,
		(ulong) UT_LIST_GET_LEN(buf_pool->LRU),
		(ulong) UT_LIST_GET_LEN(buf_pool->free),
		(ulong) UT_LIST_GET_LEN(buf_pool->flush_list),
		(ulong) buf_pool->n_pend_reads,
		(ulong) buf_pool->n_flush[BUF_FLUSH_LRU],
		(ulong) buf_pool->n_flush[BUF_FLUSH_LIST],
		(ulong) buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE],
		(ulong) buf_pool->n_pages_read, buf_pool->n_pages_created,
		(ulong) buf_pool->n_pages_written);
2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211

	/* Count the number of blocks belonging to each index in the buffer */
	
	n_found = 0;

	for (i = 0; i < size; i++) {
		frame = buf_pool_get_nth_block(buf_pool, i)->frame;

		if (fil_page_get_type(frame) == FIL_PAGE_INDEX) {

			id = btr_page_get_index_id(frame);

			/* Look for the id in the index_ids array */
			j = 0;

			while (j < n_found) {

				if (ut_dulint_cmp(index_ids[j], id) == 0) {
					(counts[j])++;

					break;
				}
				j++;
			}

			if (j == n_found) {
				n_found++;
				index_ids[j] = id;
				counts[j] = 1;
			}
		}
	}

	mutex_exit(&(buf_pool->mutex));

	for (i = 0; i < n_found; i++) {
		index = dict_index_get_if_in_cache(index_ids[i]);

2212 2213
		fprintf(stderr,
			"Block count for index %lu in buffer is about %lu",
2214 2215
		       (ulong) ut_dulint_get_low(index_ids[i]),
		       (ulong) counts[i]);
2216 2217

		if (index) {
2218
			putc(' ', stderr);
2219
			dict_index_name_print(stderr, NULL, index);
2220 2221
		}

2222
		putc('\n', stderr);
2223 2224 2225 2226 2227 2228 2229
	}
	
	mem_free(index_ids);
	mem_free(counts);

	ut_a(buf_validate());
}	
2230
#endif /* UNIV_DEBUG */
2231

2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245
/*************************************************************************
Returns the number of latched pages in the buffer pool. */

ulint
buf_get_latched_pages_number(void)
{
        buf_block_t* block;
        ulint i;
        ulint fixed_pages_number = 0;

        mutex_enter(&(buf_pool->mutex));

        for (i = 0; i < buf_pool->curr_size; i++) {

2246 2247 2248 2249
		block = buf_pool_get_nth_block(buf_pool, i);

		if (block->magic_n == BUF_BLOCK_MAGIC_N) {
			mutex_enter(&block->mutex);
2250

2251 2252 2253 2254 2255 2256
			if (block->buf_fix_count != 0 || block->io_fix != 0) {
				fixed_pages_number++;
			}

			mutex_exit(&block->mutex);
		}
2257 2258 2259 2260 2261 2262
        }

        mutex_exit(&(buf_pool->mutex));
        return fixed_pages_number;
}

2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275
/*************************************************************************
Returns the number of pending buf pool ios. */

ulint
buf_get_n_pending_ios(void)
/*=======================*/
{
	return(buf_pool->n_pend_reads
		+ buf_pool->n_flush[BUF_FLUSH_LRU]
		+ buf_pool->n_flush[BUF_FLUSH_LIST]
		+ buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]);
}

2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288
/*************************************************************************
Returns the ratio in percents of modified pages in the buffer pool /
database pages in the buffer pool. */

ulint
buf_get_modified_ratio_pct(void)
/*============================*/
{
	ulint	ratio;

	mutex_enter(&(buf_pool->mutex));

	ratio = (100 * UT_LIST_GET_LEN(buf_pool->flush_list))
unknown's avatar
unknown committed
2289 2290
		     / (1 + UT_LIST_GET_LEN(buf_pool->LRU)
		        + UT_LIST_GET_LEN(buf_pool->free));
2291 2292 2293 2294 2295 2296 2297 2298

		       /* 1 + is there to avoid division by zero */   

	mutex_exit(&(buf_pool->mutex));

	return(ratio);
}

2299 2300 2301 2302
/*************************************************************************
Prints info of the buffer i/o. */

void
unknown's avatar
unknown committed
2303 2304
buf_print_io(
/*=========*/
2305
	FILE*	file)	/* in/out: buffer where to print */
2306
{
2307 2308
	time_t	current_time;
	double	time_elapsed;
2309 2310
	ulint	size;
	
2311
	ut_ad(buf_pool);
unknown's avatar
unknown committed
2312
	size = buf_pool->curr_size;
2313

2314
	mutex_enter(&(buf_pool->mutex));
2315
	
unknown's avatar
unknown committed
2316
	if (srv_use_awe) {
unknown's avatar
unknown committed
2317
		fprintf(stderr,
unknown's avatar
unknown committed
2318
		"AWE: Buffer pool memory frames                        %lu\n",
2319
				(ulong) buf_pool->n_frames);
unknown's avatar
unknown committed
2320
		
unknown's avatar
unknown committed
2321
		fprintf(stderr,
unknown's avatar
unknown committed
2322
		"AWE: Database pages and free buffers mapped in frames %lu\n",
2323
				(ulong) UT_LIST_GET_LEN(buf_pool->awe_LRU_free_mapped));
unknown's avatar
unknown committed
2324
	}
2325 2326 2327 2328 2329
	fprintf(file,
		"Buffer pool size   %lu\n"
		"Free buffers       %lu\n"
		"Database pages     %lu\n"
		"Modified db pages  %lu\n"
unknown's avatar
unknown committed
2330
		"Pending reads %lu\n"
unknown's avatar
unknown committed
2331
		"Pending writes: LRU %lu, flush list %lu, single page %lu\n",
unknown's avatar
unknown committed
2332 2333 2334 2335 2336 2337 2338 2339 2340
		(ulong) size,
		(ulong) UT_LIST_GET_LEN(buf_pool->free),
		(ulong) UT_LIST_GET_LEN(buf_pool->LRU),
		(ulong) UT_LIST_GET_LEN(buf_pool->flush_list),
		(ulong) buf_pool->n_pend_reads,
		(ulong) buf_pool->n_flush[BUF_FLUSH_LRU]
			+ buf_pool->init_flush[BUF_FLUSH_LRU],
		(ulong) buf_pool->n_flush[BUF_FLUSH_LIST]
			+ buf_pool->init_flush[BUF_FLUSH_LIST],
2341
		(ulong) buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]);
2342

2343
	current_time = time(NULL);
unknown's avatar
unknown committed
2344 2345
	time_elapsed = 0.001 + difftime(current_time,
						buf_pool->last_printout_time);
2346 2347
	buf_pool->last_printout_time = current_time;

2348 2349 2350
	fprintf(file,
		"Pages read %lu, created %lu, written %lu\n"
		"%.2f reads/s, %.2f creates/s, %.2f writes/s\n",
unknown's avatar
unknown committed
2351 2352 2353
		(ulong) buf_pool->n_pages_read,
		(ulong) buf_pool->n_pages_created,
		(ulong) buf_pool->n_pages_written,
2354 2355 2356 2357 2358 2359
		(buf_pool->n_pages_read - buf_pool->n_pages_read_old)
		/ time_elapsed,
		(buf_pool->n_pages_created - buf_pool->n_pages_created_old)
		/ time_elapsed,
		(buf_pool->n_pages_written - buf_pool->n_pages_written_old)
		/ time_elapsed);
2360

unknown's avatar
unknown committed
2361
	if (srv_use_awe) {
unknown's avatar
unknown committed
2362
		fprintf(file, "AWE: %.2f page remaps/s\n",
unknown's avatar
unknown committed
2363 2364 2365 2366 2367
		(buf_pool->n_pages_awe_remapped
				- buf_pool->n_pages_awe_remapped_old)
			/ time_elapsed);
	}
		
2368
	if (buf_pool->n_page_gets > buf_pool->n_page_gets_old) {
2369
		fprintf(file, "Buffer pool hit rate %lu / 1000\n",
2370
       (ulong) (1000
2371 2372
		- ((1000 *
		    (buf_pool->n_pages_read - buf_pool->n_pages_read_old))
2373
		/ (buf_pool->n_page_gets - buf_pool->n_page_gets_old))));
2374
	} else {
2375 2376
		fputs("No buffer pool page gets since the last printout\n",
			file);
2377 2378 2379 2380
	}

	buf_pool->n_page_gets_old = buf_pool->n_page_gets;
	buf_pool->n_pages_read_old = buf_pool->n_pages_read;
2381 2382
	buf_pool->n_pages_created_old = buf_pool->n_pages_created;
	buf_pool->n_pages_written_old = buf_pool->n_pages_written;
unknown's avatar
unknown committed
2383
	buf_pool->n_pages_awe_remapped_old = buf_pool->n_pages_awe_remapped;
2384

2385 2386 2387
	mutex_exit(&(buf_pool->mutex));
}

unknown's avatar
unknown committed
2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399
/**************************************************************************
Refreshes the statistics used to print per-second averages. */

void
buf_refresh_io_stats(void)
/*======================*/
{
        buf_pool->last_printout_time = time(NULL);
	buf_pool->n_page_gets_old = buf_pool->n_page_gets;
	buf_pool->n_pages_read_old = buf_pool->n_pages_read;
	buf_pool->n_pages_created_old = buf_pool->n_pages_created;
	buf_pool->n_pages_written_old = buf_pool->n_pages_written;
unknown's avatar
unknown committed
2400
	buf_pool->n_pages_awe_remapped_old = buf_pool->n_pages_awe_remapped; 
unknown's avatar
unknown committed
2401 2402
}

2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420
/*************************************************************************
Checks that all file pages in the buffer are in a replaceable state. */

ibool
buf_all_freed(void)
/*===============*/
{
	buf_block_t*	block;
	ulint		i;
	
	ut_ad(buf_pool);

	mutex_enter(&(buf_pool->mutex));

	for (i = 0; i < buf_pool->curr_size; i++) {

		block = buf_pool_get_nth_block(buf_pool, i);

2421 2422
		mutex_enter(&block->mutex);

2423 2424 2425 2426
		if (block->state == BUF_BLOCK_FILE_PAGE) {

			if (!buf_flush_ready_for_replace(block)) {

2427 2428
				fprintf(stderr,
					"Page %lu %lu still fixed or dirty\n",
2429 2430
					(ulong) block->space,
					(ulong) block->offset);
2431 2432 2433
			    	ut_error;
			}
		}
2434 2435

		mutex_exit(&block->mutex);
2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485
 	}

	mutex_exit(&(buf_pool->mutex));

	return(TRUE);
}	

/*************************************************************************
Checks that there currently are no pending i/o-operations for the buffer
pool. */

ibool
buf_pool_check_no_pending_io(void)
/*==============================*/
				/* out: TRUE if there is no pending i/o */
{
	ibool	ret;

	mutex_enter(&(buf_pool->mutex));

	if (buf_pool->n_pend_reads + buf_pool->n_flush[BUF_FLUSH_LRU]
				+ buf_pool->n_flush[BUF_FLUSH_LIST]
				+ buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]) {
		ret = FALSE;
	} else {
		ret = TRUE;
	}

	mutex_exit(&(buf_pool->mutex));

	return(ret);
}

/*************************************************************************
Gets the current length of the free list of buffer blocks. */

ulint
buf_get_free_list_len(void)
/*=======================*/
{
	ulint	len;

	mutex_enter(&(buf_pool->mutex));

	len = UT_LIST_GET_LEN(buf_pool->free);

	mutex_exit(&(buf_pool->mutex));

	return(len);
}