← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Brian Aker
  • Date: 2010-12-08 22:35:56 UTC
  • mfrom: (1819.9.158 update-innobase)
  • Revision ID: brian@tangent.org-20101208223556-37mi4omqg7lkjzf3
Merge in Stewart's changes, 1.3 changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/log0recv.h
 
1
/*****************************************************************************
 
2
 
 
3
Copyright (c) 1997, 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/log0recv.h
 
21
Recovery
 
22
 
 
23
Created 9/20/1997 Heikki Tuuri
 
24
*******************************************************/
 
25
 
 
26
#ifndef log0recv_h
 
27
#define log0recv_h
 
28
 
 
29
#include "univ.i"
 
30
#include "ut0byte.h"
 
31
#include "buf0types.h"
 
32
#include "hash0hash.h"
 
33
#include "log0log.h"
 
34
 
 
35
#ifdef UNIV_HOTBACKUP
 
36
extern ibool    recv_replay_file_ops;
 
37
 
 
38
/*******************************************************************//**
 
39
Reads the checkpoint info needed in hot backup.
 
40
@return TRUE if success */
 
41
UNIV_INTERN
 
42
ibool
 
43
recv_read_cp_info_for_backup(
 
44
/*=========================*/
 
45
        const byte*     hdr,    /*!< in: buffer containing the log group
 
46
                                header */
 
47
        ib_uint64_t*    lsn,    /*!< out: checkpoint lsn */
 
48
        ulint*          offset, /*!< out: checkpoint offset in the log group */
 
49
        ulint*          fsp_limit,/*!< out: fsp limit of space 0,
 
50
                                1000000000 if the database is running
 
51
                                with < version 3.23.50 of InnoDB */
 
52
        ib_uint64_t*    cp_no,  /*!< out: checkpoint number */
 
53
        ib_uint64_t*    first_header_lsn);
 
54
                                /*!< out: lsn of of the start of the
 
55
                                first log file */
 
56
/*******************************************************************//**
 
57
Scans the log segment and n_bytes_scanned is set to the length of valid
 
58
log scanned. */
 
59
UNIV_INTERN
 
60
void
 
61
recv_scan_log_seg_for_backup(
 
62
/*=========================*/
 
63
        byte*           buf,            /*!< in: buffer containing log data */
 
64
        ulint           buf_len,        /*!< in: data length in that buffer */
 
65
        ib_uint64_t*    scanned_lsn,    /*!< in/out: lsn of buffer start,
 
66
                                        we return scanned lsn */
 
67
        ulint*          scanned_checkpoint_no,
 
68
                                        /*!< in/out: 4 lowest bytes of the
 
69
                                        highest scanned checkpoint number so
 
70
                                        far */
 
71
        ulint*          n_bytes_scanned);/*!< out: how much we were able to
 
72
                                        scan, smaller than buf_len if log
 
73
                                        data ended here */
 
74
#endif /* UNIV_HOTBACKUP */
 
75
/*******************************************************************//**
 
76
Returns TRUE if recovery is currently running.
 
77
@return recv_recovery_on */
 
78
UNIV_INLINE
 
79
ibool
 
80
recv_recovery_is_on(void);
 
81
/*=====================*/
 
82
#ifdef UNIV_LOG_ARCHIVE
 
83
/*******************************************************************//**
 
84
Returns TRUE if recovery from backup is currently running.
 
85
@return recv_recovery_from_backup_on */
 
86
UNIV_INLINE
 
87
ibool
 
88
recv_recovery_from_backup_is_on(void);
 
89
/*=================================*/
 
90
#endif /* UNIV_LOG_ARCHIVE */
 
91
/************************************************************************//**
 
92
Applies the hashed log records to the page, if the page lsn is less than the
 
93
lsn of a log record. This can be called when a buffer page has just been
 
94
read in, or also for a page already in the buffer pool. */
 
95
UNIV_INTERN
 
96
void
 
97
recv_recover_page_func(
 
98
/*===================*/
 
99
#ifndef UNIV_HOTBACKUP
 
100
        ibool           just_read_in,
 
101
                                /*!< in: TRUE if the i/o handler calls
 
102
                                this for a freshly read page */
 
103
#endif /* !UNIV_HOTBACKUP */
 
104
        buf_block_t*    block); /*!< in/out: buffer block */
 
105
#ifndef UNIV_HOTBACKUP
 
106
/** Wrapper for recv_recover_page_func().
 
107
Applies the hashed log records to the page, if the page lsn is less than the
 
108
lsn of a log record. This can be called when a buffer page has just been
 
109
read in, or also for a page already in the buffer pool.
 
110
@param jri      in: TRUE if just read in (the i/o handler calls this for
 
111
a freshly read page)
 
112
@param block    in/out: the buffer block
 
113
*/
 
114
# define recv_recover_page(jri, block)  recv_recover_page_func(jri, block)
 
115
#else /* !UNIV_HOTBACKUP */
 
116
/** Wrapper for recv_recover_page_func().
 
117
Applies the hashed log records to the page, if the page lsn is less than the
 
118
lsn of a log record. This can be called when a buffer page has just been
 
119
read in, or also for a page already in the buffer pool.
 
120
@param jri      in: TRUE if just read in (the i/o handler calls this for
 
121
a freshly read page)
 
122
@param block    in/out: the buffer block
 
123
*/
 
124
# define recv_recover_page(jri, block)  recv_recover_page_func(block)
 
125
#endif /* !UNIV_HOTBACKUP */
 
126
/********************************************************//**
 
127
Recovers from a checkpoint. When this function returns, the database is able
 
128
to start processing of new user transactions, but the function
 
129
recv_recovery_from_checkpoint_finish should be called later to complete
 
130
the recovery and free the resources used in it.
 
131
@return error code or DB_SUCCESS */
 
132
UNIV_INTERN
 
133
ulint
 
134
recv_recovery_from_checkpoint_start_func(
 
135
/*=====================================*/
 
136
#ifdef UNIV_LOG_ARCHIVE
 
137
        ulint           type,           /*!< in: LOG_CHECKPOINT or
 
138
                                        LOG_ARCHIVE */
 
139
        ib_uint64_t     limit_lsn,      /*!< in: recover up to this lsn
 
140
                                        if possible */
 
141
#endif /* UNIV_LOG_ARCHIVE */
 
142
        ib_uint64_t     min_flushed_lsn,/*!< in: min flushed lsn from
 
143
                                        data files */
 
144
        ib_uint64_t     max_flushed_lsn);/*!< in: max flushed lsn from
 
145
                                         data files */
 
146
#ifdef UNIV_LOG_ARCHIVE
 
147
/** Wrapper for recv_recovery_from_checkpoint_start_func().
 
148
Recovers from a checkpoint. When this function returns, the database is able
 
149
to start processing of new user transactions, but the function
 
150
recv_recovery_from_checkpoint_finish should be called later to complete
 
151
the recovery and free the resources used in it.
 
152
@param type     in: LOG_CHECKPOINT or LOG_ARCHIVE
 
153
@param lim      in: recover up to this log sequence number if possible
 
154
@param min      in: minimum flushed log sequence number from data files
 
155
@param max      in: maximum flushed log sequence number from data files
 
156
@return error code or DB_SUCCESS */
 
157
# define recv_recovery_from_checkpoint_start(type,lim,min,max)          \
 
158
        recv_recovery_from_checkpoint_start_func(type,lim,min,max)
 
159
#else /* UNIV_LOG_ARCHIVE */
 
160
/** Wrapper for recv_recovery_from_checkpoint_start_func().
 
161
Recovers from a checkpoint. When this function returns, the database is able
 
162
to start processing of new user transactions, but the function
 
163
recv_recovery_from_checkpoint_finish should be called later to complete
 
164
the recovery and free the resources used in it.
 
165
@param type     ignored: LOG_CHECKPOINT or LOG_ARCHIVE
 
166
@param lim      ignored: recover up to this log sequence number if possible
 
167
@param min      in: minimum flushed log sequence number from data files
 
168
@param max      in: maximum flushed log sequence number from data files
 
169
@return error code or DB_SUCCESS */
 
170
# define recv_recovery_from_checkpoint_start(type,lim,min,max)          \
 
171
        recv_recovery_from_checkpoint_start_func(min,max)
 
172
#endif /* UNIV_LOG_ARCHIVE */
 
173
/********************************************************//**
 
174
Completes recovery from a checkpoint. */
 
175
UNIV_INTERN
 
176
void
 
177
recv_recovery_from_checkpoint_finish(void);
 
178
/*======================================*/
 
179
/********************************************************//**
 
180
Initiates the rollback of active transactions. */
 
181
UNIV_INTERN
 
182
void
 
183
recv_recovery_rollback_active(void);
 
184
/*===============================*/
 
185
/*******************************************************//**
 
186
Scans log from a buffer and stores new log data to the parsing buffer.
 
187
Parses and hashes the log records if new data found.  Unless
 
188
UNIV_HOTBACKUP is defined, this function will apply log records
 
189
automatically when the hash table becomes full.
 
190
@return TRUE if limit_lsn has been reached, or not able to scan any
 
191
more in this log group */
 
192
UNIV_INTERN
 
193
ibool
 
194
recv_scan_log_recs(
 
195
/*===============*/
 
196
        ulint           available_memory,/*!< in: we let the hash table of recs
 
197
                                        to grow to this size, at the maximum */
 
198
        ibool           store_to_hash,  /*!< in: TRUE if the records should be
 
199
                                        stored to the hash table; this is set
 
200
                                        to FALSE if just debug checking is
 
201
                                        needed */
 
202
        const byte*     buf,            /*!< in: buffer containing a log
 
203
                                        segment or garbage */
 
204
        ulint           len,            /*!< in: buffer length */
 
205
        ib_uint64_t     start_lsn,      /*!< in: buffer start lsn */
 
206
        ib_uint64_t*    contiguous_lsn, /*!< in/out: it is known that all log
 
207
                                        groups contain contiguous log data up
 
208
                                        to this lsn */
 
209
        ib_uint64_t*    group_scanned_lsn);/*!< out: scanning succeeded up to
 
210
                                        this lsn */
 
211
/******************************************************//**
 
212
Resets the logs. The contents of log files will be lost! */
 
213
UNIV_INTERN
 
214
void
 
215
recv_reset_logs(
 
216
/*============*/
 
217
        ib_uint64_t     lsn,            /*!< in: reset to this lsn
 
218
                                        rounded up to be divisible by
 
219
                                        OS_FILE_LOG_BLOCK_SIZE, after
 
220
                                        which we add
 
221
                                        LOG_BLOCK_HDR_SIZE */
 
222
#ifdef UNIV_LOG_ARCHIVE
 
223
        ulint           arch_log_no,    /*!< in: next archived log file number */
 
224
#endif /* UNIV_LOG_ARCHIVE */
 
225
        ibool           new_logs_created);/*!< in: TRUE if resetting logs
 
226
                                        is done at the log creation;
 
227
                                        FALSE if it is done after
 
228
                                        archive recovery */
 
229
#ifdef UNIV_HOTBACKUP
 
230
/******************************************************//**
 
231
Creates new log files after a backup has been restored. */
 
232
UNIV_INTERN
 
233
void
 
234
recv_reset_log_files_for_backup(
 
235
/*============================*/
 
236
        const char*     log_dir,        /*!< in: log file directory path */
 
237
        ulint           n_log_files,    /*!< in: number of log files */
 
238
        ulint           log_file_size,  /*!< in: log file size */
 
239
        ib_uint64_t     lsn);           /*!< in: new start lsn, must be
 
240
                                        divisible by OS_FILE_LOG_BLOCK_SIZE */
 
241
#endif /* UNIV_HOTBACKUP */
 
242
/********************************************************//**
 
243
Creates the recovery system. */
 
244
UNIV_INTERN
 
245
void
 
246
recv_sys_create(void);
 
247
/*=================*/
 
248
/**********************************************************//**
 
249
Release recovery system mutexes. */
 
250
UNIV_INTERN
 
251
void
 
252
recv_sys_close(void);
 
253
/*================*/
 
254
/********************************************************//**
 
255
Frees the recovery system memory. */
 
256
UNIV_INTERN
 
257
void
 
258
recv_sys_mem_free(void);
 
259
/*===================*/
 
260
/********************************************************//**
 
261
Inits the recovery system for a recovery operation. */
 
262
UNIV_INTERN
 
263
void
 
264
recv_sys_init(
 
265
/*==========*/
 
266
        ulint   available_memory);      /*!< in: available memory in bytes */
 
267
#ifndef UNIV_HOTBACKUP
 
268
/********************************************************//**
 
269
Reset the state of the recovery system variables. */
 
270
UNIV_INTERN
 
271
void
 
272
recv_sys_var_init(void);
 
273
/*===================*/
 
274
#endif /* !UNIV_HOTBACKUP */
 
275
/*******************************************************************//**
 
276
Empties the hash table of stored log records, applying them to appropriate
 
277
pages. */
 
278
UNIV_INTERN
 
279
void
 
280
recv_apply_hashed_log_recs(
 
281
/*=======================*/
 
282
        ibool   allow_ibuf);    /*!< in: if TRUE, also ibuf operations are
 
283
                                allowed during the application; if FALSE,
 
284
                                no ibuf operations are allowed, and after
 
285
                                the application all file pages are flushed to
 
286
                                disk and invalidated in buffer pool: this
 
287
                                alternative means that no new log records
 
288
                                can be generated during the application */
 
289
#ifdef UNIV_HOTBACKUP
 
290
/*******************************************************************//**
 
291
Applies log records in the hash table to a backup. */
 
292
UNIV_INTERN
 
293
void
 
294
recv_apply_log_recs_for_backup(void);
 
295
/*================================*/
 
296
#endif
 
297
#ifdef UNIV_LOG_ARCHIVE
 
298
/********************************************************//**
 
299
Recovers from archived log files, and also from log files, if they exist.
 
300
@return error code or DB_SUCCESS */
 
301
UNIV_INTERN
 
302
ulint
 
303
recv_recovery_from_archive_start(
 
304
/*=============================*/
 
305
        ib_uint64_t     min_flushed_lsn,/*!< in: min flushed lsn field from the
 
306
                                        data files */
 
307
        ib_uint64_t     limit_lsn,      /*!< in: recover up to this lsn if
 
308
                                        possible */
 
309
        ulint           first_log_no);  /*!< in: number of the first archived
 
310
                                        log file to use in the recovery; the
 
311
                                        file will be searched from
 
312
                                        INNOBASE_LOG_ARCH_DIR specified in
 
313
                                        server config file */
 
314
/********************************************************//**
 
315
Completes recovery from archive. */
 
316
UNIV_INTERN
 
317
void
 
318
recv_recovery_from_archive_finish(void);
 
319
/*===================================*/
 
320
#endif /* UNIV_LOG_ARCHIVE */
 
321
 
 
322
/** Block of log record data */
 
323
typedef struct recv_data_struct recv_data_t;
 
324
/** Block of log record data */
 
325
struct recv_data_struct{
 
326
        recv_data_t*    next;   /*!< pointer to the next block or NULL */
 
327
                                /*!< the log record data is stored physically
 
328
                                immediately after this struct, max amount
 
329
                                RECV_DATA_BLOCK_SIZE bytes of it */
 
330
};
 
331
 
 
332
/** Stored log record struct */
 
333
typedef struct recv_struct      recv_t;
 
334
/** Stored log record struct */
 
335
struct recv_struct{
 
336
        byte            type;   /*!< log record type */
 
337
        ulint           len;    /*!< log record body length in bytes */
 
338
        recv_data_t*    data;   /*!< chain of blocks containing the log record
 
339
                                body */
 
340
        ib_uint64_t     start_lsn;/*!< start lsn of the log segment written by
 
341
                                the mtr which generated this log record: NOTE
 
342
                                that this is not necessarily the start lsn of
 
343
                                this log record */
 
344
        ib_uint64_t     end_lsn;/*!< end lsn of the log segment written by
 
345
                                the mtr which generated this log record: NOTE
 
346
                                that this is not necessarily the end lsn of
 
347
                                this log record */
 
348
        UT_LIST_NODE_T(recv_t)
 
349
                        rec_list;/*!< list of log records for this page */
 
350
};
 
351
 
 
352
/** States of recv_addr_struct */
 
353
enum recv_addr_state {
 
354
        /** not yet processed */
 
355
        RECV_NOT_PROCESSED,
 
356
        /** page is being read */
 
357
        RECV_BEING_READ,
 
358
        /** log records are being applied on the page */
 
359
        RECV_BEING_PROCESSED,
 
360
        /** log records have been applied on the page, or they have
 
361
        been discarded because the tablespace does not exist */
 
362
        RECV_PROCESSED
 
363
};
 
364
 
 
365
/** Hashed page file address struct */
 
366
typedef struct recv_addr_struct recv_addr_t;
 
367
/** Hashed page file address struct */
 
368
struct recv_addr_struct{
 
369
        enum recv_addr_state state;
 
370
                                /*!< recovery state of the page */
 
371
        unsigned        space:32;/*!< space id */
 
372
        unsigned        page_no:32;/*!< page number */
 
373
        UT_LIST_BASE_NODE_T(recv_t)
 
374
                        rec_list;/*!< list of log records for this page */
 
375
        hash_node_t     addr_hash;/*!< hash node in the hash bucket chain */
 
376
};
 
377
 
 
378
/** Recovery system data structure */
 
379
typedef struct recv_sys_struct  recv_sys_t;
 
380
/** Recovery system data structure */
 
381
struct recv_sys_struct{
 
382
#ifndef UNIV_HOTBACKUP
 
383
        mutex_t         mutex;  /*!< mutex protecting the fields apply_log_recs,
 
384
                                n_addrs, and the state field in each recv_addr
 
385
                                struct */
 
386
#endif /* !UNIV_HOTBACKUP */
 
387
        ibool           apply_log_recs;
 
388
                                /*!< this is TRUE when log rec application to
 
389
                                pages is allowed; this flag tells the
 
390
                                i/o-handler if it should do log record
 
391
                                application */
 
392
        ibool           apply_batch_on;
 
393
                                /*!< this is TRUE when a log rec application
 
394
                                batch is running */
 
395
        ib_uint64_t     lsn;    /*!< log sequence number */
 
396
        ulint           last_log_buf_size;
 
397
                                /*!< size of the log buffer when the database
 
398
                                last time wrote to the log */
 
399
        byte*           last_block;
 
400
                                /*!< possible incomplete last recovered log
 
401
                                block */
 
402
        byte*           last_block_buf_start;
 
403
                                /*!< the nonaligned start address of the
 
404
                                preceding buffer */
 
405
        byte*           buf;    /*!< buffer for parsing log records */
 
406
        ulint           len;    /*!< amount of data in buf */
 
407
        ib_uint64_t     parse_start_lsn;
 
408
                                /*!< this is the lsn from which we were able to
 
409
                                start parsing log records and adding them to
 
410
                                the hash table; zero if a suitable
 
411
                                start point not found yet */
 
412
        ib_uint64_t     scanned_lsn;
 
413
                                /*!< the log data has been scanned up to this
 
414
                                lsn */
 
415
        ulint           scanned_checkpoint_no;
 
416
                                /*!< the log data has been scanned up to this
 
417
                                checkpoint number (lowest 4 bytes) */
 
418
        ulint           recovered_offset;
 
419
                                /*!< start offset of non-parsed log records in
 
420
                                buf */
 
421
        ib_uint64_t     recovered_lsn;
 
422
                                /*!< the log records have been parsed up to
 
423
                                this lsn */
 
424
        ib_uint64_t     limit_lsn;/*!< recovery should be made at most
 
425
                                up to this lsn */
 
426
        ibool           found_corrupt_log;
 
427
                                /*!< this is set to TRUE if we during log
 
428
                                scan find a corrupt log block, or a corrupt
 
429
                                log record, or there is a log parsing
 
430
                                buffer overflow */
 
431
#ifdef UNIV_LOG_ARCHIVE
 
432
        log_group_t*    archive_group;
 
433
                                /*!< in archive recovery: the log group whose
 
434
                                archive is read */
 
435
#endif /* !UNIV_LOG_ARCHIVE */
 
436
        mem_heap_t*     heap;   /*!< memory heap of log records and file
 
437
                                addresses*/
 
438
        hash_table_t*   addr_hash;/*!< hash table of file addresses of pages */
 
439
        ulint           n_addrs;/*!< number of not processed hashed file
 
440
                                addresses in the hash table */
 
441
};
 
442
 
 
443
/** The recovery system */
 
444
extern recv_sys_t*      recv_sys;
 
445
 
 
446
/** TRUE when applying redo log records during crash recovery; FALSE
 
447
otherwise.  Note that this is FALSE while a background thread is
 
448
rolling back incomplete transactions. */
 
449
extern ibool            recv_recovery_on;
 
450
/** If the following is TRUE, the buffer pool file pages must be invalidated
 
451
after recovery and no ibuf operations are allowed; this becomes TRUE if
 
452
the log record hash table becomes too full, and log records must be merged
 
453
to file pages already before the recovery is finished: in this case no
 
454
ibuf operations are allowed, as they could modify the pages read in the
 
455
buffer pool before the pages have been recovered to the up-to-date state.
 
456
 
 
457
TRUE means that recovery is running and no operations on the log files
 
458
are allowed yet: the variable name is misleading. */
 
459
extern ibool            recv_no_ibuf_operations;
 
460
/** TRUE when recv_init_crash_recovery() has been called. */
 
461
extern ibool            recv_needed_recovery;
 
462
#ifdef UNIV_DEBUG
 
463
/** TRUE if writing to the redo log (mtr_commit) is forbidden.
 
464
Protected by log_sys->mutex. */
 
465
extern ibool            recv_no_log_write;
 
466
#endif /* UNIV_DEBUG */
 
467
 
 
468
/** TRUE if buf_page_is_corrupted() should check if the log sequence
 
469
number (FIL_PAGE_LSN) is in the future.  Initially FALSE, and set by
 
470
recv_recovery_from_checkpoint_start_func(). */
 
471
extern ibool            recv_lsn_checks_on;
 
472
#ifdef UNIV_HOTBACKUP
 
473
/** TRUE when the redo log is being backed up */
 
474
extern ibool            recv_is_making_a_backup;
 
475
#endif /* UNIV_HOTBACKUP */
 
476
/** Maximum page number encountered in the redo log */
 
477
extern ulint            recv_max_parsed_page_no;
 
478
 
 
479
/** Size of the parsing buffer; it must accommodate RECV_SCAN_SIZE many
 
480
times! */
 
481
#define RECV_PARSING_BUF_SIZE   (2 * 1024 * 1024)
 
482
 
 
483
/** Size of block reads when the log groups are scanned forward to do a
 
484
roll-forward */
 
485
#define RECV_SCAN_SIZE          (4 * UNIV_PAGE_SIZE)
 
486
 
 
487
/** This many frames must be left free in the buffer pool when we scan
 
488
the log and store the scanned log records in the buffer pool: we will
 
489
use these free frames to read in pages when we start applying the
 
490
log records to the database. */
 
491
extern ulint    recv_n_pool_free_frames;
 
492
 
 
493
#ifndef UNIV_NONINL
 
494
#include "log0recv.ic"
 
495
#endif
 
496
 
 
497
#endif