log0recv.h 12.7 KB
Newer Older
osku's avatar
osku committed
1 2 3 4 5 6 7 8 9 10 11 12 13
/******************************************************
Recovery

(c) 1997 Innobase Oy

Created 9/20/1997 Heikki Tuuri
*******************************************************/

#ifndef log0recv_h
#define log0recv_h

#include "univ.i"
#include "ut0byte.h"
14
#include "buf0types.h"
osku's avatar
osku committed
15 16 17 18 19 20 21 22
#include "hash0hash.h"
#include "log0log.h"

#ifdef UNIV_HOTBACKUP
extern ibool	recv_replay_file_ops;

/***********************************************************************
Reads the checkpoint info needed in hot backup. */
23
UNIV_INTERN
osku's avatar
osku committed
24 25 26
ibool
recv_read_cp_info_for_backup(
/*=========================*/
27 28 29
				/* out: TRUE if success */
	byte*		hdr,	/* in: buffer containing the log group
				header */
30
	ib_uint64_t*	lsn,	/* out: checkpoint lsn */
31 32 33 34
	ulint*		offset,	/* out: checkpoint offset in the log group */
	ulint*		fsp_limit,/* out: fsp limit of space 0,
				1000000000 if the database is running
				with < version 3.23.50 of InnoDB */
35 36
	ib_uint64_t*	cp_no,	/* out: checkpoint number */
	ib_uint64_t*	first_header_lsn);
37 38
				/* out: lsn of of the start of the
				first log file */
osku's avatar
osku committed
39 40 41
/***********************************************************************
Scans the log segment and n_bytes_scanned is set to the length of valid
log scanned. */
42
UNIV_INTERN
osku's avatar
osku committed
43 44 45 46 47
void
recv_scan_log_seg_for_backup(
/*=========================*/
	byte*		buf,		/* in: buffer containing log data */
	ulint		buf_len,	/* in: data length in that buffer */
48
	ib_uint64_t*	scanned_lsn,	/* in/out: lsn of buffer start,
osku's avatar
osku committed
49 50 51 52 53 54 55 56
					we return scanned lsn */
	ulint*		scanned_checkpoint_no,
					/* in/out: 4 lowest bytes of the
					highest scanned checkpoint number so
					far */
	ulint*		n_bytes_scanned);/* out: how much we were able to
					scan, smaller than buf_len if log
					data ended here */
57
#endif /* UNIV_HOTBACKUP */
osku's avatar
osku committed
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
/***********************************************************************
Returns TRUE if recovery is currently running. */
UNIV_INLINE
ibool
recv_recovery_is_on(void);
/*=====================*/
/***********************************************************************
Returns TRUE if recovery from backup is currently running. */
UNIV_INLINE
ibool
recv_recovery_from_backup_is_on(void);
/*=================================*/
/****************************************************************************
Applies the hashed log records to the page, if the page lsn is less than the
lsn of a log record. This can be called when a buffer page has just been
read in, or also for a page already in the buffer pool. */
74
UNIV_INTERN
osku's avatar
osku committed
75 76 77
void
recv_recover_page(
/*==============*/
78 79
	ibool		recover_backup,
				/* in: TRUE if we are recovering a backup
osku's avatar
osku committed
80 81 82
				page: then we do not acquire any latches
				since the page was read in outside the
				buffer pool */
83 84
	ibool		just_read_in,
				/* in: TRUE if the i/o-handler calls this for
osku's avatar
osku committed
85
				a freshly read page */
86
	buf_block_t*	block);	/* in: buffer block */
osku's avatar
osku committed
87 88 89 90 91
/************************************************************
Recovers from a checkpoint. When this function returns, the database is able
to start processing of new user transactions, but the function
recv_recovery_from_checkpoint_finish should be called later to complete
the recovery and free the resources used in it. */
92
UNIV_INTERN
osku's avatar
osku committed
93
ulint
94 95
recv_recovery_from_checkpoint_start_func(
/*=====================================*/
96
					/* out: error code or DB_SUCCESS */
97
#ifdef UNIV_LOG_ARCHIVE
98
	ulint		type,		/* in: LOG_CHECKPOINT or LOG_ARCHIVE */
99
	ib_uint64_t	limit_lsn,	/* in: recover up to this lsn
100
					if possible */
101
#endif /* UNIV_LOG_ARCHIVE */
102
	ib_uint64_t	min_flushed_lsn,/* in: min flushed lsn from
103
					data files */
104
	ib_uint64_t	max_flushed_lsn);/* in: max flushed lsn from
105
					 data files */
106 107 108 109 110 111 112
#ifdef UNIV_LOG_ARCHIVE
# define recv_recovery_from_checkpoint_start(type,lim,min,max)		\
	recv_recovery_from_checkpoint_start_func(type,lim,min,max)
#else /* UNIV_LOG_ARCHIVE */
# define recv_recovery_from_checkpoint_start(type,lim,min,max)		\
	recv_recovery_from_checkpoint_start_func(min,max)
#endif /* UNIV_LOG_ARCHIVE */
osku's avatar
osku committed
113 114
/************************************************************
Completes recovery from a checkpoint. */
115
UNIV_INTERN
osku's avatar
osku committed
116 117 118 119 120 121
void
recv_recovery_from_checkpoint_finish(void);
/*======================================*/
/***********************************************************
Scans log from a buffer and stores new log data to the parsing buffer. Parses
and hashes the log records if new data found. */
122
UNIV_INTERN
osku's avatar
osku committed
123 124 125
ibool
recv_scan_log_recs(
/*===============*/
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
					/* out: TRUE if limit_lsn has been
					reached, or not able to scan any more
					in this log group */
	ibool		apply_automatically,/* in: TRUE if we want this
					function to apply log records
					automatically when the hash table
					becomes full; in the hot backup tool
					the tool does the applying, not this
					function */
	ulint		available_memory,/* in: we let the hash table of recs
					to grow to this size, at the maximum */
	ibool		store_to_hash,	/* in: TRUE if the records should be
					stored to the hash table; this is set
					to FALSE if just debug checking is
					needed */
	byte*		buf,		/* in: buffer containing a log segment
					or garbage */
	ulint		len,		/* in: buffer length */
144 145
	ib_uint64_t	start_lsn,	/* in: buffer start lsn */
	ib_uint64_t*	contiguous_lsn,	/* in/out: it is known that all log
146 147
					groups contain contiguous log data up
					to this lsn */
148
	ib_uint64_t*	group_scanned_lsn);/* out: scanning succeeded up to
149
					this lsn */
osku's avatar
osku committed
150 151
/**********************************************************
Resets the logs. The contents of log files will be lost! */
152
UNIV_INTERN
osku's avatar
osku committed
153 154 155
void
recv_reset_logs(
/*============*/
156
	ib_uint64_t	lsn,		/* in: reset to this lsn
157 158 159 160
					rounded up to be divisible by
					OS_FILE_LOG_BLOCK_SIZE, after
					which we add
					LOG_BLOCK_HDR_SIZE */
osku's avatar
osku committed
161
#ifdef UNIV_LOG_ARCHIVE
162
	ulint		arch_log_no,	/* in: next archived log file number */
osku's avatar
osku committed
163
#endif /* UNIV_LOG_ARCHIVE */
164 165 166 167
	ibool		new_logs_created);/* in: TRUE if resetting logs
					is done at the log creation;
					FALSE if it is done after
					archive recovery */
osku's avatar
osku committed
168 169 170
#ifdef UNIV_HOTBACKUP
/**********************************************************
Creates new log files after a backup has been restored. */
171
UNIV_INTERN
osku's avatar
osku committed
172 173 174 175 176 177
void
recv_reset_log_files_for_backup(
/*============================*/
	const char*	log_dir,	/* in: log file directory path */
	ulint		n_log_files,	/* in: number of log files */
	ulint		log_file_size,	/* in: log file size */
178
	ib_uint64_t	lsn);		/* in: new start lsn, must be
osku's avatar
osku committed
179 180 181 182
					divisible by OS_FILE_LOG_BLOCK_SIZE */
#endif /* UNIV_HOTBACKUP */
/************************************************************
Creates the recovery system. */
183
UNIV_INTERN
osku's avatar
osku committed
184 185 186 187 188
void
recv_sys_create(void);
/*=================*/
/************************************************************
Inits the recovery system for a recovery operation. */
189
UNIV_INTERN
osku's avatar
osku committed
190 191 192 193 194 195 196 197 198
void
recv_sys_init(
/*==========*/
	ibool	recover_from_backup,	/* in: TRUE if this is called
					to recover from a hot backup */
	ulint	available_memory);	/* in: available memory in bytes */
/***********************************************************************
Empties the hash table of stored log records, applying them to appropriate
pages. */
199
UNIV_INTERN
osku's avatar
osku committed
200 201 202 203 204 205 206 207 208 209 210 211 212
void
recv_apply_hashed_log_recs(
/*=======================*/
	ibool	allow_ibuf);	/* in: if TRUE, also ibuf operations are
				allowed during the application; if FALSE,
				no ibuf operations are allowed, and after
				the application all file pages are flushed to
				disk and invalidated in buffer pool: this
				alternative means that no new log records
				can be generated during the application */
#ifdef UNIV_HOTBACKUP
/***********************************************************************
Applies log records in the hash table to a backup. */
213
UNIV_INTERN
osku's avatar
osku committed
214 215 216 217 218 219 220
void
recv_apply_log_recs_for_backup(void);
/*================================*/
#endif
#ifdef UNIV_LOG_ARCHIVE
/************************************************************
Recovers from archived log files, and also from log files, if they exist. */
221
UNIV_INTERN
osku's avatar
osku committed
222 223 224
ulint
recv_recovery_from_archive_start(
/*=============================*/
225
					/* out: error code or DB_SUCCESS */
226
	ib_uint64_t	min_flushed_lsn,/* in: min flushed lsn field from the
227
					data files */
228
	ib_uint64_t	limit_lsn,	/* in: recover up to this lsn if
229 230 231 232 233 234
					possible */
	ulint		first_log_no);	/* in: number of the first archived
					log file to use in the recovery; the
					file will be searched from
					INNOBASE_LOG_ARCH_DIR specified in
					server config file */
osku's avatar
osku committed
235 236
/************************************************************
Completes recovery from archive. */
237
UNIV_INTERN
osku's avatar
osku committed
238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
void
recv_recovery_from_archive_finish(void);
/*===================================*/
#endif /* UNIV_LOG_ARCHIVE */

/* Block of log record data */
typedef struct recv_data_struct	recv_data_t;
struct recv_data_struct{
	recv_data_t*	next;	/* pointer to the next block or NULL */
				/* the log record data is stored physically
				immediately after this struct, max amount
				RECV_DATA_BLOCK_SIZE bytes of it */
};

/* Stored log record struct */
typedef struct recv_struct	recv_t;
struct recv_struct{
	byte		type;	/* log record type */
	ulint		len;	/* log record body length in bytes */
	recv_data_t*	data;	/* chain of blocks containing the log record
				body */
259
	ib_uint64_t	start_lsn;/* start lsn of the log segment written by
osku's avatar
osku committed
260 261 262
				the mtr which generated this log record: NOTE
				that this is not necessarily the start lsn of
				this log record */
263
	ib_uint64_t	end_lsn;/* end lsn of the log segment written by
osku's avatar
osku committed
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
				the mtr which generated this log record: NOTE
				that this is not necessarily the end lsn of
				this log record */
	UT_LIST_NODE_T(recv_t)
			rec_list;/* list of log records for this page */
};

/* Hashed page file address struct */
typedef struct recv_addr_struct	recv_addr_t;
struct recv_addr_struct{
	ulint		state;	/* RECV_NOT_PROCESSED, RECV_BEING_PROCESSED,
				or RECV_PROCESSED */
	ulint		space;	/* space id */
	ulint		page_no;/* page number */
	UT_LIST_BASE_NODE_T(recv_t)
			rec_list;/* list of log records for this page */
	hash_node_t	addr_hash;
};

/* Recovery system data structure */
typedef struct recv_sys_struct	recv_sys_t;
struct recv_sys_struct{
	mutex_t		mutex;	/* mutex protecting the fields apply_log_recs,
				n_addrs, and the state field in each recv_addr
				struct */
	ibool		apply_log_recs;
				/* this is TRUE when log rec application to
				pages is allowed; this flag tells the
				i/o-handler if it should do log record
				application */
	ibool		apply_batch_on;
				/* this is TRUE when a log rec application
				batch is running */
297
	ib_uint64_t	lsn;	/* log sequence number */
osku's avatar
osku committed
298 299 300 301 302 303 304 305 306 307 308
	ulint		last_log_buf_size;
				/* size of the log buffer when the database
				last time wrote to the log */
	byte*		last_block;
				/* possible incomplete last recovered log
				block */
	byte*		last_block_buf_start;
				/* the nonaligned start address of the
				preceding buffer */
	byte*		buf;	/* buffer for parsing log records */
	ulint		len;	/* amount of data in buf */
309
	ib_uint64_t	parse_start_lsn;
osku's avatar
osku committed
310 311
				/* this is the lsn from which we were able to
				start parsing log records and adding them to
312
				the hash table; zero if a suitable
osku's avatar
osku committed
313
				start point not found yet */
314
	ib_uint64_t	scanned_lsn;
osku's avatar
osku committed
315 316 317 318 319 320 321 322
				/* the log data has been scanned up to this
				lsn */
	ulint		scanned_checkpoint_no;
				/* the log data has been scanned up to this
				checkpoint number (lowest 4 bytes) */
	ulint		recovered_offset;
				/* start offset of non-parsed log records in
				buf */
323
	ib_uint64_t	recovered_lsn;
osku's avatar
osku committed
324 325
				/* the log records have been parsed up to
				this lsn */
326
	ib_uint64_t	limit_lsn;/* recovery should be made at most up to this
osku's avatar
osku committed
327 328 329 330 331 332
				lsn */
	ibool		found_corrupt_log;
				/* this is set to TRUE if we during log
				scan find a corrupt log block, or a corrupt
				log record, or there is a log parsing
				buffer overflow */
333
#ifdef UNIV_LOG_ARCHIVE
osku's avatar
osku committed
334 335 336
	log_group_t*	archive_group;
				/* in archive recovery: the log group whose
				archive is read */
337
#endif /* !UNIV_LOG_ARCHIVE */
osku's avatar
osku committed
338 339 340 341 342 343 344 345 346 347 348 349
	mem_heap_t*	heap;	/* memory heap of log records and file
				addresses*/
	hash_table_t*	addr_hash;/* hash table of file addresses of pages */
	ulint		n_addrs;/* number of not processed hashed file
				addresses in the hash table */
};

extern recv_sys_t*	recv_sys;
extern ibool		recv_recovery_on;
extern ibool		recv_no_ibuf_operations;
extern ibool		recv_needed_recovery;

350
extern ibool		recv_lsn_checks_on;
osku's avatar
osku committed
351 352 353 354 355 356
#ifdef UNIV_HOTBACKUP
extern ibool		recv_is_making_a_backup;
#endif /* UNIV_HOTBACKUP */
extern ulint		recv_max_parsed_page_no;

/* Size of the parsing buffer; it must accommodate RECV_SCAN_SIZE many
357
times! */
osku's avatar
osku committed
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
#define RECV_PARSING_BUF_SIZE	(2 * 1024 * 1024)

/* Size of block reads when the log groups are scanned forward to do a
roll-forward */
#define RECV_SCAN_SIZE		(4 * UNIV_PAGE_SIZE)

/* States of recv_addr_struct */
#define RECV_NOT_PROCESSED	71
#define RECV_BEING_READ		72
#define RECV_BEING_PROCESSED	73
#define RECV_PROCESSED		74

extern ulint	recv_n_pool_free_frames;

#ifndef UNIV_NONINL
#include "log0recv.ic"
#endif

#endif