← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/buf0buf.h

  • Committer: Monty Taylor
  • Date: 2008-12-06 22:41:03 UTC
  • mto: (656.1.7 devel)
  • mto: This revision was merged to the branch mainline in revision 665.
  • Revision ID: monty@inaugust.com-20081206224103-jdouqwt9hb0f01y1
Moved non-working tests into broken suite for easier running of working tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/buf0buf.h
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (C) 1995, 2010, Innobase Oy. All Rights Reserved.
4
 
 
5
 
This program is free software; you can redistribute it and/or modify it under
6
 
the terms of the GNU General Public License as published by the Free Software
7
 
Foundation; version 2 of the License.
8
 
 
9
 
This program is distributed in the hope that it will be useful, but WITHOUT
10
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
 
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
 
 
13
 
You should have received a copy of the GNU General Public License along with
14
 
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15
 
St, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
*****************************************************************************/
18
 
 
19
 
/**************************************************//**
20
 
@file include/buf0buf.h
 
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
/******************************************************
21
16
The database buffer pool high-level routines
22
17
 
 
18
(c) 1995 Innobase Oy
 
19
 
23
20
Created 11/5/1995 Heikki Tuuri
24
21
*******************************************************/
25
22
 
30
27
#include "fil0fil.h"
31
28
#include "mtr0types.h"
32
29
#include "buf0types.h"
 
30
#include "sync0rw.h"
33
31
#include "hash0hash.h"
34
32
#include "ut0byte.h"
 
33
#include "os0proc.h"
35
34
#include "page0types.h"
36
 
#ifndef UNIV_HOTBACKUP
37
 
#include "ut0rbt.h"
38
 
#include "os0proc.h"
39
 
 
40
 
/** @name Modes for buf_page_get_gen */
41
 
/* @{ */
42
 
#define BUF_GET                 10      /*!< get always */
43
 
#define BUF_GET_IF_IN_POOL      11      /*!< get if in pool */
44
 
#define BUF_GET_NO_LATCH        14      /*!< get and bufferfix, but
45
 
                                        set no latch; we have
46
 
                                        separated this case, because
47
 
                                        it is error-prone programming
48
 
                                        not to set a latch, and it
49
 
                                        should be used with care */
50
 
#define BUF_GET_IF_IN_POOL_OR_WATCH     15
51
 
                                        /*!< Get the page only if it's in the
52
 
                                        buffer pool, if not then set a watch
53
 
                                        on the page. */
54
 
/* @} */
55
 
/** @name Modes for buf_page_get_known_nowait */
56
 
/* @{ */
57
 
#define BUF_MAKE_YOUNG  51              /*!< Move the block to the
58
 
                                        start of the LRU list if there
59
 
                                        is a danger that the block
60
 
                                        would drift out of the buffer
61
 
                                        pool*/
62
 
#define BUF_KEEP_OLD    52              /*!< Preserve the current LRU
63
 
                                        position of the block. */
64
 
/* @} */
65
 
 
66
 
#define MAX_BUFFER_POOLS 64             /*!< The maximum number of buffer
67
 
                                        pools that can be defined */
68
 
 
69
 
#define BUF_POOL_WATCH_SIZE 1           /*!< Maximum number of concurrent
70
 
                                        buffer pool watches */
71
 
 
72
 
extern  buf_pool_t*     buf_pool_ptr;   /*!< The buffer pools
73
 
                                        of the database */
 
35
 
 
36
/* Modes for buf_page_get_gen */
 
37
#define BUF_GET                 10      /* get always */
 
38
#define BUF_GET_IF_IN_POOL      11      /* get if in pool */
 
39
#define BUF_GET_NOWAIT          12      /* get if can set the latch without
 
40
                                        waiting */
 
41
#define BUF_GET_NO_LATCH        14      /* get and bufferfix, but set no latch;
 
42
                                        we have separated this case, because
 
43
                                        it is error-prone programming not to
 
44
                                        set a latch, and it should be used
 
45
                                        with care */
 
46
/* Modes for buf_page_get_known_nowait */
 
47
#define BUF_MAKE_YOUNG  51
 
48
#define BUF_KEEP_OLD    52
 
49
/* Magic value to use instead of checksums when they are disabled */
 
50
#define BUF_NO_CHECKSUM_MAGIC 0xDEADBEEFUL
 
51
 
 
52
extern buf_pool_t*      buf_pool;       /* The buffer pool of the database */
74
53
#ifdef UNIV_DEBUG
75
 
extern ibool            buf_debug_prints;/*!< If this is set TRUE, the program
 
54
extern ibool            buf_debug_prints;/* If this is set TRUE, the program
76
55
                                        prints info whenever read or flush
77
56
                                        occurs */
78
57
#endif /* UNIV_DEBUG */
79
 
#else /* !UNIV_HOTBACKUP */
80
 
extern buf_block_t*     back_block1;    /*!< first block, for --apply-log */
81
 
extern buf_block_t*     back_block2;    /*!< second block, for page reorganize */
82
 
#endif /* !UNIV_HOTBACKUP */
83
 
 
84
 
/** Magic value to use instead of checksums when they are disabled */
85
 
#define BUF_NO_CHECKSUM_MAGIC 0xDEADBEEFUL
86
 
 
87
 
/** @brief States of a control block
88
 
@see buf_page_struct
89
 
 
 
58
 
 
59
/* States of a control block (@see buf_page_struct).
90
60
The enumeration values must be 0..7. */
91
61
enum buf_page_state {
92
 
        BUF_BLOCK_ZIP_FREE = 0,         /*!< contains a free
93
 
                                        compressed page */
94
 
        BUF_BLOCK_POOL_WATCH = 0,       /*!< a sentinel for the buffer pool
95
 
                                        watch, element of buf_pool->watch[] */
96
 
        BUF_BLOCK_ZIP_PAGE,             /*!< contains a clean
97
 
                                        compressed page */
98
 
        BUF_BLOCK_ZIP_DIRTY,            /*!< contains a compressed
99
 
                                        page that is in the
100
 
                                        buf_pool->flush_list */
101
 
 
102
 
        BUF_BLOCK_NOT_USED,             /*!< is in the free list;
103
 
                                        must be after the BUF_BLOCK_ZIP_
104
 
                                        constants for compressed-only pages
105
 
                                        @see buf_block_state_valid() */
106
 
        BUF_BLOCK_READY_FOR_USE,        /*!< when buf_LRU_get_free_block
107
 
                                        returns a block, it is in this state */
108
 
        BUF_BLOCK_FILE_PAGE,            /*!< contains a buffered file page */
109
 
        BUF_BLOCK_MEMORY,               /*!< contains some main memory
110
 
                                        object */
111
 
        BUF_BLOCK_REMOVE_HASH           /*!< hash index should be removed
 
62
        BUF_BLOCK_ZIP_FREE = 0,         /* contains a free compressed page */
 
63
        BUF_BLOCK_ZIP_PAGE,             /* contains a clean compressed page */
 
64
        BUF_BLOCK_ZIP_DIRTY,            /* contains a compressed page that is
 
65
                                        in the buf_pool->flush_list */
 
66
 
 
67
        /* The constants for compressed-only pages must precede
 
68
        BUF_BLOCK_NOT_USED; @see buf_block_state_valid() */
 
69
 
 
70
        BUF_BLOCK_NOT_USED,             /* is in the free list */
 
71
        BUF_BLOCK_READY_FOR_USE,        /* when buf_LRU_get_free_block returns
 
72
                                        a block, it is in this state */
 
73
        BUF_BLOCK_FILE_PAGE,            /* contains a buffered file page */
 
74
        BUF_BLOCK_MEMORY,               /* contains some main memory object */
 
75
        BUF_BLOCK_REMOVE_HASH           /* hash index should be removed
112
76
                                        before putting to the free list */
113
77
};
114
78
 
115
 
#ifndef UNIV_HOTBACKUP
116
 
/********************************************************************//**
117
 
Acquire mutex on all buffer pool instances */
118
 
UNIV_INLINE
119
 
void
120
 
buf_pool_mutex_enter_all(void);
121
 
/*===========================*/
122
 
 
123
 
/********************************************************************//**
124
 
Release mutex on all buffer pool instances */
125
 
UNIV_INLINE
126
 
void
127
 
buf_pool_mutex_exit_all(void);
128
 
/*==========================*/
129
 
 
130
 
/********************************************************************//**
131
 
Creates the buffer pool.
132
 
@return own: buf_pool object, NULL if not enough memory or error */
 
79
/************************************************************************
 
80
Creates the buffer pool. */
133
81
UNIV_INTERN
134
 
ulint
135
 
buf_pool_init(
136
 
/*=========*/
137
 
        ulint   size,           /*!< in: Size of the total pool in bytes */
138
 
        ulint   n_instances);   /*!< in: Number of instances */
139
 
/********************************************************************//**
 
82
buf_pool_t*
 
83
buf_pool_init(void);
 
84
/*===============*/
 
85
                                /* out, own: buf_pool object, NULL if not
 
86
                                enough memory or error */
 
87
/************************************************************************
140
88
Frees the buffer pool at shutdown.  This must not be invoked before
141
89
freeing all mutexes. */
142
90
UNIV_INTERN
143
91
void
144
 
buf_pool_free(
145
 
/*==========*/
146
 
        ulint   n_instances);   /*!< in: numbere of instances to free */
147
 
 
148
 
/********************************************************************//**
149
 
Drops the adaptive hash index.  To prevent a livelock, this function
150
 
is only to be called while holding btr_search_latch and while
151
 
btr_search_enabled == FALSE. */
152
 
UNIV_INTERN
153
 
void
154
 
buf_pool_drop_hash_index(void);
155
 
/*==========================*/
156
 
 
157
 
/********************************************************************//**
 
92
buf_pool_free(void);
 
93
/*===============*/
 
94
 
 
95
/************************************************************************
158
96
Relocate a buffer control block.  Relocates the block on the LRU list
159
97
and in buf_pool->page_hash.  Does not relocate bpage->list.
160
98
The caller must take care of relocating bpage->list. */
162
100
void
163
101
buf_relocate(
164
102
/*=========*/
165
 
        buf_page_t*     bpage,  /*!< in/out: control block being relocated;
 
103
        buf_page_t*     bpage,  /* in/out: control block being relocated;
166
104
                                buf_page_get_state(bpage) must be
167
105
                                BUF_BLOCK_ZIP_DIRTY or BUF_BLOCK_ZIP_PAGE */
168
 
        buf_page_t*     dpage)  /*!< in/out: destination control block */
 
106
        buf_page_t*     dpage)  /* in/out: destination control block */
169
107
        __attribute__((nonnull));
170
 
/********************************************************************//**
 
108
/************************************************************************
171
109
Resizes the buffer pool. */
172
110
UNIV_INTERN
173
111
void
174
112
buf_pool_resize(void);
175
113
/*=================*/
176
 
/*********************************************************************//**
177
 
Gets the current size of buffer buf_pool in bytes.
178
 
@return size in bytes */
 
114
/*************************************************************************
 
115
Gets the current size of buffer buf_pool in bytes. */
179
116
UNIV_INLINE
180
117
ulint
181
118
buf_pool_get_curr_size(void);
182
119
/*========================*/
183
 
/*********************************************************************//**
184
 
Gets the current size of buffer buf_pool in frames.
185
 
@return size in pages */
186
 
UNIV_INLINE
187
 
ulint
188
 
buf_pool_get_n_pages(void);
189
 
/*=======================*/
190
 
/********************************************************************//**
 
120
                        /* out: size in bytes */
 
121
/************************************************************************
191
122
Gets the smallest oldest_modification lsn for any page in the pool. Returns
192
 
zero if all modified pages have been flushed to disk.
193
 
@return oldest modification in pool, zero if none */
194
 
UNIV_INTERN
 
123
zero if all modified pages have been flushed to disk. */
 
124
UNIV_INLINE
195
125
ib_uint64_t
196
126
buf_pool_get_oldest_modification(void);
197
127
/*==================================*/
198
 
/********************************************************************//**
199
 
Allocates a buffer block.
200
 
@return own: the allocated block, in state BUF_BLOCK_MEMORY */
201
 
UNIV_INTERN
 
128
                                /* out: oldest modification in pool,
 
129
                                zero if none */
 
130
/************************************************************************
 
131
Allocates a buffer block. */
 
132
UNIV_INLINE
202
133
buf_block_t*
203
134
buf_block_alloc(
204
135
/*============*/
205
 
        buf_pool_t*     buf_pool,       /*!< buffer pool instance */
206
 
        ulint           zip_size);      /*!< in: compressed page size in bytes,
207
 
                                        or 0 if uncompressed tablespace */
208
 
/********************************************************************//**
 
136
                                /* out, own: the allocated block,
 
137
                                in state BUF_BLOCK_MEMORY */
 
138
        ulint   zip_size);      /* in: compressed page size in bytes,
 
139
                                or 0 if uncompressed tablespace */
 
140
/************************************************************************
209
141
Frees a buffer block which does not contain a file page. */
210
142
UNIV_INLINE
211
143
void
212
144
buf_block_free(
213
145
/*===========*/
214
 
        buf_block_t*    block); /*!< in, own: block to be freed */
215
 
#endif /* !UNIV_HOTBACKUP */
216
 
/*********************************************************************//**
217
 
Copies contents of a buffer frame to a given buffer.
218
 
@return buf */
 
146
        buf_block_t*    block); /* in, own: block to be freed */
 
147
/*************************************************************************
 
148
Copies contents of a buffer frame to a given buffer. */
219
149
UNIV_INLINE
220
150
byte*
221
151
buf_frame_copy(
222
152
/*===========*/
223
 
        byte*                   buf,    /*!< in: buffer to copy to */
224
 
        const buf_frame_t*      frame); /*!< in: buffer frame */
225
 
#ifndef UNIV_HOTBACKUP
226
 
/**************************************************************//**
 
153
                                        /* out: buf */
 
154
        byte*                   buf,    /* in: buffer to copy to */
 
155
        const buf_frame_t*      frame); /* in: buffer frame */
 
156
/******************************************************************
227
157
NOTE! The following macros should be used instead of buf_page_get_gen,
228
158
to improve debugging. Only values RW_S_LATCH and RW_X_LATCH are allowed
229
159
in LA! */
230
160
#define buf_page_get(SP, ZS, OF, LA, MTR)        buf_page_get_gen(\
231
161
                                SP, ZS, OF, LA, NULL,\
232
162
                                BUF_GET, __FILE__, __LINE__, MTR)
233
 
/**************************************************************//**
 
163
/******************************************************************
234
164
Use these macros to bufferfix a page with no latching. Remember not to
235
165
read the contents of the page unless you know it is safe. Do not modify
236
166
the contents of the page! We have separated this case, because it is
239
169
#define buf_page_get_with_no_latch(SP, ZS, OF, MTR)        buf_page_get_gen(\
240
170
                                SP, ZS, OF, RW_NO_LATCH, NULL,\
241
171
                                BUF_GET_NO_LATCH, __FILE__, __LINE__, MTR)
242
 
/********************************************************************//**
 
172
/******************************************************************
 
173
NOTE! The following macros should be used instead of buf_page_get_gen, to
 
174
improve debugging. Only values RW_S_LATCH and RW_X_LATCH are allowed as LA! */
 
175
#define buf_page_get_nowait(SP, ZS, OF, LA, MTR)        buf_page_get_gen(\
 
176
                                SP, ZS, OF, LA, NULL,\
 
177
                                BUF_GET_NOWAIT, __FILE__, __LINE__, MTR)
 
178
/******************************************************************
 
179
NOTE! The following macros should be used instead of
 
180
buf_page_optimistic_get_func, to improve debugging. Only values RW_S_LATCH and
 
181
RW_X_LATCH are allowed as LA! */
 
182
#define buf_page_optimistic_get(LA, BL, MC, MTR)                             \
 
183
        buf_page_optimistic_get_func(LA, BL, MC, __FILE__, __LINE__, MTR)
 
184
/************************************************************************
243
185
This is the general function used to get optimistic access to a database
244
 
page.
245
 
@return TRUE if success */
 
186
page. */
246
187
UNIV_INTERN
247
188
ibool
248
 
buf_page_optimistic_get(
249
 
/*====================*/
250
 
        ulint           rw_latch,/*!< in: RW_S_LATCH, RW_X_LATCH */
251
 
        buf_block_t*    block,  /*!< in: guessed block */
252
 
        ib_uint64_t     modify_clock,/*!< in: modify clock value if mode is
 
189
buf_page_optimistic_get_func(
 
190
/*=========================*/
 
191
                                /* out: TRUE if success */
 
192
        ulint           rw_latch,/* in: RW_S_LATCH, RW_X_LATCH */
 
193
        buf_block_t*    block,  /* in: guessed block */
 
194
        ib_uint64_t     modify_clock,/* in: modify clock value if mode is
253
195
                                ..._GUESS_ON_CLOCK */
254
 
        const char*     file,   /*!< in: file name */
255
 
        ulint           line,   /*!< in: line where called */
256
 
        mtr_t*          mtr);   /*!< in: mini-transaction */
257
 
/********************************************************************//**
 
196
        const char*     file,   /* in: file name */
 
197
        ulint           line,   /* in: line where called */
 
198
        mtr_t*          mtr);   /* in: mini-transaction */
 
199
/************************************************************************
258
200
This is used to get access to a known database page, when no waiting can be
259
 
done.
260
 
@return TRUE if success */
 
201
done. */
261
202
UNIV_INTERN
262
203
ibool
263
204
buf_page_get_known_nowait(
264
205
/*======================*/
265
 
        ulint           rw_latch,/*!< in: RW_S_LATCH, RW_X_LATCH */
266
 
        buf_block_t*    block,  /*!< in: the known page */
267
 
        ulint           mode,   /*!< in: BUF_MAKE_YOUNG or BUF_KEEP_OLD */
268
 
        const char*     file,   /*!< in: file name */
269
 
        ulint           line,   /*!< in: line where called */
270
 
        mtr_t*          mtr);   /*!< in: mini-transaction */
 
206
                                /* out: TRUE if success */
 
207
        ulint           rw_latch,/* in: RW_S_LATCH, RW_X_LATCH */
 
208
        buf_block_t*    block,  /* in: the known page */
 
209
        ulint           mode,   /* in: BUF_MAKE_YOUNG or BUF_KEEP_OLD */
 
210
        const char*     file,   /* in: file name */
 
211
        ulint           line,   /* in: line where called */
 
212
        mtr_t*          mtr);   /* in: mini-transaction */
271
213
 
272
 
/*******************************************************************//**
 
214
/***********************************************************************
273
215
Given a tablespace id and page number tries to get that page. If the
274
216
page is not in the buffer pool it is not loaded and NULL is returned.
275
217
Suitable for using when holding the kernel mutex. */
276
 
UNIV_INTERN
 
218
 
277
219
const buf_block_t*
278
220
buf_page_try_get_func(
279
221
/*==================*/
280
 
        ulint           space_id,/*!< in: tablespace id */
281
 
        ulint           page_no,/*!< in: page number */
282
 
        const char*     file,   /*!< in: file name */
283
 
        ulint           line,   /*!< in: line where called */
284
 
        mtr_t*          mtr);   /*!< in: mini-transaction */
 
222
        ulint           space_id,/* in: tablespace id */
 
223
        ulint           page_no,/* in: page number */
 
224
        const char*     file,   /* in: file name */
 
225
        ulint           line,   /* in: line where called */
 
226
        mtr_t*          mtr);   /* in: mini-transaction */
285
227
 
286
 
/** Tries to get a page. If the page is not in the buffer pool it is
287
 
not loaded.  Suitable for using when holding the kernel mutex.
288
 
@param space_id in: tablespace id
289
 
@param page_no  in: page number
290
 
@param mtr      in: mini-transaction
291
 
@return         the page if in buffer pool, NULL if not */
292
228
#define buf_page_try_get(space_id, page_no, mtr)        \
293
229
        buf_page_try_get_func(space_id, page_no, __FILE__, __LINE__, mtr);
294
230
 
295
 
/********************************************************************//**
 
231
/************************************************************************
296
232
Get read access to a compressed page (usually of type
297
233
FIL_PAGE_TYPE_ZBLOB or FIL_PAGE_TYPE_ZBLOB2).
298
234
The page must be released with buf_page_release_zip().
299
235
NOTE: the page is not protected by any latch.  Mutual exclusion has to
300
236
be implemented at a higher level.  In other words, all possible
301
237
accesses to a given page through this function must be protected by
302
 
the same set of mutexes or latches.
303
 
@return pointer to the block, or NULL if not compressed */
 
238
the same set of mutexes or latches. */
304
239
UNIV_INTERN
305
240
buf_page_t*
306
241
buf_page_get_zip(
307
242
/*=============*/
308
 
        ulint           space,  /*!< in: space id */
309
 
        ulint           zip_size,/*!< in: compressed page size */
310
 
        ulint           offset);/*!< in: page number */
311
 
/********************************************************************//**
312
 
This is the general function used to get access to a database page.
313
 
@return pointer to the block or NULL */
 
243
                                /* out: pointer to the block,
 
244
                                or NULL if not compressed */
 
245
        ulint           space,  /* in: space id */
 
246
        ulint           zip_size,/* in: compressed page size */
 
247
        ulint           offset);/* in: page number */
 
248
/************************************************************************
 
249
This is the general function used to get access to a database page. */
314
250
UNIV_INTERN
315
251
buf_block_t*
316
252
buf_page_get_gen(
317
253
/*=============*/
318
 
        ulint           space,  /*!< in: space id */
319
 
        ulint           zip_size,/*!< in: compressed page size in bytes
 
254
                                /* out: pointer to the block or NULL */
 
255
        ulint           space,  /* in: space id */
 
256
        ulint           zip_size,/* in: compressed page size in bytes
320
257
                                or 0 for uncompressed pages */
321
 
        ulint           offset, /*!< in: page number */
322
 
        ulint           rw_latch,/*!< in: RW_S_LATCH, RW_X_LATCH, RW_NO_LATCH */
323
 
        buf_block_t*    guess,  /*!< in: guessed block or NULL */
324
 
        ulint           mode,   /*!< in: BUF_GET, BUF_GET_IF_IN_POOL,
325
 
                                BUF_GET_NO_LATCH or
326
 
                                BUF_GET_IF_IN_POOL_OR_WATCH */
327
 
        const char*     file,   /*!< in: file name */
328
 
        ulint           line,   /*!< in: line where called */
329
 
        mtr_t*          mtr);   /*!< in: mini-transaction */
330
 
/********************************************************************//**
 
258
        ulint           offset, /* in: page number */
 
259
        ulint           rw_latch,/* in: RW_S_LATCH, RW_X_LATCH, RW_NO_LATCH */
 
260
        buf_block_t*    guess,  /* in: guessed block or NULL */
 
261
        ulint           mode,   /* in: BUF_GET, BUF_GET_IF_IN_POOL,
 
262
                                BUF_GET_NO_LATCH */
 
263
        const char*     file,   /* in: file name */
 
264
        ulint           line,   /* in: line where called */
 
265
        mtr_t*          mtr);   /* in: mini-transaction */
 
266
/************************************************************************
331
267
Initializes a page to the buffer buf_pool. The page is usually not read
332
268
from a file even if it cannot be found in the buffer buf_pool. This is one
333
269
of the functions which perform to a block a state transition NOT_USED =>
334
 
FILE_PAGE (the other is buf_page_get_gen).
335
 
@return pointer to the block, page bufferfixed */
 
270
FILE_PAGE (the other is buf_page_get_gen). */
336
271
UNIV_INTERN
337
272
buf_block_t*
338
273
buf_page_create(
339
274
/*============*/
340
 
        ulint   space,  /*!< in: space id */
341
 
        ulint   offset, /*!< in: offset of the page within space in units of
 
275
                        /* out: pointer to the block, page bufferfixed */
 
276
        ulint   space,  /* in: space id */
 
277
        ulint   offset, /* in: offset of the page within space in units of
342
278
                        a page */
343
 
        ulint   zip_size,/*!< in: compressed page size, or 0 */
344
 
        mtr_t*  mtr);   /*!< in: mini-transaction handle */
345
 
#else /* !UNIV_HOTBACKUP */
346
 
/********************************************************************//**
 
279
        ulint   zip_size,/* in: compressed page size, or 0 */
 
280
        mtr_t*  mtr);   /* in: mini-transaction handle */
 
281
#ifdef UNIV_HOTBACKUP
 
282
/************************************************************************
347
283
Inits a page to the buffer buf_pool, for use in ibbackup --restore. */
348
284
UNIV_INTERN
349
285
void
350
286
buf_page_init_for_backup_restore(
351
287
/*=============================*/
352
 
        ulint           space,  /*!< in: space id */
353
 
        ulint           offset, /*!< in: offset of the page within space
 
288
        ulint           space,  /* in: space id */
 
289
        ulint           offset, /* in: offset of the page within space
354
290
                                in units of a page */
355
 
        ulint           zip_size,/*!< in: compressed page size in bytes
 
291
        ulint           zip_size,/* in: compressed page size in bytes
356
292
                                or 0 for uncompressed pages */
357
 
        buf_block_t*    block); /*!< in: block to init */
358
 
#endif /* !UNIV_HOTBACKUP */
359
 
 
360
 
#ifndef UNIV_HOTBACKUP
361
 
/********************************************************************//**
 
293
        buf_block_t*    block); /* in: block to init */
 
294
#endif /* UNIV_HOTBACKUP */
 
295
/************************************************************************
362
296
Releases a compressed-only page acquired with buf_page_get_zip(). */
363
297
UNIV_INLINE
364
298
void
365
299
buf_page_release_zip(
366
300
/*=================*/
367
 
        buf_page_t*     bpage);         /*!< in: buffer block */
368
 
/********************************************************************//**
 
301
        buf_page_t*     bpage);         /* in: buffer block */
 
302
/************************************************************************
369
303
Decrements the bufferfix count of a buffer control block and releases
370
304
a latch, if specified. */
371
305
UNIV_INLINE
372
306
void
373
307
buf_page_release(
374
308
/*=============*/
375
 
        buf_block_t*    block,          /*!< in: buffer block */
376
 
        ulint           rw_latch);      /*!< in: RW_S_LATCH, RW_X_LATCH,
 
309
        buf_block_t*    block,          /* in: buffer block */
 
310
        ulint           rw_latch,       /* in: RW_S_LATCH, RW_X_LATCH,
377
311
                                        RW_NO_LATCH */
378
 
/********************************************************************//**
 
312
        mtr_t*          mtr);           /* in: mtr */
 
313
/************************************************************************
379
314
Moves a page to the start of the buffer pool LRU list. This high-level
380
 
function can be used to prevent an important page from slipping out of
 
315
function can be used to prevent an important page from from slipping out of
381
316
the buffer pool. */
382
317
UNIV_INTERN
383
318
void
384
319
buf_page_make_young(
385
320
/*================*/
386
 
        buf_page_t*     bpage); /*!< in: buffer block of a file page */
387
 
/********************************************************************//**
388
 
Returns TRUE if the page can be found in the buffer pool hash table.
389
 
 
390
 
NOTE that it is possible that the page is not yet read from disk,
391
 
though.
392
 
 
393
 
@return TRUE if found in the page hash table */
 
321
        buf_page_t*     bpage); /* in: buffer block of a file page */
 
322
/************************************************************************
 
323
Returns TRUE if the page can be found in the buffer pool hash table. NOTE
 
324
that it is possible that the page is not yet read from disk, though. */
394
325
UNIV_INLINE
395
326
ibool
396
327
buf_page_peek(
397
328
/*==========*/
398
 
        ulint   space,  /*!< in: space id */
399
 
        ulint   offset);/*!< in: page number */
400
 
/********************************************************************//**
 
329
                        /* out: TRUE if found from page hash table,
 
330
                        NOTE that the page is not necessarily yet read
 
331
                        from disk! */
 
332
        ulint   space,  /* in: space id */
 
333
        ulint   offset);/* in: page number */
 
334
/************************************************************************
401
335
Resets the check_index_page_at_flush field of a page if found in the buffer
402
336
pool. */
403
337
UNIV_INTERN
404
338
void
405
339
buf_reset_check_index_page_at_flush(
406
340
/*================================*/
407
 
        ulint   space,  /*!< in: space id */
408
 
        ulint   offset);/*!< in: page number */
 
341
        ulint   space,  /* in: space id */
 
342
        ulint   offset);/* in: page number */
409
343
#ifdef UNIV_DEBUG_FILE_ACCESSES
410
 
/********************************************************************//**
 
344
/************************************************************************
411
345
Sets file_page_was_freed TRUE if the page is found in the buffer pool.
412
346
This function should be called when we free a file page and want the
413
347
debug version to check that it is not accessed any more unless
414
 
reallocated.
415
 
@return control block if found in page hash table, otherwise NULL */
 
348
reallocated. */
416
349
UNIV_INTERN
417
350
buf_page_t*
418
351
buf_page_set_file_page_was_freed(
419
352
/*=============================*/
420
 
        ulint   space,  /*!< in: space id */
421
 
        ulint   offset);/*!< in: page number */
422
 
/********************************************************************//**
 
353
                        /* out: control block if found in page hash table,
 
354
                        otherwise NULL */
 
355
        ulint   space,  /* in: space id */
 
356
        ulint   offset);/* in: page number */
 
357
/************************************************************************
423
358
Sets file_page_was_freed FALSE if the page is found in the buffer pool.
424
359
This function should be called when we free a file page and want the
425
360
debug version to check that it is not accessed any more unless
426
 
reallocated.
427
 
@return control block if found in page hash table, otherwise NULL */
 
361
reallocated. */
428
362
UNIV_INTERN
429
363
buf_page_t*
430
364
buf_page_reset_file_page_was_freed(
431
365
/*===============================*/
432
 
        ulint   space,  /*!< in: space id */
433
 
        ulint   offset);        /*!< in: page number */
 
366
                        /* out: control block if found in page hash table,
 
367
                        otherwise NULL */
 
368
        ulint   space,  /* in: space id */
 
369
        ulint   offset);        /* in: page number */
434
370
#endif /* UNIV_DEBUG_FILE_ACCESSES */
435
 
/********************************************************************//**
436
 
Reads the freed_page_clock of a buffer block.
437
 
@return freed_page_clock */
 
371
/************************************************************************
 
372
Reads the freed_page_clock of a buffer block. */
438
373
UNIV_INLINE
439
374
ulint
440
375
buf_page_get_freed_page_clock(
441
376
/*==========================*/
442
 
        const buf_page_t*       bpage)  /*!< in: block */
 
377
                                        /* out: freed_page_clock */
 
378
        const buf_page_t*       bpage)  /* in: block */
443
379
        __attribute__((pure));
444
 
/********************************************************************//**
445
 
Reads the freed_page_clock of a buffer block.
446
 
@return freed_page_clock */
 
380
/************************************************************************
 
381
Reads the freed_page_clock of a buffer block. */
447
382
UNIV_INLINE
448
383
ulint
449
384
buf_block_get_freed_page_clock(
450
385
/*===========================*/
451
 
        const buf_block_t*      block)  /*!< in: block */
 
386
                                        /* out: freed_page_clock */
 
387
        const buf_block_t*      block)  /* in: block */
452
388
        __attribute__((pure));
453
389
 
454
 
/********************************************************************//**
 
390
/************************************************************************
455
391
Recommends a move of a block to the start of the LRU list if there is danger
456
392
of dropping from the buffer pool. NOTE: does not reserve the buffer pool
457
 
mutex.
458
 
@return TRUE if should be made younger */
 
393
mutex. */
459
394
UNIV_INLINE
460
395
ibool
461
396
buf_page_peek_if_too_old(
462
397
/*=====================*/
463
 
        const buf_page_t*       bpage); /*!< in: block to make younger */
464
 
/********************************************************************//**
 
398
                                        /* out: TRUE if should be made
 
399
                                        younger */
 
400
        const buf_page_t*       bpage); /* in: block to make younger */
 
401
/************************************************************************
465
402
Returns the current state of is_hashed of a page. FALSE if the page is
466
403
not in the pool. NOTE that this operation does not fix the page in the
467
 
pool if it is found there.
468
 
@return TRUE if page hash index is built in search system */
 
404
pool if it is found there. */
469
405
UNIV_INTERN
470
406
ibool
471
407
buf_page_peek_if_search_hashed(
472
408
/*===========================*/
473
 
        ulint   space,  /*!< in: space id */
474
 
        ulint   offset);/*!< in: page number */
475
 
/********************************************************************//**
 
409
                        /* out: TRUE if page hash index is built in search
 
410
                        system */
 
411
        ulint   space,  /* in: space id */
 
412
        ulint   offset);/* in: page number */
 
413
/************************************************************************
476
414
Gets the youngest modification log sequence number for a frame.
477
 
Returns zero if not file page or no modification occurred yet.
478
 
@return newest modification to page */
 
415
Returns zero if not file page or no modification occurred yet. */
479
416
UNIV_INLINE
480
417
ib_uint64_t
481
418
buf_page_get_newest_modification(
482
419
/*=============================*/
483
 
        const buf_page_t*       bpage); /*!< in: block containing the
 
420
                                        /* out: newest modification to page */
 
421
        const buf_page_t*       bpage); /* in: block containing the
484
422
                                        page frame */
485
 
/********************************************************************//**
 
423
/************************************************************************
486
424
Increments the modify clock of a frame by 1. The caller must (1) own the
487
 
buf_pool->mutex and block bufferfix count has to be zero, (2) or own an x-lock
 
425
buf_pool mutex and block bufferfix count has to be zero, (2) or own an x-lock
488
426
on the block. */
489
427
UNIV_INLINE
490
428
void
491
429
buf_block_modify_clock_inc(
492
430
/*=======================*/
493
 
        buf_block_t*    block); /*!< in: block */
494
 
/********************************************************************//**
 
431
        buf_block_t*    block); /* in: block */
 
432
/************************************************************************
495
433
Returns the value of the modify clock. The caller must have an s-lock
496
 
or x-lock on the block.
497
 
@return value */
 
434
or x-lock on the block. */
498
435
UNIV_INLINE
499
436
ib_uint64_t
500
437
buf_block_get_modify_clock(
501
438
/*=======================*/
502
 
        buf_block_t*    block); /*!< in: block */
503
 
#else /* !UNIV_HOTBACKUP */
504
 
# define buf_block_modify_clock_inc(block) ((void) 0)
505
 
#endif /* !UNIV_HOTBACKUP */
506
 
/********************************************************************//**
 
439
                                /* out: value */
 
440
        buf_block_t*    block); /* in: block */
 
441
/************************************************************************
507
442
Calculates a page checksum which is stored to the page when it is written
508
443
to a file. Note that we must be careful to calculate the same value
509
 
on 32-bit and 64-bit architectures.
510
 
@return checksum */
 
444
on 32-bit and 64-bit architectures. */
511
445
UNIV_INTERN
512
446
ulint
513
447
buf_calc_page_new_checksum(
514
448
/*=======================*/
515
 
        const byte*     page);  /*!< in: buffer page */
516
 
/********************************************************************//**
 
449
                                /* out: checksum */
 
450
        const byte*     page);  /* in: buffer page */
 
451
/************************************************************************
517
452
In versions < 4.0.14 and < 4.1.1 there was a bug that the checksum only
518
453
looked at the first few bytes of the page. This calculates that old
519
454
checksum.
520
455
NOTE: we must first store the new formula checksum to
521
456
FIL_PAGE_SPACE_OR_CHKSUM before calculating and storing this old checksum
522
 
because this takes that field as an input!
523
 
@return checksum */
 
457
because this takes that field as an input! */
524
458
UNIV_INTERN
525
459
ulint
526
460
buf_calc_page_old_checksum(
527
461
/*=======================*/
528
 
        const byte*      page); /*!< in: buffer page */
529
 
/********************************************************************//**
530
 
Checks if a page is corrupt.
531
 
@return TRUE if corrupted */
 
462
                                /* out: checksum */
 
463
        const byte*      page); /* in: buffer page */
 
464
/************************************************************************
 
465
Checks if a page is corrupt. */
532
466
UNIV_INTERN
533
467
ibool
534
468
buf_page_is_corrupted(
535
469
/*==================*/
536
 
        const byte*     read_buf,       /*!< in: a database page */
537
 
        ulint           zip_size);      /*!< in: size of compressed page;
 
470
                                        /* out: TRUE if corrupted */
 
471
        const byte*     read_buf,       /* in: a database page */
 
472
        ulint           zip_size);      /* in: size of compressed page;
538
473
                                        0 for uncompressed pages */
539
 
#ifndef UNIV_HOTBACKUP
540
 
/**********************************************************************//**
 
474
/**************************************************************************
541
475
Gets the space id, page offset, and byte offset within page of a
542
476
pointer pointing to a buffer frame containing a file page. */
543
477
UNIV_INLINE
544
478
void
545
479
buf_ptr_get_fsp_addr(
546
480
/*=================*/
547
 
        const void*     ptr,    /*!< in: pointer to a buffer frame */
548
 
        ulint*          space,  /*!< out: space id */
549
 
        fil_addr_t*     addr);  /*!< out: page offset and byte offset */
550
 
/**********************************************************************//**
 
481
        const void*     ptr,    /* in: pointer to a buffer frame */
 
482
        ulint*          space,  /* out: space id */
 
483
        fil_addr_t*     addr);  /* out: page offset and byte offset */
 
484
/**************************************************************************
551
485
Gets the hash value of a block. This can be used in searches in the
552
 
lock hash table.
553
 
@return lock hash value */
 
486
lock hash table. */
554
487
UNIV_INLINE
555
488
ulint
556
489
buf_block_get_lock_hash_val(
557
490
/*========================*/
558
 
        const buf_block_t*      block)  /*!< in: block */
 
491
                                        /* out: lock hash value */
 
492
        const buf_block_t*      block)  /* in: block */
559
493
        __attribute__((pure));
560
494
#ifdef UNIV_DEBUG
561
 
/*********************************************************************//**
 
495
/*************************************************************************
562
496
Finds a block in the buffer pool that points to a
563
 
given compressed page.
564
 
@return buffer block pointing to the compressed page, or NULL */
 
497
given compressed page. */
565
498
UNIV_INTERN
566
499
buf_block_t*
567
500
buf_pool_contains_zip(
568
501
/*==================*/
569
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
570
 
        const void*     data);          /*!< in: pointer to compressed page */
 
502
                                /* out: buffer block pointing to
 
503
                                the compressed page, or NULL */
 
504
        const void*     data);  /* in: pointer to compressed page */
571
505
#endif /* UNIV_DEBUG */
572
506
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
573
 
/*********************************************************************//**
574
 
Validates the buffer pool data structure.
575
 
@return TRUE */
 
507
/*************************************************************************
 
508
Validates the buffer pool data structure. */
576
509
UNIV_INTERN
577
510
ibool
578
511
buf_validate(void);
579
512
/*==============*/
580
513
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
581
514
#if defined UNIV_DEBUG_PRINT || defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
582
 
/*********************************************************************//**
 
515
/*************************************************************************
583
516
Prints info of the buffer pool data structure. */
584
517
UNIV_INTERN
585
518
void
586
519
buf_print(void);
587
520
/*============*/
588
521
#endif /* UNIV_DEBUG_PRINT || UNIV_DEBUG || UNIV_BUF_DEBUG */
589
 
#endif /* !UNIV_HOTBACKUP */
590
 
/********************************************************************//**
 
522
/************************************************************************
591
523
Prints a page to stderr. */
592
524
UNIV_INTERN
593
525
void
594
526
buf_page_print(
595
527
/*===========*/
596
 
        const byte*     read_buf,       /*!< in: a database page */
597
 
        ulint           zip_size);      /*!< in: compressed page size, or
 
528
        const byte*     read_buf,       /* in: a database page */
 
529
        ulint           zip_size);      /* in: compressed page size, or
598
530
                                        0 for uncompressed pages */
599
 
/********************************************************************//**
600
 
Decompress a block.
601
 
@return TRUE if successful */
602
 
UNIV_INTERN
603
 
ibool
604
 
buf_zip_decompress(
605
 
/*===============*/
606
 
        buf_block_t*    block,  /*!< in/out: block */
607
 
        ibool           check); /*!< in: TRUE=verify the page checksum */
608
 
#ifndef UNIV_HOTBACKUP
609
531
#ifdef UNIV_DEBUG
610
 
/*********************************************************************//**
611
 
Returns the number of latched pages in the buffer pool.
612
 
@return number of latched pages */
 
532
/*************************************************************************
 
533
Returns the number of latched pages in the buffer pool. */
613
534
UNIV_INTERN
614
535
ulint
615
536
buf_get_latched_pages_number(void);
616
537
/*==============================*/
617
538
#endif /* UNIV_DEBUG */
618
 
/*********************************************************************//**
619
 
Returns the number of pending buf pool ios.
620
 
@return number of pending I/O operations */
 
539
/*************************************************************************
 
540
Returns the number of pending buf pool ios. */
621
541
UNIV_INTERN
622
542
ulint
623
543
buf_get_n_pending_ios(void);
624
544
/*=======================*/
625
 
/*********************************************************************//**
 
545
/*************************************************************************
626
546
Prints info of the buffer i/o. */
627
547
UNIV_INTERN
628
548
void
629
549
buf_print_io(
630
550
/*=========*/
631
 
        FILE*   file);  /*!< in: file where to print */
632
 
/*********************************************************************//**
 
551
        FILE*   file);  /* in: file where to print */
 
552
/*************************************************************************
633
553
Returns the ratio in percents of modified pages in the buffer pool /
634
 
database pages in the buffer pool.
635
 
@return modified page percentage ratio */
 
554
database pages in the buffer pool. */
636
555
UNIV_INTERN
637
556
ulint
638
557
buf_get_modified_ratio_pct(void);
639
558
/*============================*/
640
 
/**********************************************************************//**
641
 
Refreshes the statistics used to print per-second averages. */
642
 
UNIV_INTERN
643
 
void
644
 
buf_refresh_io_stats(
645
 
/*=================*/
646
 
        buf_pool_t*     buf_pool);      /*!< buffer pool instance */
647
 
/**********************************************************************//**
648
 
Refreshes the statistics used to print per-second averages. */
649
 
UNIV_INTERN
650
 
void
651
 
buf_refresh_io_stats_all(void);
652
 
/*=================*/
653
 
/*********************************************************************//**
654
 
Asserts that all file pages in the buffer are in a replaceable state.
655
 
@return TRUE */
 
559
/**************************************************************************
 
560
Refreshes the statistics used to print per-second averages. */
 
561
UNIV_INTERN
 
562
void
 
563
buf_refresh_io_stats(void);
 
564
/*======================*/
 
565
/*************************************************************************
 
566
Checks that all file pages in the buffer are in a replaceable state. */
656
567
UNIV_INTERN
657
568
ibool
658
569
buf_all_freed(void);
659
570
/*===============*/
660
 
/*********************************************************************//**
 
571
/*************************************************************************
661
572
Checks that there currently are no pending i/o-operations for the buffer
662
 
pool.
663
 
@return TRUE if there is no pending i/o */
 
573
pool. */
664
574
UNIV_INTERN
665
575
ibool
666
576
buf_pool_check_no_pending_io(void);
667
577
/*==============================*/
668
 
/*********************************************************************//**
 
578
                                /* out: TRUE if there is no pending i/o */
 
579
/*************************************************************************
669
580
Invalidates the file pages in the buffer pool when an archive recovery is
670
581
completed. All the file pages buffered must be in a replaceable state when
671
582
this function is called: not latched and not modified. */
673
584
void
674
585
buf_pool_invalidate(void);
675
586
/*=====================*/
676
 
#endif /* !UNIV_HOTBACKUP */
677
587
 
678
588
/*========================================================================
679
589
--------------------------- LOWER LEVEL ROUTINES -------------------------
680
590
=========================================================================*/
681
591
 
682
592
#ifdef UNIV_SYNC_DEBUG
683
 
/*********************************************************************//**
 
593
/*************************************************************************
684
594
Adds latch level info for the rw-lock protecting the buffer frame. This
685
595
should be called in the debug version after a successful latching of a
686
596
page if we know the latching order level of the acquired latch. */
688
598
void
689
599
buf_block_dbg_add_level(
690
600
/*====================*/
691
 
        buf_block_t*    block,  /*!< in: buffer page
 
601
        buf_block_t*    block,  /* in: buffer page
692
602
                                where we have acquired latch */
693
 
        ulint           level); /*!< in: latching order level */
 
603
        ulint           level); /* in: latching order level */
694
604
#else /* UNIV_SYNC_DEBUG */
695
605
# define buf_block_dbg_add_level(block, level) /* nothing */
696
606
#endif /* UNIV_SYNC_DEBUG */
697
 
/*********************************************************************//**
698
 
Gets the state of a block.
699
 
@return state */
 
607
/*************************************************************************
 
608
Gets the state of a block. */
700
609
UNIV_INLINE
701
610
enum buf_page_state
702
611
buf_page_get_state(
703
612
/*===============*/
704
 
        const buf_page_t*       bpage); /*!< in: pointer to the control block */
705
 
/*********************************************************************//**
706
 
Gets the state of a block.
707
 
@return state */
 
613
                                        /* out: state */
 
614
        const buf_page_t*       bpage); /* in: pointer to the control block */
 
615
/*************************************************************************
 
616
Gets the state of a block. */
708
617
UNIV_INLINE
709
618
enum buf_page_state
710
619
buf_block_get_state(
711
620
/*================*/
712
 
        const buf_block_t*      block)  /*!< in: pointer to the control block */
 
621
                                        /* out: state */
 
622
        const buf_block_t*      block)  /* in: pointer to the control block */
713
623
        __attribute__((pure));
714
 
/*********************************************************************//**
 
624
/*************************************************************************
715
625
Sets the state of a block. */
716
626
UNIV_INLINE
717
627
void
718
628
buf_page_set_state(
719
629
/*===============*/
720
 
        buf_page_t*             bpage,  /*!< in/out: pointer to control block */
721
 
        enum buf_page_state     state); /*!< in: state */
722
 
/*********************************************************************//**
 
630
        buf_page_t*             bpage,  /* in/out: pointer to control block */
 
631
        enum buf_page_state     state); /* in: state */
 
632
/*************************************************************************
723
633
Sets the state of a block. */
724
634
UNIV_INLINE
725
635
void
726
636
buf_block_set_state(
727
637
/*================*/
728
 
        buf_block_t*            block,  /*!< in/out: pointer to control block */
729
 
        enum buf_page_state     state); /*!< in: state */
730
 
/*********************************************************************//**
731
 
Determines if a block is mapped to a tablespace.
732
 
@return TRUE if mapped */
 
638
        buf_block_t*            block,  /* in/out: pointer to control block */
 
639
        enum buf_page_state     state); /* in: state */
 
640
/*************************************************************************
 
641
Determines if a block is mapped to a tablespace. */
733
642
UNIV_INLINE
734
643
ibool
735
644
buf_page_in_file(
736
645
/*=============*/
737
 
        const buf_page_t*       bpage)  /*!< in: pointer to control block */
 
646
                                        /* out: TRUE if mapped */
 
647
        const buf_page_t*       bpage)  /* in: pointer to control block */
738
648
        __attribute__((pure));
739
 
#ifndef UNIV_HOTBACKUP
740
 
/*********************************************************************//**
741
 
Determines if a block should be on unzip_LRU list.
742
 
@return TRUE if block belongs to unzip_LRU */
 
649
/*************************************************************************
 
650
Determines if a block should be on unzip_LRU list. */
743
651
UNIV_INLINE
744
652
ibool
745
653
buf_page_belongs_to_unzip_LRU(
746
654
/*==========================*/
747
 
        const buf_page_t*       bpage)  /*!< in: pointer to control block */
 
655
                                        /* out: TRUE if block belongs
 
656
                                        to unzip_LRU */
 
657
        const buf_page_t*       bpage)  /* in: pointer to control block */
 
658
        __attribute__((pure));
 
659
/*************************************************************************
 
660
Determine the approximate LRU list position of a block. */
 
661
UNIV_INLINE
 
662
ulint
 
663
buf_page_get_LRU_position(
 
664
/*======================*/
 
665
                                        /* out: LRU list position */
 
666
        const buf_page_t*       bpage)  /* in: control block */
748
667
        __attribute__((pure));
749
668
 
750
 
/*********************************************************************//**
751
 
Gets the mutex of a block.
752
 
@return pointer to mutex protecting bpage */
 
669
/*************************************************************************
 
670
Gets the mutex of a block. */
753
671
UNIV_INLINE
754
672
mutex_t*
755
673
buf_page_get_mutex(
756
674
/*===============*/
757
 
        const buf_page_t*       bpage)  /*!< in: pointer to control block */
 
675
                                        /* out: pointer to mutex
 
676
                                        protecting bpage */
 
677
        const buf_page_t*       bpage)  /* in: pointer to control block */
758
678
        __attribute__((pure));
759
679
 
760
 
/*********************************************************************//**
761
 
Get the flush type of a page.
762
 
@return flush type */
 
680
/*************************************************************************
 
681
Get the flush type of a page. */
763
682
UNIV_INLINE
764
683
enum buf_flush
765
684
buf_page_get_flush_type(
766
685
/*====================*/
767
 
        const buf_page_t*       bpage)  /*!< in: buffer page */
 
686
                                        /* out: flush type */
 
687
        const buf_page_t*       bpage)  /* in: buffer page */
768
688
        __attribute__((pure));
769
 
/*********************************************************************//**
 
689
/*************************************************************************
770
690
Set the flush type of a page. */
771
691
UNIV_INLINE
772
692
void
773
693
buf_page_set_flush_type(
774
694
/*====================*/
775
 
        buf_page_t*     bpage,          /*!< in: buffer page */
776
 
        enum buf_flush  flush_type);    /*!< in: flush type */
777
 
/*********************************************************************//**
 
695
        buf_page_t*     bpage,          /* in: buffer page */
 
696
        enum buf_flush  flush_type);    /* in: flush type */
 
697
/*************************************************************************
778
698
Map a block to a file page. */
779
699
UNIV_INLINE
780
700
void
781
701
buf_block_set_file_page(
782
702
/*====================*/
783
 
        buf_block_t*            block,  /*!< in/out: pointer to control block */
784
 
        ulint                   space,  /*!< in: tablespace id */
785
 
        ulint                   page_no);/*!< in: page number */
786
 
/*********************************************************************//**
787
 
Gets the io_fix state of a block.
788
 
@return io_fix state */
 
703
        buf_block_t*            block,  /* in/out: pointer to control block */
 
704
        ulint                   space,  /* in: tablespace id */
 
705
        ulint                   page_no);/* in: page number */
 
706
/*************************************************************************
 
707
Gets the io_fix state of a block. */
789
708
UNIV_INLINE
790
709
enum buf_io_fix
791
710
buf_page_get_io_fix(
792
711
/*================*/
793
 
        const buf_page_t*       bpage)  /*!< in: pointer to the control block */
 
712
                                        /* out: io_fix state */
 
713
        const buf_page_t*       bpage)  /* in: pointer to the control block */
794
714
        __attribute__((pure));
795
 
/*********************************************************************//**
796
 
Gets the io_fix state of a block.
797
 
@return io_fix state */
 
715
/*************************************************************************
 
716
Gets the io_fix state of a block. */
798
717
UNIV_INLINE
799
718
enum buf_io_fix
800
719
buf_block_get_io_fix(
801
720
/*================*/
802
 
        const buf_block_t*      block)  /*!< in: pointer to the control block */
 
721
                                        /* out: io_fix state */
 
722
        const buf_block_t*      block)  /* in: pointer to the control block */
803
723
        __attribute__((pure));
804
 
/*********************************************************************//**
 
724
/*************************************************************************
805
725
Sets the io_fix state of a block. */
806
726
UNIV_INLINE
807
727
void
808
728
buf_page_set_io_fix(
809
729
/*================*/
810
 
        buf_page_t*     bpage,  /*!< in/out: control block */
811
 
        enum buf_io_fix io_fix);/*!< in: io_fix state */
812
 
/*********************************************************************//**
 
730
        buf_page_t*     bpage,  /* in/out: control block */
 
731
        enum buf_io_fix io_fix);/* in: io_fix state */
 
732
/*************************************************************************
813
733
Sets the io_fix state of a block. */
814
734
UNIV_INLINE
815
735
void
816
736
buf_block_set_io_fix(
817
737
/*=================*/
818
 
        buf_block_t*    block,  /*!< in/out: control block */
819
 
        enum buf_io_fix io_fix);/*!< in: io_fix state */
 
738
        buf_block_t*    block,  /* in/out: control block */
 
739
        enum buf_io_fix io_fix);/* in: io_fix state */
820
740
 
821
 
/********************************************************************//**
 
741
/************************************************************************
822
742
Determine if a buffer block can be relocated in memory.  The block
823
743
can be dirty, but it must not be I/O-fixed or bufferfixed. */
824
744
UNIV_INLINE
825
745
ibool
826
746
buf_page_can_relocate(
827
747
/*==================*/
828
 
        const buf_page_t*       bpage)  /*!< control block being relocated */
 
748
        const buf_page_t*       bpage)  /* control block being relocated */
829
749
        __attribute__((pure));
830
750
 
831
 
/*********************************************************************//**
832
 
Determine if a block has been flagged old.
833
 
@return TRUE if old */
 
751
/*************************************************************************
 
752
Determine if a block has been flagged old. */
834
753
UNIV_INLINE
835
754
ibool
836
755
buf_page_is_old(
837
756
/*============*/
838
 
        const buf_page_t*       bpage)  /*!< in: control block */
 
757
                                        /* out: TRUE if old */
 
758
        const buf_page_t*       bpage)  /* in: control block */
839
759
        __attribute__((pure));
840
 
/*********************************************************************//**
 
760
/*************************************************************************
841
761
Flag a block old. */
842
762
UNIV_INLINE
843
763
void
844
764
buf_page_set_old(
845
765
/*=============*/
846
 
        buf_page_t*     bpage,  /*!< in/out: control block */
847
 
        ibool           old);   /*!< in: old */
848
 
/*********************************************************************//**
849
 
Determine the time of first access of a block in the buffer pool.
850
 
@return ut_time_ms() at the time of first access, 0 if not accessed */
 
766
        buf_page_t*     bpage,  /* in/out: control block */
 
767
        ibool           old);   /* in: old */
 
768
/*************************************************************************
 
769
Determine if a block has been accessed in the buffer pool. */
851
770
UNIV_INLINE
852
 
unsigned
 
771
ibool
853
772
buf_page_is_accessed(
854
773
/*=================*/
855
 
        const buf_page_t*       bpage)  /*!< in: control block */
856
 
        __attribute__((nonnull, pure));
857
 
/*********************************************************************//**
 
774
                                        /* out: TRUE if accessed */
 
775
        const buf_page_t*       bpage)  /* in: control block */
 
776
        __attribute__((pure));
 
777
/*************************************************************************
858
778
Flag a block accessed. */
859
779
UNIV_INLINE
860
780
void
861
781
buf_page_set_accessed(
862
782
/*==================*/
863
 
        buf_page_t*     bpage,          /*!< in/out: control block */
864
 
        ulint           time_ms)        /*!< in: ut_time_ms() */
865
 
        __attribute__((nonnull));
866
 
/*********************************************************************//**
 
783
        buf_page_t*     bpage,          /* in/out: control block */
 
784
        ibool           accessed);      /* in: accessed */
 
785
/*************************************************************************
867
786
Gets the buf_block_t handle of a buffered file block if an uncompressed
868
 
page frame exists, or NULL. Note: even though bpage is not declared a
869
 
const we don't update its value. It is safe to make this pure.
870
 
@return control block, or NULL */
 
787
page frame exists, or NULL. */
871
788
UNIV_INLINE
872
789
buf_block_t*
873
790
buf_page_get_block(
874
791
/*===============*/
875
 
        buf_page_t*     bpage)  /*!< in: control block, or NULL */
 
792
                                /* out: control block, or NULL */
 
793
        buf_page_t*     bpage)  /* in: control block, or NULL */
876
794
        __attribute__((pure));
877
 
#endif /* !UNIV_HOTBACKUP */
878
795
#ifdef UNIV_DEBUG
879
 
/*********************************************************************//**
880
 
Gets a pointer to the memory frame of a block.
881
 
@return pointer to the frame */
 
796
/*************************************************************************
 
797
Gets a pointer to the memory frame of a block. */
882
798
UNIV_INLINE
883
799
buf_frame_t*
884
800
buf_block_get_frame(
885
801
/*================*/
886
 
        const buf_block_t*      block)  /*!< in: pointer to the control block */
 
802
                                        /* out: pointer to the frame */
 
803
        const buf_block_t*      block)  /* in: pointer to the control block */
887
804
        __attribute__((pure));
888
805
#else /* UNIV_DEBUG */
889
806
# define buf_block_get_frame(block) (block)->frame
890
807
#endif /* UNIV_DEBUG */
891
 
/*********************************************************************//**
892
 
Gets the space id of a block.
893
 
@return space id */
 
808
/*************************************************************************
 
809
Gets the space id of a block. */
894
810
UNIV_INLINE
895
811
ulint
896
812
buf_page_get_space(
897
813
/*===============*/
898
 
        const buf_page_t*       bpage)  /*!< in: pointer to the control block */
 
814
                                        /* out: space id */
 
815
        const buf_page_t*       bpage)  /* in: pointer to the control block */
899
816
        __attribute__((pure));
900
 
/*********************************************************************//**
901
 
Gets the space id of a block.
902
 
@return space id */
 
817
/*************************************************************************
 
818
Gets the space id of a block. */
903
819
UNIV_INLINE
904
820
ulint
905
821
buf_block_get_space(
906
822
/*================*/
907
 
        const buf_block_t*      block)  /*!< in: pointer to the control block */
 
823
                                        /* out: space id */
 
824
        const buf_block_t*      block)  /* in: pointer to the control block */
908
825
        __attribute__((pure));
909
 
/*********************************************************************//**
910
 
Gets the page number of a block.
911
 
@return page number */
 
826
/*************************************************************************
 
827
Gets the page number of a block. */
912
828
UNIV_INLINE
913
829
ulint
914
830
buf_page_get_page_no(
915
831
/*=================*/
916
 
        const buf_page_t*       bpage)  /*!< in: pointer to the control block */
 
832
                                        /* out: page number */
 
833
        const buf_page_t*       bpage)  /* in: pointer to the control block */
917
834
        __attribute__((pure));
918
 
/*********************************************************************//**
919
 
Gets the page number of a block.
920
 
@return page number */
 
835
/*************************************************************************
 
836
Gets the page number of a block. */
921
837
UNIV_INLINE
922
838
ulint
923
839
buf_block_get_page_no(
924
840
/*==================*/
925
 
        const buf_block_t*      block)  /*!< in: pointer to the control block */
 
841
                                        /* out: page number */
 
842
        const buf_block_t*      block)  /* in: pointer to the control block */
926
843
        __attribute__((pure));
927
 
/*********************************************************************//**
928
 
Gets the compressed page size of a block.
929
 
@return compressed page size, or 0 */
 
844
/*************************************************************************
 
845
Gets the compressed page size of a block. */
930
846
UNIV_INLINE
931
847
ulint
932
848
buf_page_get_zip_size(
933
849
/*==================*/
934
 
        const buf_page_t*       bpage)  /*!< in: pointer to the control block */
 
850
                                        /* out: compressed page size, or 0 */
 
851
        const buf_page_t*       bpage)  /* in: pointer to the control block */
935
852
        __attribute__((pure));
936
 
/*********************************************************************//**
937
 
Gets the compressed page size of a block.
938
 
@return compressed page size, or 0 */
 
853
/*************************************************************************
 
854
Gets the compressed page size of a block. */
939
855
UNIV_INLINE
940
856
ulint
941
857
buf_block_get_zip_size(
942
858
/*===================*/
943
 
        const buf_block_t*      block)  /*!< in: pointer to the control block */
 
859
                                        /* out: compressed page size, or 0 */
 
860
        const buf_block_t*      block)  /* in: pointer to the control block */
944
861
        __attribute__((pure));
945
 
/*********************************************************************//**
 
862
/*************************************************************************
946
863
Gets the compressed page descriptor corresponding to an uncompressed page
947
864
if applicable. */
948
865
#define buf_block_get_page_zip(block) \
949
866
        (UNIV_LIKELY_NULL((block)->page.zip.data) ? &(block)->page.zip : NULL)
950
 
#ifndef UNIV_HOTBACKUP
951
 
/*******************************************************************//**
952
 
Gets the block to whose frame the pointer is pointing to.
953
 
@return pointer to block, never NULL */
954
 
UNIV_INTERN
955
 
buf_block_t*
 
867
#if defined UNIV_DEBUG || defined UNIV_ZIP_DEBUG
 
868
/***********************************************************************
 
869
Gets the block to whose frame the pointer is pointing to. */
 
870
UNIV_INLINE
 
871
const buf_block_t*
956
872
buf_block_align(
957
873
/*============*/
958
 
        const byte*     ptr);   /*!< in: pointer to a frame */
959
 
/********************************************************************//**
960
 
Find out if a pointer belongs to a buf_block_t. It can be a pointer to
961
 
the buf_block_t itself or a member of it
962
 
@return TRUE if ptr belongs to a buf_block_t struct */
963
 
UNIV_INTERN
964
 
ibool
965
 
buf_pointer_is_block_field(
966
 
/*=======================*/
967
 
        const void*             ptr);   /*!< in: pointer not
968
 
                                        dereferenced */
969
 
/** Find out if a pointer corresponds to a buf_block_t::mutex.
970
 
@param m        in: mutex candidate
971
 
@return         TRUE if m is a buf_block_t::mutex */
972
 
#define buf_pool_is_block_mutex(m)                      \
973
 
        buf_pointer_is_block_field((const void*)(m))
974
 
/** Find out if a pointer corresponds to a buf_block_t::lock.
975
 
@param l        in: rw-lock candidate
976
 
@return         TRUE if l is a buf_block_t::lock */
977
 
#define buf_pool_is_block_lock(l)                       \
978
 
        buf_pointer_is_block_field((const void*)(l))
979
 
 
980
 
#if defined UNIV_DEBUG || defined UNIV_ZIP_DEBUG
981
 
/*********************************************************************//**
 
874
                                /* out: pointer to block */
 
875
        const byte*     ptr);   /* in: pointer to a frame */
 
876
/*************************************************************************
982
877
Gets the compressed page descriptor corresponding to an uncompressed page
983
 
if applicable.
984
 
@return compressed page descriptor, or NULL */
 
878
if applicable. */
985
879
UNIV_INLINE
986
880
const page_zip_des_t*
987
881
buf_frame_get_page_zip(
988
882
/*===================*/
989
 
        const byte*     ptr);   /*!< in: pointer to the page */
 
883
                                /* out: compressed page descriptor, or NULL */
 
884
        const byte*     ptr);   /* in: pointer to the page */
990
885
#endif /* UNIV_DEBUG || UNIV_ZIP_DEBUG */
991
 
/********************************************************************//**
 
886
/************************************************************************
 
887
This function is used to get info if there is an io operation
 
888
going on on a buffer page. */
 
889
UNIV_INLINE
 
890
ibool
 
891
buf_page_io_query(
 
892
/*==============*/
 
893
                                /* out: TRUE if io going on */
 
894
        buf_page_t*     bpage); /* in: pool block, must be bufferfixed */
 
895
/************************************************************************
992
896
Function which inits a page for read to the buffer buf_pool. If the page is
993
897
(1) already in buf_pool, or
994
898
(2) if we specify to read only ibuf pages and the page is not an ibuf page, or
996
900
then this function does nothing.
997
901
Sets the io_fix flag to BUF_IO_READ and sets a non-recursive exclusive lock
998
902
on the buffer frame. The io-handler must take care that the flag is cleared
999
 
and the lock released later.
1000
 
@return pointer to the block or NULL */
 
903
and the lock released later. */
1001
904
UNIV_INTERN
1002
905
buf_page_t*
1003
906
buf_page_init_for_read(
1004
907
/*===================*/
1005
 
        ulint*          err,    /*!< out: DB_SUCCESS or DB_TABLESPACE_DELETED */
1006
 
        ulint           mode,   /*!< in: BUF_READ_IBUF_PAGES_ONLY, ... */
1007
 
        ulint           space,  /*!< in: space id */
1008
 
        ulint           zip_size,/*!< in: compressed page size, or 0 */
1009
 
        ibool           unzip,  /*!< in: TRUE=request uncompressed page */
1010
 
        ib_int64_t      tablespace_version,/*!< in: prevents reading from a wrong
 
908
                                /* out: pointer to the block or NULL */
 
909
        ulint*          err,    /* out: DB_SUCCESS or DB_TABLESPACE_DELETED */
 
910
        ulint           mode,   /* in: BUF_READ_IBUF_PAGES_ONLY, ... */
 
911
        ulint           space,  /* in: space id */
 
912
        ulint           zip_size,/* in: compressed page size, or 0 */
 
913
        ibool           unzip,  /* in: TRUE=request uncompressed page */
 
914
        ib_int64_t      tablespace_version,/* in: prevents reading from a wrong
1011
915
                                version of the tablespace in case we have done
1012
916
                                DISCARD + IMPORT */
1013
 
        ulint           offset);/*!< in: page number */
1014
 
/********************************************************************//**
 
917
        ulint           offset);/* in: page number */
 
918
/************************************************************************
1015
919
Completes an asynchronous read or write request of a file page to or from
1016
920
the buffer pool. */
1017
921
UNIV_INTERN
1018
922
void
1019
923
buf_page_io_complete(
1020
924
/*=================*/
1021
 
        buf_page_t*     bpage); /*!< in: pointer to the block in question */
1022
 
/********************************************************************//**
 
925
        buf_page_t*     bpage); /* in: pointer to the block in question */
 
926
/************************************************************************
1023
927
Calculates a folded value of a file page address to use in the page hash
1024
 
table.
1025
 
@return the folded value */
 
928
table. */
1026
929
UNIV_INLINE
1027
930
ulint
1028
931
buf_page_address_fold(
1029
932
/*==================*/
1030
 
        ulint   space,  /*!< in: space id */
1031
 
        ulint   offset) /*!< in: offset of the page within space */
1032
 
        __attribute__((const));
1033
 
/********************************************************************//**
1034
 
Calculates the index of a buffer pool to the buf_pool[] array.
1035
 
@return the position of the buffer pool in buf_pool[] */
1036
 
UNIV_INLINE
1037
 
ulint
1038
 
buf_pool_index(
1039
 
/*===========*/
1040
 
        const buf_pool_t*       buf_pool)       /*!< in: buffer pool */
1041
 
        __attribute__((nonnull, const));
1042
 
/******************************************************************//**
1043
 
Returns the buffer pool instance given a page instance
1044
 
@return buf_pool */
1045
 
UNIV_INLINE
1046
 
buf_pool_t*
1047
 
buf_pool_from_bpage(
1048
 
/*================*/
1049
 
        const buf_page_t*       bpage); /*!< in: buffer pool page */
1050
 
/******************************************************************//**
1051
 
Returns the buffer pool instance given a block instance
1052
 
@return buf_pool */
1053
 
UNIV_INLINE
1054
 
buf_pool_t*
1055
 
buf_pool_from_block(
1056
 
/*================*/
1057
 
        const buf_block_t*      block); /*!< in: block */
1058
 
/******************************************************************//**
1059
 
Returns the buffer pool instance given space and offset of page
1060
 
@return buffer pool */
1061
 
UNIV_INLINE
1062
 
buf_pool_t*
1063
 
buf_pool_get(
1064
 
/*==========*/
1065
 
        ulint   space,  /*!< in: space id */
1066
 
        ulint   offset);/*!< in: offset of the page within space */
1067
 
/******************************************************************//**
1068
 
Returns the buffer pool instance given its array index
1069
 
@return buffer pool */
1070
 
UNIV_INLINE
1071
 
buf_pool_t*
1072
 
buf_pool_from_array(
1073
 
/*================*/
1074
 
        ulint   index);         /*!< in: array index to get
1075
 
                                buffer pool instance from */
1076
 
/******************************************************************//**
1077
 
Returns the control block of a file page, NULL if not found.
1078
 
@return block, NULL if not found */
1079
 
UNIV_INLINE
1080
 
buf_page_t*
1081
 
buf_page_hash_get_low(
1082
 
/*==================*/
1083
 
        buf_pool_t*     buf_pool,       /*!< buffer pool instance */
1084
 
        ulint           space,          /*!< in: space id */
1085
 
        ulint           offset,         /*!< in: offset of the page
1086
 
                                        within space */
1087
 
        ulint           fold);          /*!< in: buf_page_address_fold(
1088
 
                                        space, offset) */
1089
 
/******************************************************************//**
1090
 
Returns the control block of a file page, NULL if not found.
1091
 
@return block, NULL if not found or not a real control block */
 
933
                        /* out: the folded value */
 
934
        ulint   space,  /* in: space id */
 
935
        ulint   offset) /* in: offset of the page within space */
 
936
        __attribute__((__const__));
 
937
/**********************************************************************
 
938
Returns the control block of a file page, NULL if not found. */
1092
939
UNIV_INLINE
1093
940
buf_page_t*
1094
941
buf_page_hash_get(
1095
942
/*==============*/
1096
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
1097
 
        ulint           space,          /*!< in: space id */
1098
 
        ulint           offset);        /*!< in: offset of the page
1099
 
                                        within space */
1100
 
/******************************************************************//**
 
943
                        /* out: block, NULL if not found */
 
944
        ulint   space,  /* in: space id */
 
945
        ulint   offset);/* in: offset of the page within space */
 
946
/**********************************************************************
1101
947
Returns the control block of a file page, NULL if not found
1102
 
or an uncompressed page frame does not exist.
1103
 
@return block, NULL if not found */
 
948
or an uncompressed page frame does not exist. */
1104
949
UNIV_INLINE
1105
950
buf_block_t*
1106
951
buf_block_hash_get(
1107
952
/*===============*/
1108
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
1109
 
        ulint           space,          /*!< in: space id */
1110
 
        ulint           offset);        /*!< in: offset of the page
1111
 
                                        within space */
1112
 
/*********************************************************************//**
1113
 
Gets the current length of the free list of buffer blocks.
1114
 
@return length of the free list */
 
953
                        /* out: block, NULL if not found */
 
954
        ulint   space,  /* in: space id */
 
955
        ulint   offset);/* in: offset of the page within space */
 
956
/***********************************************************************
 
957
Increments the pool clock by one and returns its new value. Remember that
 
958
in the 32 bit version the clock wraps around at 4 billion! */
 
959
UNIV_INLINE
 
960
ulint
 
961
buf_pool_clock_tic(void);
 
962
/*====================*/
 
963
                        /* out: new clock value */
 
964
/*************************************************************************
 
965
Gets the current length of the free list of buffer blocks. */
1115
966
UNIV_INTERN
1116
967
ulint
1117
968
buf_get_free_list_len(void);
1118
969
/*=======================*/
1119
970
 
1120
 
/********************************************************************
1121
 
Determine if a block is a sentinel for a buffer pool watch.
1122
 
@return TRUE if a sentinel for a buffer pool watch, FALSE if not */
1123
 
UNIV_INTERN
1124
 
ibool
1125
 
buf_pool_watch_is_sentinel(
1126
 
/*=======================*/
1127
 
        buf_pool_t*             buf_pool,       /*!< buffer pool instance */
1128
 
        const buf_page_t*       bpage)          /*!< in: block */
1129
 
  UNIV_WARN_UNUSED_RESULT;
1130
 
/****************************************************************//**
1131
 
Add watch for the given page to be read in. Caller must have the buffer pool
1132
 
@return NULL if watch set, block if the page is in the buffer pool */
1133
 
UNIV_INTERN
1134
 
buf_page_t*
1135
 
buf_pool_watch_set(
1136
 
/*===============*/
1137
 
        ulint   space,  /*!< in: space id */
1138
 
        ulint   offset, /*!< in: page number */
1139
 
        ulint   fold)   /*!< in: buf_page_address_fold(space, offset) */
1140
 
  UNIV_WARN_UNUSED_RESULT;
1141
 
/****************************************************************//**
1142
 
Stop watching if the page has been read in.
1143
 
buf_pool_watch_set(space,offset) must have returned NULL before. */
1144
 
UNIV_INTERN
1145
 
void
1146
 
buf_pool_watch_unset(
1147
 
/*=================*/
1148
 
        ulint   space,  /*!< in: space id */
1149
 
        ulint   offset);/*!< in: page number */
1150
 
/****************************************************************//**
1151
 
Check if the page has been read in.
1152
 
This may only be called after buf_pool_watch_set(space,offset)
1153
 
has returned NULL and before invoking buf_pool_watch_unset(space,offset).
1154
 
@return FALSE if the given page was not read in, TRUE if it was */
1155
 
UNIV_INTERN
1156
 
ibool
1157
 
buf_pool_watch_occurred(
1158
 
/*====================*/
1159
 
        ulint   space,  /*!< in: space id */
1160
 
        ulint   offset) /*!< in: page number */
1161
 
  UNIV_WARN_UNUSED_RESULT;
1162
 
/********************************************************************//**
1163
 
Get total buffer pool statistics. */
1164
 
UNIV_INTERN
1165
 
void
1166
 
buf_get_total_list_len(
1167
 
/*===================*/
1168
 
        ulint*          LRU_len,        /*!< out: length of all LRU lists */
1169
 
        ulint*          free_len,       /*!< out: length of all free lists */
1170
 
        ulint*          flush_list_len);/*!< out: length of all flush lists */
1171
 
/********************************************************************//**
1172
 
Get total buffer pool statistics. */
1173
 
UNIV_INTERN
1174
 
void
1175
 
buf_get_total_stat(
1176
 
/*===============*/
1177
 
        buf_pool_stat_t*tot_stat);      /*!< out: buffer pool stats */
1178
 
 
1179
 
#endif /* !UNIV_HOTBACKUP */
1180
 
 
1181
 
/** The common buffer control block structure
 
971
 
 
972
 
 
973
/* The common buffer control block structure
1182
974
for compressed and uncompressed frames */
1183
975
 
1184
976
struct buf_page_struct{
1185
 
        /** @name General fields
1186
 
        None of these bit-fields must be modified without holding
1187
 
        buf_page_get_mutex() [buf_block_struct::mutex or
1188
 
        buf_pool->zip_mutex], since they can be stored in the same
1189
 
        machine word.  Some of these fields are additionally protected
1190
 
        by buf_pool->mutex. */
1191
 
        /* @{ */
1192
 
 
1193
 
        unsigned        space:32;       /*!< tablespace id; also protected
1194
 
                                        by buf_pool->mutex. */
1195
 
        unsigned        offset:32;      /*!< page number; also protected
1196
 
                                        by buf_pool->mutex. */
1197
 
 
1198
 
        unsigned        state:3;        /*!< state of the control block; also
1199
 
                                        protected by buf_pool->mutex.
 
977
        /* None of the following bit-fields must be modified without
 
978
        holding buf_page_get_mutex() [block->mutex or buf_pool_zip_mutex],
 
979
        since they can be stored in the same machine word.  Some of them are
 
980
        additionally protected by buf_pool_mutex. */
 
981
 
 
982
        unsigned        space:32;       /* tablespace id */
 
983
        unsigned        offset:32;      /* page number */
 
984
 
 
985
        unsigned        state:3;        /* state of the control block
 
986
                                        (@see enum buf_page_state); also
 
987
                                        protected by buf_pool_mutex.
1200
988
                                        State transitions from
1201
989
                                        BUF_BLOCK_READY_FOR_USE to
1202
990
                                        BUF_BLOCK_MEMORY need not be
1203
 
                                        protected by buf_page_get_mutex().
1204
 
                                        @see enum buf_page_state */
1205
 
#ifndef UNIV_HOTBACKUP
1206
 
        unsigned        flush_type:2;   /*!< if this block is currently being
 
991
                                        protected by buf_page_get_mutex(). */
 
992
        unsigned        flush_type:2;   /* if this block is currently being
1207
993
                                        flushed to disk, this tells the
1208
 
                                        flush_type.
1209
 
                                        @see enum buf_flush */
1210
 
        unsigned        io_fix:2;       /*!< type of pending I/O operation;
1211
 
                                        also protected by buf_pool->mutex
1212
 
                                        @see enum buf_io_fix */
1213
 
        unsigned        buf_fix_count:19;/*!< count of how manyfold this block
 
994
                                        flush_type (@see enum buf_flush) */
 
995
        unsigned        accessed:1;     /* TRUE if the page has been accessed
 
996
                                        while in the buffer pool: read-ahead
 
997
                                        may read in pages which have not been
 
998
                                        accessed yet; a thread is allowed to
 
999
                                        read this for heuristic purposes
 
1000
                                        without holding any mutex or latch */
 
1001
        unsigned        io_fix:2;       /* type of pending I/O operation
 
1002
                                        (@see enum buf_io_fix); also
 
1003
                                        protected by buf_pool_mutex */
 
1004
        unsigned        buf_fix_count:24;/* count of how manyfold this block
1214
1005
                                        is currently bufferfixed */
1215
 
        unsigned        buf_pool_index:6;/*!< index number of the buffer pool
1216
 
                                        that this block belongs to */
1217
 
# if MAX_BUFFER_POOLS > 64
1218
 
#  error "MAX_BUFFER_POOLS > 64; redefine buf_pool_index:6"
1219
 
# endif
1220
 
        /* @} */
1221
 
#endif /* !UNIV_HOTBACKUP */
1222
 
        page_zip_des_t  zip;            /*!< compressed page; zip.data
 
1006
 
 
1007
        page_zip_des_t  zip;            /* compressed page; zip.data
1223
1008
                                        (but not the data it points to) is
1224
 
                                        also protected by buf_pool->mutex;
1225
 
                                        state == BUF_BLOCK_ZIP_PAGE and
1226
 
                                        zip.data == NULL means an active
1227
 
                                        buf_pool->watch */
1228
 
#ifndef UNIV_HOTBACKUP
1229
 
        buf_page_t*     hash;           /*!< node used in chaining to
 
1009
                                        also protected by buf_pool_mutex */
 
1010
        buf_page_t*     hash;           /* node used in chaining to
1230
1011
                                        buf_pool->page_hash or
1231
1012
                                        buf_pool->zip_hash */
1232
1013
#ifdef UNIV_DEBUG
1233
 
        ibool           in_page_hash;   /*!< TRUE if in buf_pool->page_hash */
1234
 
        ibool           in_zip_hash;    /*!< TRUE if in buf_pool->zip_hash */
 
1014
        ibool           in_page_hash;   /* TRUE if in buf_pool->page_hash */
 
1015
        ibool           in_zip_hash;    /* TRUE if in buf_pool->zip_hash */
1235
1016
#endif /* UNIV_DEBUG */
1236
1017
 
1237
 
        /** @name Page flushing fields
1238
 
        All these are protected by buf_pool->mutex. */
1239
 
        /* @{ */
 
1018
        /* 2. Page flushing fields; protected by buf_pool_mutex */
1240
1019
 
1241
1020
        UT_LIST_NODE_T(buf_page_t) list;
1242
 
                                        /*!< based on state, this is a
1243
 
                                        list node, protected either by
1244
 
                                        buf_pool->mutex or by
1245
 
                                        buf_pool->flush_list_mutex,
1246
 
                                        in one of the following lists in
1247
 
                                        buf_pool:
1248
 
 
1249
 
                                        - BUF_BLOCK_NOT_USED:   free
1250
 
                                        - BUF_BLOCK_FILE_PAGE:  flush_list
1251
 
                                        - BUF_BLOCK_ZIP_DIRTY:  flush_list
1252
 
                                        - BUF_BLOCK_ZIP_PAGE:   zip_clean
1253
 
                                        - BUF_BLOCK_ZIP_FREE:   zip_free[]
1254
 
 
1255
 
                                        If bpage is part of flush_list
1256
 
                                        then the node pointers are
1257
 
                                        covered by buf_pool->flush_list_mutex.
1258
 
                                        Otherwise these pointers are
1259
 
                                        protected by buf_pool->mutex.
1260
 
 
1261
 
                                        The contents of the list node
1262
 
                                        is undefined if !in_flush_list
1263
 
                                        && state == BUF_BLOCK_FILE_PAGE,
1264
 
                                        or if state is one of
1265
 
                                        BUF_BLOCK_MEMORY,
1266
 
                                        BUF_BLOCK_REMOVE_HASH or
1267
 
                                        BUF_BLOCK_READY_IN_USE. */
1268
 
 
 
1021
                                        /* based on state, this is a list
 
1022
                                        node in one of the following lists
 
1023
                                        in buf_pool:
 
1024
 
 
1025
                                        BUF_BLOCK_NOT_USED:     free
 
1026
                                        BUF_BLOCK_FILE_PAGE:    flush_list
 
1027
                                        BUF_BLOCK_ZIP_DIRTY:    flush_list
 
1028
                                        BUF_BLOCK_ZIP_PAGE:     zip_clean
 
1029
                                        BUF_BLOCK_ZIP_FREE:     zip_free[] */
1269
1030
#ifdef UNIV_DEBUG
1270
 
        ibool           in_flush_list;  /*!< TRUE if in buf_pool->flush_list;
1271
 
                                        when buf_pool->flush_list_mutex is
1272
 
                                        free, the following should hold:
1273
 
                                        in_flush_list
 
1031
        ibool           in_flush_list;  /* TRUE if in buf_pool->flush_list;
 
1032
                                        when buf_pool_mutex is free, the
 
1033
                                        following should hold: in_flush_list
1274
1034
                                        == (state == BUF_BLOCK_FILE_PAGE
1275
 
                                            || state == BUF_BLOCK_ZIP_DIRTY)
1276
 
                                        Writes to this field must be
1277
 
                                        covered by both block->mutex
1278
 
                                        and buf_pool->flush_list_mutex. Hence
1279
 
                                        reads can happen while holding
1280
 
                                        any one of the two mutexes */
1281
 
        ibool           in_free_list;   /*!< TRUE if in buf_pool->free; when
1282
 
                                        buf_pool->mutex is free, the following
 
1035
                                            || state == BUF_BLOCK_ZIP_DIRTY) */
 
1036
        ibool           in_free_list;   /* TRUE if in buf_pool->free; when
 
1037
                                        buf_pool_mutex is free, the following
1283
1038
                                        should hold: in_free_list
1284
1039
                                        == (state == BUF_BLOCK_NOT_USED) */
1285
1040
#endif /* UNIV_DEBUG */
1286
1041
        ib_uint64_t     newest_modification;
1287
 
                                        /*!< log sequence number of
1288
 
                                        the youngest modification to
1289
 
                                        this block, zero if not
1290
 
                                        modified. Protected by block
1291
 
                                        mutex */
 
1042
                                        /* log sequence number of the youngest
 
1043
                                        modification to this block, zero if
 
1044
                                        not modified */
1292
1045
        ib_uint64_t     oldest_modification;
1293
 
                                        /*!< log sequence number of
1294
 
                                        the START of the log entry
1295
 
                                        written of the oldest
1296
 
                                        modification to this block
1297
 
                                        which has not yet been flushed
1298
 
                                        on disk; zero if all
1299
 
                                        modifications are on disk.
1300
 
                                        Writes to this field must be
1301
 
                                        covered by both block->mutex
1302
 
                                        and buf_pool->flush_list_mutex. Hence
1303
 
                                        reads can happen while holding
1304
 
                                        any one of the two mutexes */
1305
 
        /* @} */
1306
 
        /** @name LRU replacement algorithm fields
1307
 
        These fields are protected by buf_pool->mutex only (not
1308
 
        buf_pool->zip_mutex or buf_block_struct::mutex). */
1309
 
        /* @{ */
 
1046
                                        /* log sequence number of the START of
 
1047
                                        the log entry written of the oldest
 
1048
                                        modification to this block which has
 
1049
                                        not yet been flushed on disk; zero if
 
1050
                                        all modifications are on disk */
 
1051
 
 
1052
        /* 3. LRU replacement algorithm fields; protected by buf_pool_mutex */
1310
1053
 
1311
1054
        UT_LIST_NODE_T(buf_page_t) LRU;
1312
 
                                        /*!< node of the LRU list */
 
1055
                                        /* node of the LRU list */
1313
1056
#ifdef UNIV_DEBUG
1314
 
        ibool           in_LRU_list;    /*!< TRUE if the page is in
1315
 
                                        the LRU list; used in
1316
 
                                        debugging */
 
1057
        ibool           in_LRU_list;    /* TRUE if the page is in the LRU list;
 
1058
                                        used in debugging */
1317
1059
#endif /* UNIV_DEBUG */
1318
 
        unsigned        old:1;          /*!< TRUE if the block is in the old
1319
 
                                        blocks in buf_pool->LRU_old */
1320
 
        unsigned        freed_page_clock:31;/*!< the value of
1321
 
                                        buf_pool->freed_page_clock
1322
 
                                        when this block was the last
1323
 
                                        time put to the head of the
1324
 
                                        LRU list; a thread is allowed
1325
 
                                        to read this for heuristic
1326
 
                                        purposes without holding any
1327
 
                                        mutex or latch */
1328
 
        unsigned        access_time:32; /*!< time of first access, or
1329
 
                                        0 if the block was never accessed
1330
 
                                        in the buffer pool */
1331
 
        /* @} */
1332
 
# ifdef UNIV_DEBUG_FILE_ACCESSES
 
1060
        unsigned        old:1;          /* TRUE if the block is in the old
 
1061
                                        blocks in the LRU list */
 
1062
        unsigned        LRU_position:31;/* value which monotonically decreases
 
1063
                                        (or may stay constant if old==TRUE)
 
1064
                                        toward the end of the LRU list, if
 
1065
                                        buf_pool->ulint_clock has not wrapped
 
1066
                                        around: NOTE that this value can only
 
1067
                                        be used in heuristic algorithms,
 
1068
                                        because of the possibility of a
 
1069
                                        wrap-around! */
 
1070
        unsigned        freed_page_clock:32;/* the value of
 
1071
                                        buf_pool->freed_page_clock when this
 
1072
                                        block was the last time put to the
 
1073
                                        head of the LRU list; a thread is
 
1074
                                        allowed to read this for heuristic
 
1075
                                        purposes without holding any mutex or
 
1076
                                        latch */
 
1077
#ifdef UNIV_DEBUG_FILE_ACCESSES
1333
1078
        ibool           file_page_was_freed;
1334
 
                                        /*!< this is set to TRUE when fsp
 
1079
                                        /* this is set to TRUE when fsp
1335
1080
                                        frees a page in buffer pool */
1336
 
# endif /* UNIV_DEBUG_FILE_ACCESSES */
1337
 
#endif /* !UNIV_HOTBACKUP */
 
1081
#endif /* UNIV_DEBUG_FILE_ACCESSES */
1338
1082
};
1339
1083
 
1340
 
/** The buffer control block structure */
 
1084
/* The buffer control block structure */
1341
1085
 
1342
1086
struct buf_block_struct{
1343
1087
 
1344
 
        /** @name General fields */
1345
 
        /* @{ */
 
1088
        /* 1. General fields */
1346
1089
 
1347
 
        buf_page_t      page;           /*!< page information; this must
 
1090
        buf_page_t      page;           /* page information; this must
1348
1091
                                        be the first field, so that
1349
1092
                                        buf_pool->page_hash can point
1350
1093
                                        to buf_page_t or buf_block_t */
1351
 
        byte*           frame;          /*!< pointer to buffer frame which
1352
 
                                        is of size UNIV_PAGE_SIZE, and
1353
 
                                        aligned to an address divisible by
1354
 
                                        UNIV_PAGE_SIZE */
1355
 
#ifndef UNIV_HOTBACKUP
1356
1094
        UT_LIST_NODE_T(buf_block_t) unzip_LRU;
1357
 
                                        /*!< node of the decompressed LRU list;
 
1095
                                        /* node of the decompressed LRU list;
1358
1096
                                        a block is in the unzip_LRU list
1359
1097
                                        if page.state == BUF_BLOCK_FILE_PAGE
1360
1098
                                        and page.zip.data != NULL */
1361
1099
#ifdef UNIV_DEBUG
1362
 
        ibool           in_unzip_LRU_list;/*!< TRUE if the page is in the
 
1100
        ibool           in_unzip_LRU_list;/* TRUE if the page is in the
1363
1101
                                        decompressed LRU list;
1364
1102
                                        used in debugging */
1365
1103
#endif /* UNIV_DEBUG */
1366
 
        mutex_t         mutex;          /*!< mutex protecting this block:
 
1104
        byte*           frame;          /* pointer to buffer frame which
 
1105
                                        is of size UNIV_PAGE_SIZE, and
 
1106
                                        aligned to an address divisible by
 
1107
                                        UNIV_PAGE_SIZE */
 
1108
        mutex_t         mutex;          /* mutex protecting this block:
1367
1109
                                        state (also protected by the buffer
1368
1110
                                        pool mutex), io_fix, buf_fix_count,
1369
1111
                                        and accessed; we introduce this new
1370
1112
                                        mutex in InnoDB-5.1 to relieve
1371
1113
                                        contention on the buffer pool mutex */
1372
 
        rw_lock_t       lock;           /*!< read-write lock of the buffer
 
1114
        rw_lock_t       lock;           /* read-write lock of the buffer
1373
1115
                                        frame */
1374
 
        unsigned        lock_hash_val:32;/*!< hashed value of the page address
1375
 
                                        in the record lock hash table;
1376
 
                                        protected by buf_block_t::lock
1377
 
                                        (or buf_block_t::mutex, buf_pool->mutex
1378
 
                                        in buf_page_get_gen(),
1379
 
                                        buf_page_init_for_read()
1380
 
                                        and buf_page_create()) */
1381
 
        ibool           check_index_page_at_flush;
1382
 
                                        /*!< TRUE if we know that this is
 
1116
        unsigned        lock_hash_val:32;/* hashed value of the page address
 
1117
                                        in the record lock hash table */
 
1118
        unsigned        check_index_page_at_flush:1;
 
1119
                                        /* TRUE if we know that this is
1383
1120
                                        an index page, and want the database
1384
1121
                                        to check its consistency before flush;
1385
1122
                                        note that there may be pages in the
1386
1123
                                        buffer pool which are index pages,
1387
1124
                                        but this flag is not set because
1388
 
                                        we do not keep track of all pages;
1389
 
                                        NOT protected by any mutex */
1390
 
        /* @} */
1391
 
        /** @name Optimistic search field */
1392
 
        /* @{ */
1393
 
 
1394
 
        ib_uint64_t     modify_clock;   /*!< this clock is incremented every
 
1125
                                        we do not keep track of all pages */
 
1126
 
 
1127
        /* 2. Optimistic search field */
 
1128
 
 
1129
        ib_uint64_t     modify_clock;   /* this clock is incremented every
1395
1130
                                        time a pointer to a record on the
1396
1131
                                        page may become obsolete; this is
1397
1132
                                        used in the optimistic cursor
1402
1137
                                        pool mutex and the page is not
1403
1138
                                        bufferfixed, or (2) the thread has an
1404
1139
                                        x-latch on the block */
1405
 
        /* @} */
1406
 
        /** @name Hash search fields (unprotected)
1407
 
        NOTE that these fields are NOT protected by any semaphore! */
1408
 
        /* @{ */
1409
 
 
1410
 
        ulint           n_hash_helps;   /*!< counter which controls building
 
1140
 
 
1141
        /* 3. Hash search fields: NOTE that the first 4 fields are NOT
 
1142
        protected by any semaphore! */
 
1143
 
 
1144
        ulint           n_hash_helps;   /* counter which controls building
1411
1145
                                        of a new hash index for the page */
1412
 
        ulint           n_fields;       /*!< recommended prefix length for hash
 
1146
        ulint           n_fields;       /* recommended prefix length for hash
1413
1147
                                        search: number of full fields */
1414
 
        ulint           n_bytes;        /*!< recommended prefix: number of bytes
 
1148
        ulint           n_bytes;        /* recommended prefix: number of bytes
1415
1149
                                        in an incomplete field */
1416
 
        ibool           left_side;      /*!< TRUE or FALSE, depending on
 
1150
        ibool           left_side;      /* TRUE or FALSE, depending on
1417
1151
                                        whether the leftmost record of several
1418
1152
                                        records with the same prefix should be
1419
1153
                                        indexed in the hash index */
1420
 
        /* @} */
1421
1154
 
1422
 
        /** @name Hash search fields
1423
 
        These 6 fields may only be modified when we have
 
1155
        /* These 6 fields may only be modified when we have
1424
1156
        an x-latch on btr_search_latch AND
1425
 
        - we are holding an s-latch or x-latch on buf_block_struct::lock or
1426
 
        - we know that buf_block_struct::buf_fix_count == 0.
 
1157
        a) we are holding an s-latch or x-latch on block->lock or
 
1158
        b) we know that block->buf_fix_count == 0.
1427
1159
 
1428
1160
        An exception to this is when we init or create a page
1429
1161
        in the buffer pool in buf0buf.c. */
1430
1162
 
1431
 
        /* @{ */
1432
 
 
1433
 
#if defined UNIV_AHI_DEBUG || defined UNIV_DEBUG
1434
 
        ulint           n_pointers;     /*!< used in debugging: the number of
 
1163
#ifdef UNIV_DEBUG
 
1164
        ulint           n_pointers;     /* used in debugging: the number of
1435
1165
                                        pointers in the adaptive hash index
1436
1166
                                        pointing to this frame */
1437
 
#endif /* UNIV_AHI_DEBUG || UNIV_DEBUG */
1438
 
        unsigned        is_hashed:1;    /*!< TRUE if hash index has
1439
 
                                        already been built on this
1440
 
                                        page; note that it does not
1441
 
                                        guarantee that the index is
1442
 
                                        complete, though: there may
1443
 
                                        have been hash collisions,
1444
 
                                        record deletions, etc. */
1445
 
        unsigned        curr_n_fields:10;/*!< prefix length for hash indexing:
 
1167
#endif /* UNIV_DEBUG */
 
1168
        unsigned        is_hashed:1;    /* TRUE if hash index has already been
 
1169
                                        built on this page; note that it does
 
1170
                                        not guarantee that the index is
 
1171
                                        complete, though: there may have been
 
1172
                                        hash collisions, record deletions,
 
1173
                                        etc. */
 
1174
        unsigned        curr_n_fields:10;/* prefix length for hash indexing:
1446
1175
                                        number of full fields */
1447
 
        unsigned        curr_n_bytes:15;/*!< number of bytes in hash
1448
 
                                        indexing */
1449
 
        unsigned        curr_left_side:1;/*!< TRUE or FALSE in hash indexing */
1450
 
        dict_index_t*   index;          /*!< Index for which the adaptive
 
1176
        unsigned        curr_n_bytes:15;/* number of bytes in hash indexing */
 
1177
        unsigned        curr_left_side:1;/* TRUE or FALSE in hash indexing */
 
1178
        dict_index_t*   index;          /* Index for which the adaptive
1451
1179
                                        hash index has been created. */
1452
 
        /* @} */
1453
 
# ifdef UNIV_SYNC_DEBUG
1454
 
        /** @name Debug fields */
1455
 
        /* @{ */
1456
 
        rw_lock_t       debug_latch;    /*!< in the debug version, each thread
 
1180
        /* 4. Debug fields */
 
1181
#ifdef UNIV_SYNC_DEBUG
 
1182
        rw_lock_t       debug_latch;    /* in the debug version, each thread
1457
1183
                                        which bufferfixes the block acquires
1458
1184
                                        an s-latch here; so we can use the
1459
1185
                                        debug utilities in sync0rw */
1460
 
        /* @} */
1461
 
# endif
1462
 
#endif /* !UNIV_HOTBACKUP */
 
1186
#endif
1463
1187
};
1464
1188
 
1465
 
/** Check if a buf_block_t object is in a valid state
1466
 
@param block    buffer block
1467
 
@return         TRUE if valid */
 
1189
/* Check if a buf_block_t object is in a valid state. */
1468
1190
#define buf_block_state_valid(block)                            \
1469
1191
(buf_block_get_state(block) >= BUF_BLOCK_NOT_USED               \
1470
1192
 && (buf_block_get_state(block) <= BUF_BLOCK_REMOVE_HASH))
1471
1193
 
1472
 
#ifndef UNIV_HOTBACKUP
1473
 
/**********************************************************************//**
 
1194
/**************************************************************************
1474
1195
Compute the hash fold value for blocks in buf_pool->zip_hash. */
1475
 
/* @{ */
1476
1196
#define BUF_POOL_ZIP_FOLD_PTR(ptr) ((ulint) (ptr) / UNIV_PAGE_SIZE)
1477
1197
#define BUF_POOL_ZIP_FOLD(b) BUF_POOL_ZIP_FOLD_PTR((b)->frame)
1478
1198
#define BUF_POOL_ZIP_FOLD_BPAGE(b) BUF_POOL_ZIP_FOLD((buf_block_t*) (b))
1479
 
/* @} */
1480
 
 
1481
 
/** @brief The buffer pool statistics structure. */
1482
 
struct buf_pool_stat_struct{
1483
 
        ulint   n_page_gets;    /*!< number of page gets performed;
1484
 
                                also successful searches through
1485
 
                                the adaptive hash index are
1486
 
                                counted as page gets; this field
1487
 
                                is NOT protected by the buffer
1488
 
                                pool mutex */
1489
 
        ulint   n_pages_read;   /*!< number read operations */
1490
 
        ulint   n_pages_written;/*!< number write operations */
1491
 
        ulint   n_pages_created;/*!< number of pages created
1492
 
                                in the pool with no read */
1493
 
        ulint   n_ra_pages_read;/*!< number of pages read in
1494
 
                                as part of read ahead */
1495
 
        ulint   n_ra_pages_evicted;/*!< number of read ahead
1496
 
                                pages that are evicted without
1497
 
                                being accessed */
1498
 
        ulint   n_pages_made_young; /*!< number of pages made young, in
1499
 
                                calls to buf_LRU_make_block_young() */
1500
 
        ulint   n_pages_not_made_young; /*!< number of pages not made
1501
 
                                young because the first access
1502
 
                                was not long enough ago, in
1503
 
                                buf_page_peek_if_too_old() */
1504
 
};
1505
 
 
1506
 
/** Statistics of buddy blocks of a given size. */
1507
 
struct buf_buddy_stat_struct {
1508
 
        /** Number of blocks allocated from the buddy system. */
1509
 
        ulint           used;
1510
 
        /** Number of blocks relocated by the buddy system. */
1511
 
        ib_uint64_t     relocated;
1512
 
        /** Total duration of block relocations, in microseconds. */
1513
 
        ib_uint64_t     relocated_usec;
1514
 
};
1515
 
 
1516
 
/** @brief The buffer pool structure.
1517
 
 
1518
 
NOTE! The definition appears here only for other modules of this
1519
 
directory (buf) to see it. Do not use from outside! */
 
1199
 
 
1200
/* The buffer pool structure. NOTE! The definition appears here only for
 
1201
other modules of this directory (buf) to see it. Do not use from outside! */
1520
1202
 
1521
1203
struct buf_pool_struct{
1522
1204
 
1523
 
        /** @name General fields */
1524
 
        /* @{ */
1525
 
        mutex_t         mutex;          /*!< Buffer pool mutex of this
1526
 
                                        instance */
1527
 
        mutex_t         zip_mutex;      /*!< Zip mutex of this buffer
1528
 
                                        pool instance, protects compressed
1529
 
                                        only pages (of type buf_page_t, not
1530
 
                                        buf_block_t */
1531
 
        ulint           instance_no;    /*!< Array index of this buffer
1532
 
                                        pool instance */
1533
 
        ulint           old_pool_size;  /*!< Old pool size in bytes */
1534
 
        ulint           curr_pool_size; /*!< Current pool size in bytes */
1535
 
        ulint           LRU_old_ratio;  /*!< Reserve this much of the buffer
1536
 
                                        pool for "old" blocks */
1537
 
#ifdef UNIV_DEBUG
1538
 
        ulint           buddy_n_frames; /*!< Number of frames allocated from
1539
 
                                        the buffer pool to the buddy system */
1540
 
#endif
1541
 
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
1542
 
        ulint           mutex_exit_forbidden; /*!< Forbid release mutex */
1543
 
#endif
1544
 
        ulint           n_chunks;       /*!< number of buffer pool chunks */
1545
 
        buf_chunk_t*    chunks;         /*!< buffer pool chunks */
1546
 
        ulint           curr_size;      /*!< current pool size in pages */
1547
 
        hash_table_t*   page_hash;      /*!< hash table of buf_page_t or
 
1205
        /* 1. General fields */
 
1206
 
 
1207
        ulint           n_chunks;       /* number of buffer pool chunks */
 
1208
        buf_chunk_t*    chunks;         /* buffer pool chunks */
 
1209
        ulint           curr_size;      /* current pool size in pages */
 
1210
        hash_table_t*   page_hash;      /* hash table of buf_page_t or
1548
1211
                                        buf_block_t file pages,
1549
1212
                                        buf_page_in_file() == TRUE,
1550
1213
                                        indexed by (space_id, offset) */
1551
 
        hash_table_t*   zip_hash;       /*!< hash table of buf_block_t blocks
 
1214
        hash_table_t*   zip_hash;       /* hash table of buf_block_t blocks
1552
1215
                                        whose frames are allocated to the
1553
1216
                                        zip buddy system,
1554
1217
                                        indexed by block->frame */
1555
 
        ulint           n_pend_reads;   /*!< number of pending read
1556
 
                                        operations */
1557
 
        ulint           n_pend_unzip;   /*!< number of pending decompressions */
 
1218
        ulint           n_pend_reads;   /* number of pending read operations */
 
1219
        ulint           n_pend_unzip;   /* number of pending decompressions */
1558
1220
 
1559
 
        time_t          last_printout_time;
1560
 
                                        /*!< when buf_print_io was last time
 
1221
        time_t          last_printout_time; /* when buf_print was last time
1561
1222
                                        called */
1562
 
        buf_buddy_stat_t buddy_stat[BUF_BUDDY_SIZES + 1];
1563
 
                                        /*!< Statistics of buddy system,
1564
 
                                        indexed by block size */
1565
 
        buf_pool_stat_t stat;           /*!< current statistics */
1566
 
        buf_pool_stat_t old_stat;       /*!< old statistics */
1567
 
 
1568
 
        /* @} */
1569
 
 
1570
 
        /** @name Page flushing algorithm fields */
1571
 
 
1572
 
        /* @{ */
1573
 
 
1574
 
        mutex_t         flush_list_mutex;/*!< mutex protecting the
1575
 
                                        flush list access. This mutex
1576
 
                                        protects flush_list, flush_rbt
1577
 
                                        and bpage::list pointers when
1578
 
                                        the bpage is on flush_list. It
1579
 
                                        also protects writes to
1580
 
                                        bpage::oldest_modification */
 
1223
        ulint           n_pages_read;   /* number read operations */
 
1224
        ulint           n_pages_written;/* number write operations */
 
1225
        ulint           n_pages_created;/* number of pages created in the pool
 
1226
                                        with no read */
 
1227
        ulint           n_page_gets;    /* number of page gets performed;
 
1228
                                        also successful searches through
 
1229
                                        the adaptive hash index are
 
1230
                                        counted as page gets; this field
 
1231
                                        is NOT protected by the buffer
 
1232
                                        pool mutex */
 
1233
        ulint           n_page_gets_old;/* n_page_gets when buf_print was
 
1234
                                        last time called: used to calculate
 
1235
                                        hit rate */
 
1236
        ulint           n_pages_read_old;/* n_pages_read when buf_print was
 
1237
                                        last time called */
 
1238
        ulint           n_pages_written_old;/* number write operations */
 
1239
        ulint           n_pages_created_old;/* number of pages created in
 
1240
                                        the pool with no read */
 
1241
        /* 2. Page flushing algorithm fields */
 
1242
 
1581
1243
        UT_LIST_BASE_NODE_T(buf_page_t) flush_list;
1582
 
                                        /*!< base node of the modified block
 
1244
                                        /* base node of the modified block
1583
1245
                                        list */
1584
1246
        ibool           init_flush[BUF_FLUSH_N_TYPES];
1585
 
                                        /*!< this is TRUE when a flush of the
 
1247
                                        /* this is TRUE when a flush of the
1586
1248
                                        given type is being initialized */
1587
1249
        ulint           n_flush[BUF_FLUSH_N_TYPES];
1588
 
                                        /*!< this is the number of pending
 
1250
                                        /* this is the number of pending
1589
1251
                                        writes in the given flush type */
1590
1252
        os_event_t      no_flush[BUF_FLUSH_N_TYPES];
1591
 
                                        /*!< this is in the set state
1592
 
                                        when there is no flush batch
1593
 
                                        of the given type running */
1594
 
        ib_rbt_t*       flush_rbt;      /*!< a red-black tree is used
1595
 
                                        exclusively during recovery to
1596
 
                                        speed up insertions in the
1597
 
                                        flush_list. This tree contains
1598
 
                                        blocks in order of
1599
 
                                        oldest_modification LSN and is
1600
 
                                        kept in sync with the
1601
 
                                        flush_list.
1602
 
                                        Each member of the tree MUST
1603
 
                                        also be on the flush_list.
1604
 
                                        This tree is relevant only in
1605
 
                                        recovery and is set to NULL
1606
 
                                        once the recovery is over.
1607
 
                                        Protected by flush_list_mutex */
1608
 
        ulint           freed_page_clock;/*!< a sequence number used
1609
 
                                        to count the number of buffer
1610
 
                                        blocks removed from the end of
1611
 
                                        the LRU list; NOTE that this
1612
 
                                        counter may wrap around at 4
1613
 
                                        billion! A thread is allowed
1614
 
                                        to read this for heuristic
1615
 
                                        purposes without holding any
1616
 
                                        mutex or latch */
1617
 
        ulint           LRU_flush_ended;/*!< when an LRU flush ends for a page,
 
1253
                                        /* this is in the set state when there
 
1254
                                        is no flush batch of the given type
 
1255
                                        running */
 
1256
        ulint           ulint_clock;    /* a sequence number used to count
 
1257
                                        time. NOTE! This counter wraps
 
1258
                                        around at 4 billion (if ulint ==
 
1259
                                        32 bits)! */
 
1260
        ulint           freed_page_clock;/* a sequence number used to count the
 
1261
                                        number of buffer blocks removed from
 
1262
                                        the end of the LRU list; NOTE that
 
1263
                                        this counter may wrap around at 4
 
1264
                                        billion! A thread is allowed to
 
1265
                                        read this for heuristic purposes
 
1266
                                        without holding any mutex or latch */
 
1267
        ulint           LRU_flush_ended;/* when an LRU flush ends for a page,
1618
1268
                                        this is incremented by one; this is
1619
1269
                                        set to zero when a buffer block is
1620
1270
                                        allocated */
1621
 
        /* @} */
1622
1271
 
1623
 
        /** @name LRU replacement algorithm fields */
1624
 
        /* @{ */
 
1272
        /* 3. LRU replacement algorithm fields */
1625
1273
 
1626
1274
        UT_LIST_BASE_NODE_T(buf_page_t) free;
1627
 
                                        /*!< base node of the free
1628
 
                                        block list */
 
1275
                                        /* base node of the free block list */
1629
1276
        UT_LIST_BASE_NODE_T(buf_page_t) LRU;
1630
 
                                        /*!< base node of the LRU list */
1631
 
        buf_page_t*     LRU_old;        /*!< pointer to the about
1632
 
                                        buf_LRU_old_ratio/BUF_LRU_OLD_RATIO_DIV
1633
 
                                        oldest blocks in the LRU list;
1634
 
                                        NULL if LRU length less than
1635
 
                                        BUF_LRU_OLD_MIN_LEN;
 
1277
                                        /* base node of the LRU list */
 
1278
        buf_page_t*     LRU_old;        /* pointer to the about 3/8 oldest
 
1279
                                        blocks in the LRU list; NULL if LRU
 
1280
                                        length less than BUF_LRU_OLD_MIN_LEN;
1636
1281
                                        NOTE: when LRU_old != NULL, its length
1637
1282
                                        should always equal LRU_old_len */
1638
 
        ulint           LRU_old_len;    /*!< length of the LRU list from
 
1283
        ulint           LRU_old_len;    /* length of the LRU list from
1639
1284
                                        the block to which LRU_old points
1640
1285
                                        onward, including that block;
1641
1286
                                        see buf0lru.c for the restrictions
1642
 
                                        on this value; 0 if LRU_old == NULL;
 
1287
                                        on this value; not defined if
 
1288
                                        LRU_old == NULL;
1643
1289
                                        NOTE: LRU_old_len must be adjusted
1644
1290
                                        whenever LRU_old shrinks or grows! */
1645
1291
 
1646
1292
        UT_LIST_BASE_NODE_T(buf_block_t) unzip_LRU;
1647
 
                                        /*!< base node of the
1648
 
                                        unzip_LRU list */
 
1293
                                        /* base node of the unzip_LRU list */
1649
1294
 
1650
 
        /* @} */
1651
 
        /** @name Buddy allocator fields
1652
 
        The buddy allocator is used for allocating compressed page
1653
 
        frames and buf_page_t descriptors of blocks that exist
1654
 
        in the buffer pool only in compressed form. */
1655
 
        /* @{ */
 
1295
        /* 4. Fields for the buddy allocator of compressed pages */
1656
1296
        UT_LIST_BASE_NODE_T(buf_page_t) zip_clean;
1657
 
                                        /*!< unmodified compressed pages */
 
1297
                                        /* unmodified compressed pages */
1658
1298
        UT_LIST_BASE_NODE_T(buf_page_t) zip_free[BUF_BUDDY_SIZES];
1659
 
                                        /*!< buddy free lists */
1660
 
 
1661
 
        buf_page_t                      watch[BUF_POOL_WATCH_SIZE];
1662
 
                                        /*!< Sentinel records for buffer
1663
 
                                        pool watches. Protected by
1664
 
                                        buf_pool->mutex. */
1665
 
 
 
1299
                                        /* buddy free lists */
1666
1300
#if BUF_BUDDY_HIGH != UNIV_PAGE_SIZE
1667
1301
# error "BUF_BUDDY_HIGH != UNIV_PAGE_SIZE"
1668
1302
#endif
1669
1303
#if BUF_BUDDY_LOW > PAGE_ZIP_MIN_SIZE
1670
1304
# error "BUF_BUDDY_LOW > PAGE_ZIP_MIN_SIZE"
1671
1305
#endif
1672
 
        /* @} */
1673
1306
};
1674
1307
 
1675
 
/** @name Accessors for buf_pool->mutex.
1676
 
Use these instead of accessing buf_pool->mutex directly. */
1677
 
/* @{ */
1678
 
 
1679
 
/** Test if a buffer pool mutex is owned. */
1680
 
#define buf_pool_mutex_own(b) mutex_own(&b->mutex)
1681
 
/** Acquire a buffer pool mutex. */
1682
 
#define buf_pool_mutex_enter(b) do {            \
1683
 
        ut_ad(!mutex_own(&b->zip_mutex));       \
1684
 
        mutex_enter(&b->mutex);         \
1685
 
} while (0)
1686
 
 
1687
 
/** Test if flush list mutex is owned. */
1688
 
#define buf_flush_list_mutex_own(b) mutex_own(&b->flush_list_mutex)
1689
 
 
1690
 
/** Acquire the flush list mutex. */
1691
 
#define buf_flush_list_mutex_enter(b) do {      \
1692
 
        mutex_enter(&b->flush_list_mutex);      \
1693
 
} while (0)
1694
 
/** Release the flush list mutex. */
1695
 
# define buf_flush_list_mutex_exit(b) do {      \
1696
 
        mutex_exit(&b->flush_list_mutex);       \
1697
 
} while (0)
1698
 
 
1699
 
 
 
1308
/* mutex protecting the buffer pool struct and control blocks, except the
 
1309
read-write lock in them */
 
1310
extern mutex_t  buf_pool_mutex;
 
1311
/* mutex protecting the control blocks of compressed-only pages
 
1312
(of type buf_page_t, not buf_block_t) */
 
1313
extern mutex_t  buf_pool_zip_mutex;
 
1314
 
 
1315
/* Accessors for buf_pool_mutex.  Use these instead of accessing
 
1316
buf_pool_mutex directly. */
 
1317
 
 
1318
/* Test if buf_pool_mutex is owned. */
 
1319
#define buf_pool_mutex_own() mutex_own(&buf_pool_mutex)
 
1320
/* Acquire the buffer pool mutex. */
 
1321
#define buf_pool_mutex_enter() do {             \
 
1322
        ut_ad(!mutex_own(&buf_pool_zip_mutex)); \
 
1323
        mutex_enter(&buf_pool_mutex);           \
 
1324
} while (0)
1700
1325
 
1701
1326
#if defined UNIV_DEBUG || defined UNIV_BUF_DEBUG
1702
 
/** Forbid the release of the buffer pool mutex. */
1703
 
# define buf_pool_mutex_exit_forbid(b) do {     \
1704
 
        ut_ad(buf_pool_mutex_own(b));           \
1705
 
        b->mutex_exit_forbidden++;              \
1706
 
} while (0)
1707
 
/** Allow the release of the buffer pool mutex. */
1708
 
# define buf_pool_mutex_exit_allow(b) do {      \
1709
 
        ut_ad(buf_pool_mutex_own(b));           \
1710
 
        ut_a(b->mutex_exit_forbidden);  \
1711
 
        b->mutex_exit_forbidden--;              \
1712
 
} while (0)
1713
 
/** Release the buffer pool mutex. */
1714
 
# define buf_pool_mutex_exit(b) do {            \
1715
 
        ut_a(!b->mutex_exit_forbidden);         \
1716
 
        mutex_exit(&b->mutex);                  \
 
1327
/** Flag to forbid the release of the buffer pool mutex.
 
1328
Protected by buf_pool_mutex. */
 
1329
extern ulint    buf_pool_mutex_exit_forbidden;
 
1330
/* Forbid the release of the buffer pool mutex. */
 
1331
# define buf_pool_mutex_exit_forbid() do {      \
 
1332
        ut_ad(buf_pool_mutex_own());            \
 
1333
        buf_pool_mutex_exit_forbidden++;        \
 
1334
} while (0)
 
1335
/* Allow the release of the buffer pool mutex. */
 
1336
# define buf_pool_mutex_exit_allow() do {       \
 
1337
        ut_ad(buf_pool_mutex_own());            \
 
1338
        ut_a(buf_pool_mutex_exit_forbidden);    \
 
1339
        buf_pool_mutex_exit_forbidden--;        \
 
1340
} while (0)
 
1341
/* Release the buffer pool mutex. */
 
1342
# define buf_pool_mutex_exit() do {             \
 
1343
        ut_a(!buf_pool_mutex_exit_forbidden);   \
 
1344
        mutex_exit(&buf_pool_mutex);            \
1717
1345
} while (0)
1718
1346
#else
1719
 
/** Forbid the release of the buffer pool mutex. */
1720
 
# define buf_pool_mutex_exit_forbid(b) ((void) 0)
1721
 
/** Allow the release of the buffer pool mutex. */
1722
 
# define buf_pool_mutex_exit_allow(b) ((void) 0)
1723
 
/** Release the buffer pool mutex. */
1724
 
# define buf_pool_mutex_exit(b) mutex_exit(&b->mutex)
 
1347
/* Forbid the release of the buffer pool mutex. */
 
1348
# define buf_pool_mutex_exit_forbid() ((void) 0)
 
1349
/* Allow the release of the buffer pool mutex. */
 
1350
# define buf_pool_mutex_exit_allow() ((void) 0)
 
1351
/* Release the buffer pool mutex. */
 
1352
# define buf_pool_mutex_exit() mutex_exit(&buf_pool_mutex)
1725
1353
#endif
1726
 
#endif /* !UNIV_HOTBACKUP */
1727
 
/* @} */
1728
1354
 
1729
 
/**********************************************************************
 
1355
/************************************************************************
1730
1356
Let us list the consistency conditions for different control block states.
1731
1357
 
1732
1358
NOT_USED:       is in free list, not in LRU list, not in flush list, nor