← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Patrick Galbraith
  • Date: 2010-10-03 13:40:30 UTC
  • mto: (1812.1.3 build)
  • mto: This revision was merged to the branch mainline in revision 1813.
  • Revision ID: patg@patg-desktop-20101003134030-j13wf1e79za77jtf
Added license to start_mc.sh.in to clear up ambiguity

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