← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/buf0flu.h

  • Committer: Andrew Hutchings
  • Date: 2010-10-13 11:33:44 UTC
  • mto: (1848.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 1849.
  • Revision ID: andrew@linuxjedi.co.uk-20101013113344-l8br9nkvqcns5o92
https://launchpad.net/bugs/659824
Output of unhex('ff') caused an endless loop due to 0-byte length accounting.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/buf0flu.h
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (C) 1995, 2010, Innobase Oy. All Rights Reserved.
 
3
Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.
4
4
 
5
5
This program is free software; you can redistribute it and/or modify it under
6
6
the terms of the GNU General Public License as published by the Free Software
31
31
#ifndef UNIV_HOTBACKUP
32
32
#include "mtr0types.h"
33
33
#include "buf0types.h"
34
 
#include "log0log.h"
35
34
 
36
35
/********************************************************************//**
37
36
Remove a block from the flush list of modified blocks. */
40
39
buf_flush_remove(
41
40
/*=============*/
42
41
        buf_page_t*     bpage); /*!< in: pointer to the block in question */
43
 
/*******************************************************************//**
44
 
Relocates a buffer control block on the flush_list.
45
 
Note that it is assumed that the contents of bpage has already been
46
 
copied to dpage. */
47
 
UNIV_INTERN
48
 
void
49
 
buf_flush_relocate_on_flush_list(
50
 
/*=============================*/
51
 
        buf_page_t*     bpage,  /*!< in/out: control block being moved */
52
 
        buf_page_t*     dpage); /*!< in/out: destination block */
53
42
/********************************************************************//**
54
43
Updates the flush system data structures when a write is completed. */
55
44
UNIV_INTERN
59
48
        buf_page_t*     bpage); /*!< in: pointer to the block in question */
60
49
/*********************************************************************//**
61
50
Flushes pages from the end of the LRU list if there is too small
62
 
a margin of replaceable pages there. If buffer pool is NULL it
63
 
means flush free margin on all buffer pool instances. */
64
 
UNIV_INTERN
65
 
void
66
 
buf_flush_free_margin(
67
 
/*==================*/
68
 
         buf_pool_t*    buf_pool);
69
 
/*********************************************************************//**
70
 
Flushes pages from the end of all the LRU lists. */
71
 
UNIV_INTERN
72
 
void
73
 
buf_flush_free_margins(void);
74
 
/*=========================*/
 
51
a margin of replaceable pages there. */
 
52
UNIV_INTERN
 
53
void
 
54
buf_flush_free_margin(void);
 
55
/*=======================*/
75
56
#endif /* !UNIV_HOTBACKUP */
76
57
/********************************************************************//**
77
58
Initializes a page for writing to the tablespace. */
84
65
        ib_uint64_t     newest_lsn);    /*!< in: newest modification lsn
85
66
                                        to the page */
86
67
#ifndef UNIV_HOTBACKUP
87
 
# if defined UNIV_DEBUG || defined UNIV_IBUF_DEBUG
88
 
/********************************************************************//**
89
 
Writes a flushable page asynchronously from the buffer pool to a file.
90
 
NOTE: buf_pool->mutex and block->mutex must be held upon entering this
91
 
function, and they will be released by this function after flushing.
92
 
This is loosely based on buf_flush_batch() and buf_flush_page().
93
 
@return TRUE if the page was flushed and the mutexes released */
94
 
UNIV_INTERN
95
 
ibool
96
 
buf_flush_page_try(
97
 
/*===============*/
98
 
        buf_pool_t*     buf_pool,       /*!< in/out: buffer pool instance */
99
 
        buf_block_t*    block)          /*!< in/out: buffer control block */
100
 
        __attribute__((nonnull, warn_unused_result));
101
 
# endif /* UNIV_DEBUG || UNIV_IBUF_DEBUG */
102
 
/*******************************************************************//**
103
 
This utility flushes dirty blocks from the end of the LRU list.
104
 
NOTE: The calling thread may own latches to pages: to avoid deadlocks,
105
 
this function must be written so that it cannot end up waiting for these
106
 
latches!
107
 
@return number of blocks for which the write request was queued;
108
 
ULINT_UNDEFINED if there was a flush of the same type already running */
109
 
UNIV_INTERN
110
 
ulint
111
 
buf_flush_LRU(
112
 
/*==========*/
113
 
        buf_pool_t*     buf_pool,       /*!< in: buffer pool instance */
114
 
        ulint           min_n);         /*!< in: wished minimum mumber of blocks
115
 
                                        flushed (it is not guaranteed that the
116
 
                                        actual number is that big, though) */
117
 
/*******************************************************************//**
118
 
This utility flushes dirty blocks from the end of the flush_list of
119
 
all buffer pool instances.
120
 
NOTE: The calling thread is not allowed to own any latches on pages!
121
 
@return number of blocks for which the write request was queued;
122
 
ULINT_UNDEFINED if there was a flush of the same type already running */
123
 
UNIV_INTERN
124
 
ulint
125
 
buf_flush_list(
 
68
/*******************************************************************//**
 
69
This utility flushes dirty blocks from the end of the LRU list or flush_list.
 
70
NOTE 1: in the case of an LRU flush the calling thread may own latches to
 
71
pages: to avoid deadlocks, this function must be written so that it cannot
 
72
end up waiting for these latches! NOTE 2: in the case of a flush list flush,
 
73
the calling thread is not allowed to own any latches on pages!
 
74
@return number of blocks for which the write request was queued;
 
75
ULINT_UNDEFINED if there was a flush of the same type already running */
 
76
UNIV_INTERN
 
77
ulint
 
78
buf_flush_batch(
126
79
/*============*/
 
80
        enum buf_flush  flush_type,     /*!< in: BUF_FLUSH_LRU or
 
81
                                        BUF_FLUSH_LIST; if BUF_FLUSH_LIST,
 
82
                                        then the caller must not own any
 
83
                                        latches on pages */
127
84
        ulint           min_n,          /*!< in: wished minimum mumber of blocks
128
85
                                        flushed (it is not guaranteed that the
129
86
                                        actual number is that big, though) */
138
95
void
139
96
buf_flush_wait_batch_end(
140
97
/*=====================*/
141
 
        buf_pool_t*     buf_pool,       /*!< buffer pool instance */
142
 
        enum buf_flush  type);          /*!< in: BUF_FLUSH_LRU
143
 
                                        or BUF_FLUSH_LIST */
 
98
        enum buf_flush  type);  /*!< in: BUF_FLUSH_LRU or BUF_FLUSH_LIST */
144
99
/********************************************************************//**
145
100
This function should be called at a mini-transaction commit, if a page was
146
101
modified in it. Puts the block to the list of modified blocks, if it not
216
171
@return TRUE if ok */
217
172
UNIV_INTERN
218
173
ibool
219
 
buf_flush_validate(
220
 
/*===============*/
221
 
        buf_pool_t*     buf_pool);
 
174
buf_flush_validate(void);
 
175
/*====================*/
222
176
#endif /* UNIV_DEBUG || UNIV_BUF_DEBUG */
223
177
 
224
 
/********************************************************************//**
225
 
Initialize the red-black tree to speed up insertions into the flush_list
226
 
during recovery process. Should be called at the start of recovery
227
 
process before any page has been read/written. */
228
 
UNIV_INTERN
229
 
void
230
 
buf_flush_init_flush_rbt(void);
231
 
/*==========================*/
232
 
 
233
 
/********************************************************************//**
234
 
Frees up the red-black tree. */
235
 
UNIV_INTERN
236
 
void
237
 
buf_flush_free_flush_rbt(void);
238
 
/*==========================*/
239
 
 
240
178
/** When buf_flush_free_margin is called, it tries to make this many blocks
241
179
available to replacement in the free list and at the end of the LRU list (to
242
180
make sure that a read-ahead batch can be read efficiently in a single
243
181
sweep). */
244
 
#define BUF_FLUSH_FREE_BLOCK_MARGIN(b)  (5 + BUF_READ_AHEAD_AREA(b))
 
182
#define BUF_FLUSH_FREE_BLOCK_MARGIN     (5 + BUF_READ_AHEAD_AREA)
245
183
/** Extra margin to apply above BUF_FLUSH_FREE_BLOCK_MARGIN */
246
 
#define BUF_FLUSH_EXTRA_MARGIN(b)       ((BUF_FLUSH_FREE_BLOCK_MARGIN(b) / 4 \
247
 
                                        + 100) / srv_buf_pool_instances)
 
184
#define BUF_FLUSH_EXTRA_MARGIN          (BUF_FLUSH_FREE_BLOCK_MARGIN / 4 + 100)
248
185
#endif /* !UNIV_HOTBACKUP */
249
186
 
250
187
#ifndef UNIV_NONINL