← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Monty Taylor
  • Date: 2008-12-18 07:24:54 UTC
  • mto: This revision was merged to the branch mainline in revision 714.
  • Revision ID: monty@bitters-20081218072454-8pnep622damjgqli
Fixed one more my_time thing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/log0log.h
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (C) 1995, 2010, Innobase Oy. All Rights Reserved.
4
 
Copyright (C) 2009 Google Inc.
5
 
 
6
 
Portions of this file contain modifications contributed and copyrighted by
7
 
Google, Inc. Those modifications are gratefully acknowledged and are described
8
 
briefly in the InnoDB documentation. The contributions by Google are
9
 
incorporated with their permission, and subject to the conditions contained in
10
 
the file COPYING.Google.
11
 
 
12
 
This program is free software; you can redistribute it and/or modify it under
13
 
the terms of the GNU General Public License as published by the Free Software
14
 
Foundation; version 2 of the License.
15
 
 
16
 
This program is distributed in the hope that it will be useful, but WITHOUT
17
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18
 
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
19
 
 
20
 
You should have received a copy of the GNU General Public License along with
21
 
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
22
 
St, Fifth Floor, Boston, MA 02110-1301 USA
23
 
 
24
 
*****************************************************************************/
25
 
 
26
 
/**************************************************//**
27
 
@file include/log0log.h
 
1
/******************************************************
28
2
Database log
29
3
 
 
4
(c) 1995 Innobase Oy
 
5
 
30
6
Created 12/9/1995 Heikki Tuuri
31
7
*******************************************************/
32
8
 
35
11
 
36
12
#include "univ.i"
37
13
#include "ut0byte.h"
38
 
#include "ut0lst.h"
39
 
#ifndef UNIV_HOTBACKUP
40
14
#include "sync0sync.h"
41
15
#include "sync0rw.h"
42
 
#endif /* !UNIV_HOTBACKUP */
43
16
 
44
 
/** Redo log buffer */
45
17
typedef struct log_struct       log_t;
46
 
/** Redo log group */
47
18
typedef struct log_group_struct log_group_t;
48
19
 
49
20
#ifdef UNIV_DEBUG
50
 
/** Flag: write to log file? */
51
21
extern  ibool   log_do_write;
52
 
/** Flag: enable debug output when writing to the log? */
53
22
extern  ibool   log_debug_writes;
54
23
#else /* UNIV_DEBUG */
55
 
/** Write to log */
56
24
# define log_do_write TRUE
57
25
#endif /* UNIV_DEBUG */
58
26
 
59
 
/** Wait modes for log_write_up_to @{ */
 
27
/* Wait modes for log_write_up_to */
60
28
#define LOG_NO_WAIT             91
61
29
#define LOG_WAIT_ONE_GROUP      92
62
30
#define LOG_WAIT_ALL_GROUPS     93
63
 
/* @} */
64
 
/** Maximum number of log groups in log_group_struct::checkpoint_buf */
65
31
#define LOG_MAX_N_GROUPS        32
66
32
 
67
 
#ifndef UNIV_HOTBACKUP
68
 
/****************************************************************//**
 
33
/********************************************************************
69
34
Sets the global variable log_fsp_current_free_limit. Also makes a checkpoint,
70
35
so that we know that the limit has been written to a log checkpoint field
71
36
on disk. */
73
38
void
74
39
log_fsp_current_free_limit_set_and_checkpoint(
75
40
/*==========================================*/
76
 
        ulint   limit); /*!< in: limit to set */
77
 
#endif /* !UNIV_HOTBACKUP */
78
 
/*******************************************************************//**
79
 
Calculates where in log files we find a specified lsn.
80
 
@return log file number */
 
41
        ulint   limit); /* in: limit to set */
 
42
/***********************************************************************
 
43
Calculates where in log files we find a specified lsn. */
81
44
UNIV_INTERN
82
45
ulint
83
46
log_calc_where_lsn_is(
84
47
/*==================*/
85
 
        ib_int64_t*     log_file_offset,        /*!< out: offset in that file
 
48
                                                /* out: log file number */
 
49
        ib_int64_t*     log_file_offset,        /* out: offset in that file
86
50
                                                (including the header) */
87
 
        ib_uint64_t     first_header_lsn,       /*!< in: first log file start
 
51
        ib_uint64_t     first_header_lsn,       /* in: first log file start
88
52
                                                lsn */
89
 
        ib_uint64_t     lsn,                    /*!< in: lsn whose position to
 
53
        ib_uint64_t     lsn,                    /* in: lsn whose position to
90
54
                                                determine */
91
 
        ulint           n_log_files,            /*!< in: total number of log
 
55
        ulint           n_log_files,            /* in: total number of log
92
56
                                                files */
93
 
        ib_int64_t      log_file_size);         /*!< in: log file size
 
57
        ib_int64_t      log_file_size);         /* in: log file size
94
58
                                                (including the header) */
95
 
#ifndef UNIV_HOTBACKUP
96
 
/************************************************************//**
 
59
/****************************************************************
97
60
Writes to the log the string given. The log must be released with
98
 
log_release.
99
 
@return end lsn of the log record, zero if did not succeed */
 
61
log_release. */
100
62
UNIV_INLINE
101
63
ib_uint64_t
102
64
log_reserve_and_write_fast(
103
65
/*=======================*/
104
 
        const void*     str,    /*!< in: string */
105
 
        ulint           len,    /*!< in: string length */
106
 
        ib_uint64_t*    start_lsn);/*!< out: start lsn of the log record */
107
 
/***********************************************************************//**
 
66
                                /* out: end lsn of the log record,
 
67
                                zero if did not succeed */
 
68
        byte*           str,    /* in: string */
 
69
        ulint           len,    /* in: string length */
 
70
        ib_uint64_t*    start_lsn,/* out: start lsn of the log record */
 
71
        ibool*          success);/* out: TRUE if success */
 
72
/***************************************************************************
108
73
Releases the log mutex. */
109
74
UNIV_INLINE
110
75
void
111
76
log_release(void);
112
77
/*=============*/
113
 
/***********************************************************************//**
 
78
/***************************************************************************
114
79
Checks if there is need for a log buffer flush or a new checkpoint, and does
115
80
this if yes. Any database operation should call this when it has modified
116
81
more than about 4 pages. NOTE that this function may only be called when the
119
84
void
120
85
log_free_check(void);
121
86
/*================*/
122
 
/************************************************************//**
 
87
/****************************************************************
123
88
Opens the log for log_write_low. The log must be closed with log_close and
124
 
released with log_release.
125
 
@return start lsn of the log record */
 
89
released with log_release. */
126
90
UNIV_INTERN
127
91
ib_uint64_t
128
92
log_reserve_and_open(
129
93
/*=================*/
130
 
        ulint   len);   /*!< in: length of data to be catenated */
131
 
/************************************************************//**
 
94
                        /* out: start lsn of the log record */
 
95
        ulint   len);   /* in: length of data to be catenated */
 
96
/****************************************************************
132
97
Writes to the log the string given. It is assumed that the caller holds the
133
98
log mutex. */
134
99
UNIV_INTERN
135
100
void
136
101
log_write_low(
137
102
/*==========*/
138
 
        byte*   str,            /*!< in: string */
139
 
        ulint   str_len);       /*!< in: string length */
140
 
/************************************************************//**
141
 
Closes the log.
142
 
@return lsn */
 
103
        byte*   str,            /* in: string */
 
104
        ulint   str_len);       /* in: string length */
 
105
/****************************************************************
 
106
Closes the log. */
143
107
UNIV_INTERN
144
108
ib_uint64_t
145
109
log_close(void);
146
110
/*===========*/
147
 
/************************************************************//**
148
 
Gets the current lsn.
149
 
@return current lsn */
 
111
                        /* out: lsn */
 
112
/****************************************************************
 
113
Gets the current lsn. */
150
114
UNIV_INLINE
151
115
ib_uint64_t
152
116
log_get_lsn(void);
153
117
/*=============*/
154
 
/****************************************************************
155
 
Gets the log group capacity. It is OK to read the value without
156
 
holding log_sys->mutex because it is constant.
157
 
@return log group capacity */
158
 
UNIV_INLINE
159
 
ulint
160
 
log_get_capacity(void);
161
 
/*==================*/
162
 
/******************************************************//**
 
118
                        /* out: current lsn */
 
119
/**********************************************************
163
120
Initializes the log. */
164
121
UNIV_INTERN
165
122
void
166
123
log_init(void);
167
124
/*==========*/
168
 
/******************************************************************//**
 
125
/**********************************************************************
169
126
Inits a log group to the log system. */
170
127
UNIV_INTERN
171
128
void
172
129
log_group_init(
173
130
/*===========*/
174
 
        ulint   id,                     /*!< in: group id */
175
 
        ulint   n_files,                /*!< in: number of log files */
176
 
        ulint   file_size,              /*!< in: log file size in bytes */
177
 
        ulint   space_id,               /*!< in: space id of the file space
 
131
        ulint   id,                     /* in: group id */
 
132
        ulint   n_files,                /* in: number of log files */
 
133
        ulint   file_size,              /* in: log file size in bytes */
 
134
        ulint   space_id,               /* in: space id of the file space
178
135
                                        which contains the log files of this
179
136
                                        group */
180
 
        ulint   archive_space_id);      /*!< in: space id of the file space
 
137
        ulint   archive_space_id);      /* in: space id of the file space
181
138
                                        which contains some archived log
182
139
                                        files for this group; currently, only
183
140
                                        for the first log group this is
184
141
                                        used */
185
 
/******************************************************//**
 
142
/**********************************************************
186
143
Completes an i/o to a log file. */
187
144
UNIV_INTERN
188
145
void
189
146
log_io_complete(
190
147
/*============*/
191
 
        log_group_t*    group); /*!< in: log group */
192
 
/******************************************************//**
 
148
        log_group_t*    group); /* in: log group */
 
149
/**********************************************************
193
150
This function is called, e.g., when a transaction wants to commit. It checks
194
151
that the log has been written to the log file up to the last log entry written
195
152
by the transaction. If there is a flush running, it waits and checks if the
198
155
void
199
156
log_write_up_to(
200
157
/*============*/
201
 
        ib_uint64_t     lsn,    /*!< in: log sequence number up to which
 
158
        ib_uint64_t     lsn,    /* in: log sequence number up to which
202
159
                                the log should be written,
203
160
                                IB_ULONGLONG_MAX if not specified */
204
 
        ulint           wait,   /*!< in: LOG_NO_WAIT, LOG_WAIT_ONE_GROUP,
 
161
        ulint           wait,   /* in: LOG_NO_WAIT, LOG_WAIT_ONE_GROUP,
205
162
                                or LOG_WAIT_ALL_GROUPS */
206
163
        ibool           flush_to_disk);
207
 
                                /*!< in: TRUE if we want the written log
 
164
                                /* in: TRUE if we want the written log
208
165
                                also to be flushed to disk */
209
 
/****************************************************************//**
 
166
/********************************************************************
210
167
Does a syncronous flush of the log buffer to disk. */
211
168
UNIV_INTERN
212
169
void
213
170
log_buffer_flush_to_disk(void);
214
171
/*==========================*/
215
 
/****************************************************************//**
216
 
This functions writes the log buffer to the log file and if 'flush'
217
 
is set it forces a flush of the log file as well. This is meant to be
218
 
called from background master thread only as it does not wait for
219
 
the write (+ possible flush) to finish. */
220
 
UNIV_INTERN
221
 
void
222
 
log_buffer_sync_in_background(
223
 
/*==========================*/
224
 
        ibool   flush); /*<! in: flush the logs to disk */
225
 
/****************************************************************//**
 
172
/********************************************************************
226
173
Advances the smallest lsn for which there are unflushed dirty blocks in the
227
174
buffer pool and also may make a new checkpoint. NOTE: this function may only
228
 
be called if the calling thread owns no synchronization objects!
229
 
@return FALSE if there was a flush batch of the same type running,
230
 
which means that we could not start this flush batch */
 
175
be called if the calling thread owns no synchronization objects! */
231
176
UNIV_INTERN
232
177
ibool
233
178
log_preflush_pool_modified_pages(
234
179
/*=============================*/
235
 
        ib_uint64_t     new_oldest,     /*!< in: try to advance
 
180
                                        /* out: FALSE if there was a
 
181
                                        flush batch of the same type
 
182
                                        running, which means that we
 
183
                                        could not start this flush
 
184
                                        batch */
 
185
        ib_uint64_t     new_oldest,     /* in: try to advance
236
186
                                        oldest_modified_lsn at least
237
187
                                        to this lsn */
238
 
        ibool           sync);          /*!< in: TRUE if synchronous
 
188
        ibool           sync);          /* in: TRUE if synchronous
239
189
                                        operation is desired */
240
 
/******************************************************//**
 
190
/**********************************************************
241
191
Makes a checkpoint. Note that this function does not flush dirty
242
192
blocks from the buffer pool: it only checks what is lsn of the oldest
243
193
modification in the pool, and writes information about the lsn in
244
 
log files. Use log_make_checkpoint_at to flush also the pool.
245
 
@return TRUE if success, FALSE if a checkpoint write was already running */
 
194
log files. Use log_make_checkpoint_at to flush also the pool. */
246
195
UNIV_INTERN
247
196
ibool
248
197
log_checkpoint(
249
198
/*===========*/
250
 
        ibool   sync,           /*!< in: TRUE if synchronous operation is
 
199
                                /* out: TRUE if success, FALSE if a checkpoint
 
200
                                write was already running */
 
201
        ibool   sync,           /* in: TRUE if synchronous operation is
251
202
                                desired */
252
 
        ibool   write_always);  /*!< in: the function normally checks if the
 
203
        ibool   write_always);  /* in: the function normally checks if the
253
204
                                the new checkpoint would have a greater
254
205
                                lsn than the previous one: if not, then no
255
206
                                physical write is done; by setting this
256
207
                                parameter TRUE, a physical write will always be
257
208
                                made to log files */
258
 
/****************************************************************//**
 
209
/********************************************************************
259
210
Makes a checkpoint at a given lsn or later. */
260
211
UNIV_INTERN
261
212
void
262
213
log_make_checkpoint_at(
263
214
/*===================*/
264
 
        ib_uint64_t     lsn,            /*!< in: make a checkpoint at this or a
 
215
        ib_uint64_t     lsn,            /* in: make a checkpoint at this or a
265
216
                                        later lsn, if IB_ULONGLONG_MAX, makes
266
217
                                        a checkpoint at the latest lsn */
267
 
        ibool           write_always);  /*!< in: the function normally checks if
 
218
        ibool           write_always);  /* in: the function normally checks if
268
219
                                        the the new checkpoint would have a
269
220
                                        greater lsn than the previous one: if
270
221
                                        not, then no physical write is done;
271
222
                                        by setting this parameter TRUE, a
272
223
                                        physical write will always be made to
273
224
                                        log files */
274
 
/****************************************************************//**
 
225
/********************************************************************
275
226
Makes a checkpoint at the latest lsn and writes it to first page of each
276
227
data file in the database, so that we know that the file spaces contain
277
228
all modifications up to that lsn. This can only be called at database
280
231
void
281
232
logs_empty_and_mark_files_at_shutdown(void);
282
233
/*=======================================*/
283
 
/******************************************************//**
 
234
/**********************************************************
284
235
Reads a checkpoint info from a log group header to log_sys->checkpoint_buf. */
285
236
UNIV_INTERN
286
237
void
287
238
log_group_read_checkpoint_info(
288
239
/*===========================*/
289
 
        log_group_t*    group,  /*!< in: log group */
290
 
        ulint           field); /*!< in: LOG_CHECKPOINT_1 or LOG_CHECKPOINT_2 */
291
 
/*******************************************************************//**
 
240
        log_group_t*    group,  /* in: log group */
 
241
        ulint           field); /* in: LOG_CHECKPOINT_1 or LOG_CHECKPOINT_2 */
 
242
/***********************************************************************
292
243
Gets info from a checkpoint about a log group. */
293
244
UNIV_INTERN
294
245
void
295
246
log_checkpoint_get_nth_group_info(
296
247
/*==============================*/
297
 
        const byte*     buf,    /*!< in: buffer containing checkpoint info */
298
 
        ulint           n,      /*!< in: nth slot */
299
 
        ulint*          file_no,/*!< out: archived file number */
300
 
        ulint*          offset);/*!< out: archived file offset */
301
 
/******************************************************//**
 
248
        byte*   buf,    /* in: buffer containing checkpoint info */
 
249
        ulint   n,      /* in: nth slot */
 
250
        ulint*  file_no,/* out: archived file number */
 
251
        ulint*  offset);/* out: archived file offset */
 
252
/**********************************************************
302
253
Writes checkpoint info to groups. */
303
254
UNIV_INTERN
304
255
void
305
256
log_groups_write_checkpoint_info(void);
306
257
/*==================================*/
307
 
/********************************************************************//**
308
 
Starts an archiving operation.
309
 
@return TRUE if succeed, FALSE if an archiving operation was already running */
 
258
/**********************************************************
 
259
Writes info to a buffer of a log group when log files are created in
 
260
backup restoration. */
 
261
UNIV_INTERN
 
262
void
 
263
log_reset_first_header_and_checkpoint(
 
264
/*==================================*/
 
265
        byte*           hdr_buf,/* in: buffer which will be written to the
 
266
                                start of the first log file */
 
267
        ib_uint64_t     start); /* in: lsn of the start of the first log file;
 
268
                                we pretend that there is a checkpoint at
 
269
                                start + LOG_BLOCK_HDR_SIZE */
 
270
/************************************************************************
 
271
Starts an archiving operation. */
310
272
UNIV_INTERN
311
273
ibool
312
274
log_archive_do(
313
275
/*===========*/
314
 
        ibool   sync,   /*!< in: TRUE if synchronous operation is desired */
315
 
        ulint*  n_bytes);/*!< out: archive log buffer size, 0 if nothing to
 
276
                        /* out: TRUE if succeed, FALSE if an archiving
 
277
                        operation was already running */
 
278
        ibool   sync,   /* in: TRUE if synchronous operation is desired */
 
279
        ulint*  n_bytes);/* out: archive log buffer size, 0 if nothing to
316
280
                        archive */
317
 
/****************************************************************//**
 
281
/********************************************************************
318
282
Writes the log contents to the archive up to the lsn when this function was
319
283
called, and stops the archiving. When archiving is started again, the archived
320
284
log file numbers start from a number one higher, so that the archiving will
321
285
not write again to the archived log files which exist when this function
322
 
returns.
323
 
@return DB_SUCCESS or DB_ERROR */
 
286
returns. */
324
287
UNIV_INTERN
325
288
ulint
326
289
log_archive_stop(void);
327
290
/*==================*/
328
 
/****************************************************************//**
329
 
Starts again archiving which has been stopped.
330
 
@return DB_SUCCESS or DB_ERROR */
 
291
                                /* out: DB_SUCCESS or DB_ERROR */
 
292
/********************************************************************
 
293
Starts again archiving which has been stopped. */
331
294
UNIV_INTERN
332
295
ulint
333
296
log_archive_start(void);
334
297
/*===================*/
335
 
/****************************************************************//**
336
 
Stop archiving the log so that a gap may occur in the archived log files.
337
 
@return DB_SUCCESS or DB_ERROR */
 
298
                        /* out: DB_SUCCESS or DB_ERROR */
 
299
/********************************************************************
 
300
Stop archiving the log so that a gap may occur in the archived log files. */
338
301
UNIV_INTERN
339
302
ulint
340
303
log_archive_noarchivelog(void);
341
304
/*==========================*/
342
 
/****************************************************************//**
343
 
Start archiving the log so that a gap may occur in the archived log files.
344
 
@return DB_SUCCESS or DB_ERROR */
 
305
                        /* out: DB_SUCCESS or DB_ERROR */
 
306
/********************************************************************
 
307
Start archiving the log so that a gap may occur in the archived log files. */
345
308
UNIV_INTERN
346
309
ulint
347
310
log_archive_archivelog(void);
348
311
/*========================*/
349
 
/******************************************************//**
 
312
                        /* out: DB_SUCCESS or DB_ERROR */
 
313
/**********************************************************
350
314
Generates an archived log file name. */
351
315
UNIV_INTERN
352
316
void
353
317
log_archived_file_name_gen(
354
318
/*=======================*/
355
 
        char*   buf,    /*!< in: buffer where to write */
356
 
        ulint   id,     /*!< in: group id */
357
 
        ulint   file_no);/*!< in: file number */
358
 
#else /* !UNIV_HOTBACKUP */
359
 
/******************************************************//**
360
 
Writes info to a buffer of a log group when log files are created in
361
 
backup restoration. */
362
 
UNIV_INTERN
363
 
void
364
 
log_reset_first_header_and_checkpoint(
365
 
/*==================================*/
366
 
        byte*           hdr_buf,/*!< in: buffer which will be written to the
367
 
                                start of the first log file */
368
 
        ib_uint64_t     start); /*!< in: lsn of the start of the first log file;
369
 
                                we pretend that there is a checkpoint at
370
 
                                start + LOG_BLOCK_HDR_SIZE */
371
 
#endif /* !UNIV_HOTBACKUP */
372
 
/********************************************************************//**
 
319
        char*   buf,    /* in: buffer where to write */
 
320
        ulint   id,     /* in: group id */
 
321
        ulint   file_no);/* in: file number */
 
322
/************************************************************************
373
323
Checks that there is enough free space in the log to start a new query step.
374
324
Flushes the log buffer or makes a new checkpoint if necessary. NOTE: this
375
325
function may only be called if the calling thread owns no synchronization
378
328
void
379
329
log_check_margins(void);
380
330
/*===================*/
381
 
#ifndef UNIV_HOTBACKUP
382
 
/******************************************************//**
 
331
/**********************************************************
383
332
Reads a specified log segment to a buffer. */
384
333
UNIV_INTERN
385
334
void
386
335
log_group_read_log_seg(
387
336
/*===================*/
388
 
        ulint           type,           /*!< in: LOG_ARCHIVE or LOG_RECOVER */
389
 
        byte*           buf,            /*!< in: buffer where to read */
390
 
        log_group_t*    group,          /*!< in: log group */
391
 
        ib_uint64_t     start_lsn,      /*!< in: read area start */
392
 
        ib_uint64_t     end_lsn);       /*!< in: read area end */
393
 
/******************************************************//**
 
337
        ulint           type,           /* in: LOG_ARCHIVE or LOG_RECOVER */
 
338
        byte*           buf,            /* in: buffer where to read */
 
339
        log_group_t*    group,          /* in: log group */
 
340
        ib_uint64_t     start_lsn,      /* in: read area start */
 
341
        ib_uint64_t     end_lsn);       /* in: read area end */
 
342
/**********************************************************
394
343
Writes a buffer to a log file group. */
395
344
UNIV_INTERN
396
345
void
397
346
log_group_write_buf(
398
347
/*================*/
399
 
        log_group_t*    group,          /*!< in: log group */
400
 
        byte*           buf,            /*!< in: buffer */
401
 
        ulint           len,            /*!< in: buffer len; must be divisible
 
348
        log_group_t*    group,          /* in: log group */
 
349
        byte*           buf,            /* in: buffer */
 
350
        ulint           len,            /* in: buffer len; must be divisible
402
351
                                        by OS_FILE_LOG_BLOCK_SIZE */
403
 
        ib_uint64_t     start_lsn,      /*!< in: start lsn of the buffer; must
 
352
        ib_uint64_t     start_lsn,      /* in: start lsn of the buffer; must
404
353
                                        be divisible by
405
354
                                        OS_FILE_LOG_BLOCK_SIZE */
406
 
        ulint           new_data_offset);/*!< in: start offset of new data in
 
355
        ulint           new_data_offset);/* in: start offset of new data in
407
356
                                        buf: this parameter is used to decide
408
357
                                        if we have to write a new log file
409
358
                                        header */
410
 
/********************************************************//**
 
359
/************************************************************
411
360
Sets the field values in group to correspond to a given lsn. For this function
412
361
to work, the values must already be correctly initialized to correspond to
413
362
some lsn, for instance, a checkpoint lsn. */
415
364
void
416
365
log_group_set_fields(
417
366
/*=================*/
418
 
        log_group_t*    group,  /*!< in/out: group */
419
 
        ib_uint64_t     lsn);   /*!< in: lsn for which the values should be
 
367
        log_group_t*    group,  /* in: group */
 
368
        ib_uint64_t     lsn);   /* in: lsn for which the values should be
420
369
                                set */
421
 
/******************************************************//**
 
370
/**********************************************************
422
371
Calculates the data capacity of a log group, when the log file headers are not
423
 
included.
424
 
@return capacity in bytes */
 
372
included. */
425
373
UNIV_INTERN
426
374
ulint
427
375
log_group_get_capacity(
428
376
/*===================*/
429
 
        const log_group_t*      group); /*!< in: log group */
430
 
#endif /* !UNIV_HOTBACKUP */
431
 
/************************************************************//**
432
 
Gets a log block flush bit.
433
 
@return TRUE if this block was the first to be written in a log flush */
 
377
                                /* out: capacity in bytes */
 
378
        log_group_t*    group); /* in: log group */
 
379
/****************************************************************
 
380
Gets a log block flush bit. */
434
381
UNIV_INLINE
435
382
ibool
436
383
log_block_get_flush_bit(
437
384
/*====================*/
438
 
        const byte*     log_block);     /*!< in: log block */
439
 
/************************************************************//**
440
 
Gets a log block number stored in the header.
441
 
@return log block number stored in the block header */
 
385
                                /* out: TRUE if this block was the first
 
386
                                to be written in a log flush */
 
387
        byte*   log_block);     /* in: log block */
 
388
/****************************************************************
 
389
Gets a log block number stored in the header. */
442
390
UNIV_INLINE
443
391
ulint
444
392
log_block_get_hdr_no(
445
393
/*=================*/
446
 
        const byte*     log_block);     /*!< in: log block */
447
 
/************************************************************//**
448
 
Gets a log block data length.
449
 
@return log block data length measured as a byte offset from the block start */
 
394
                                /* out: log block number stored in the block
 
395
                                header */
 
396
        byte*   log_block);     /* in: log block */
 
397
/****************************************************************
 
398
Gets a log block data length. */
450
399
UNIV_INLINE
451
400
ulint
452
401
log_block_get_data_len(
453
402
/*===================*/
454
 
        const byte*     log_block);     /*!< in: log block */
455
 
/************************************************************//**
 
403
                                /* out: log block data length measured as a
 
404
                                byte offset from the block start */
 
405
        byte*   log_block);     /* in: log block */
 
406
/****************************************************************
456
407
Sets the log block data length. */
457
408
UNIV_INLINE
458
409
void
459
410
log_block_set_data_len(
460
411
/*===================*/
461
 
        byte*   log_block,      /*!< in/out: log block */
462
 
        ulint   len);           /*!< in: data length */
463
 
/************************************************************//**
464
 
Calculates the checksum for a log block.
465
 
@return checksum */
 
412
        byte*   log_block,      /* in: log block */
 
413
        ulint   len);           /* in: data length */
 
414
/****************************************************************
 
415
Calculates the checksum for a log block. */
466
416
UNIV_INLINE
467
417
ulint
468
418
log_block_calc_checksum(
469
419
/*====================*/
470
 
        const byte*     block); /*!< in: log block */
471
 
/************************************************************//**
472
 
Gets a log block checksum field value.
473
 
@return checksum */
 
420
                                /* out: checksum */
 
421
        const byte*     block); /* in: log block */
 
422
/****************************************************************
 
423
Gets a log block checksum field value. */
474
424
UNIV_INLINE
475
425
ulint
476
426
log_block_get_checksum(
477
427
/*===================*/
478
 
        const byte*     log_block);     /*!< in: log block */
479
 
/************************************************************//**
 
428
                                        /* out: checksum */
 
429
        const byte*     log_block);     /* in: log block */
 
430
/****************************************************************
480
431
Sets a log block checksum field value. */
481
432
UNIV_INLINE
482
433
void
483
434
log_block_set_checksum(
484
435
/*===================*/
485
 
        byte*   log_block,      /*!< in/out: log block */
486
 
        ulint   checksum);      /*!< in: checksum */
487
 
/************************************************************//**
488
 
Gets a log block first mtr log record group offset.
489
 
@return first mtr log record group byte offset from the block start, 0
490
 
if none */
 
436
        byte*   log_block,      /* in: log block */
 
437
        ulint   checksum);      /* in: checksum */
 
438
/****************************************************************
 
439
Gets a log block first mtr log record group offset. */
491
440
UNIV_INLINE
492
441
ulint
493
442
log_block_get_first_rec_group(
494
443
/*==========================*/
495
 
        const byte*     log_block);     /*!< in: log block */
496
 
/************************************************************//**
 
444
                                /* out: first mtr log record group byte offset
 
445
                                from the block start, 0 if none */
 
446
        byte*   log_block);     /* in: log block */
 
447
/****************************************************************
497
448
Sets the log block first mtr log record group offset. */
498
449
UNIV_INLINE
499
450
void
500
451
log_block_set_first_rec_group(
501
452
/*==========================*/
502
 
        byte*   log_block,      /*!< in/out: log block */
503
 
        ulint   offset);        /*!< in: offset, 0 if none */
504
 
/************************************************************//**
505
 
Gets a log block checkpoint number field (4 lowest bytes).
506
 
@return checkpoint no (4 lowest bytes) */
 
453
        byte*   log_block,      /* in: log block */
 
454
        ulint   offset);        /* in: offset, 0 if none */
 
455
/****************************************************************
 
456
Gets a log block checkpoint number field (4 lowest bytes). */
507
457
UNIV_INLINE
508
458
ulint
509
459
log_block_get_checkpoint_no(
510
460
/*========================*/
511
 
        const byte*     log_block);     /*!< in: log block */
512
 
/************************************************************//**
 
461
                                /* out: checkpoint no (4 lowest bytes) */
 
462
        byte*   log_block);     /* in: log block */
 
463
/****************************************************************
513
464
Initializes a log block in the log buffer. */
514
465
UNIV_INLINE
515
466
void
516
467
log_block_init(
517
468
/*===========*/
518
 
        byte*           log_block,      /*!< in: pointer to the log buffer */
519
 
        ib_uint64_t     lsn);           /*!< in: lsn within the log block */
520
 
/************************************************************//**
 
469
        byte*           log_block,      /* in: pointer to the log buffer */
 
470
        ib_uint64_t     lsn);           /* in: lsn within the log block */
 
471
/****************************************************************
521
472
Initializes a log block in the log buffer in the old, < 3.23.52 format, where
522
473
there was no checksum yet. */
523
474
UNIV_INLINE
524
475
void
525
476
log_block_init_in_old_format(
526
477
/*=========================*/
527
 
        byte*           log_block,      /*!< in: pointer to the log buffer */
528
 
        ib_uint64_t     lsn);           /*!< in: lsn within the log block */
529
 
/************************************************************//**
530
 
Converts a lsn to a log block number.
531
 
@return log block number, it is > 0 and <= 1G */
 
478
        byte*           log_block,      /* in: pointer to the log buffer */
 
479
        ib_uint64_t     lsn);           /* in: lsn within the log block */
 
480
/****************************************************************
 
481
Converts a lsn to a log block number. */
532
482
UNIV_INLINE
533
483
ulint
534
484
log_block_convert_lsn_to_no(
535
485
/*========================*/
536
 
        ib_uint64_t     lsn);   /*!< in: lsn of a byte within the block */
537
 
/******************************************************//**
 
486
                                /* out: log block number,
 
487
                                it is > 0 and <= 1G */
 
488
        ib_uint64_t     lsn);   /* in: lsn of a byte within the block */
 
489
/**********************************************************
538
490
Prints info of the log. */
539
491
UNIV_INTERN
540
492
void
541
493
log_print(
542
494
/*======*/
543
 
        FILE*   file);  /*!< in: file where to print */
544
 
/******************************************************//**
545
 
Peeks the current lsn.
546
 
@return TRUE if success, FALSE if could not get the log system mutex */
 
495
        FILE*   file);  /* in: file where to print */
 
496
/**********************************************************
 
497
Peeks the current lsn. */
547
498
UNIV_INTERN
548
499
ibool
549
500
log_peek_lsn(
550
501
/*=========*/
551
 
        ib_uint64_t*    lsn);   /*!< out: if returns TRUE, current lsn is here */
552
 
/**********************************************************************//**
 
502
                                /* out: TRUE if success, FALSE if
 
503
                                could not get the log system mutex */
 
504
        ib_uint64_t*    lsn);   /* out: if returns TRUE, current lsn is here */
 
505
/**************************************************************************
553
506
Refreshes the statistics used to print per-second averages. */
554
507
UNIV_INTERN
555
508
void
556
509
log_refresh_stats(void);
557
510
/*===================*/
558
 
/**********************************************************
559
 
Shutdown the log system but do not release all the memory. */
560
 
UNIV_INTERN
561
 
void
562
 
log_shutdown(void);
563
 
/*==============*/
564
 
/**********************************************************
565
 
Free the log system data structures. */
566
 
UNIV_INTERN
567
 
void
568
 
log_mem_free(void);
569
 
/*==============*/
570
511
 
571
512
extern log_t*   log_sys;
572
513
 
573
514
/* Values used as flags */
574
515
#define LOG_FLUSH       7652559
575
516
#define LOG_CHECKPOINT  78656949
576
 
#ifdef UNIV_LOG_ARCHIVE
577
 
# define LOG_ARCHIVE    11122331
578
 
#endif /* UNIV_LOG_ARCHIVE */
 
517
#define LOG_ARCHIVE     11122331
579
518
#define LOG_RECOVER     98887331
580
519
 
581
520
/* The counting of lsn's starts from this value: this must be non-zero */
582
 
#define LOG_START_LSN           ((ib_uint64_t) (16 * OS_FILE_LOG_BLOCK_SIZE))
 
521
#define LOG_START_LSN   ((ib_uint64_t) (16 * OS_FILE_LOG_BLOCK_SIZE))
583
522
 
584
523
#define LOG_BUFFER_SIZE         (srv_log_buffer_size * UNIV_PAGE_SIZE)
585
524
#define LOG_ARCHIVE_BUF_SIZE    (srv_log_buffer_size * UNIV_PAGE_SIZE / 4)
631
570
#define LOG_CHECKPOINT_ARCHIVED_LSN     24
632
571
#define LOG_CHECKPOINT_GROUP_ARRAY      32
633
572
 
634
 
/* For each value smaller than LOG_MAX_N_GROUPS the following 8 bytes: */
 
573
/* For each value < LOG_MAX_N_GROUPS the following 8 bytes: */
635
574
 
636
575
#define LOG_CHECKPOINT_ARCHIVED_FILE_NO 0
637
576
#define LOG_CHECKPOINT_ARCHIVED_OFFSET  4
699
638
#define LOG_GROUP_OK            301
700
639
#define LOG_GROUP_CORRUPTED     302
701
640
 
702
 
/** Log group consists of a number of log files, each of the same size; a log
 
641
/* Log group consists of a number of log files, each of the same size; a log
703
642
group is implemented as a space in the sense of the module fil0fil. */
 
643
 
704
644
struct log_group_struct{
705
645
        /* The following fields are protected by log_sys->mutex */
706
 
        ulint           id;             /*!< log group id */
707
 
        ulint           n_files;        /*!< number of files in the group */
708
 
        ulint           file_size;      /*!< individual log file size in bytes,
 
646
        ulint           id;             /* log group id */
 
647
        ulint           n_files;        /* number of files in the group */
 
648
        ulint           file_size;      /* individual log file size in bytes,
709
649
                                        including the log file header */
710
 
        ulint           space_id;       /*!< file space which implements the log
 
650
        ulint           space_id;       /* file space which implements the log
711
651
                                        group */
712
 
        ulint           state;          /*!< LOG_GROUP_OK or
 
652
        ulint           state;          /* LOG_GROUP_OK or
713
653
                                        LOG_GROUP_CORRUPTED */
714
 
        ib_uint64_t     lsn;            /*!< lsn used to fix coordinates within
 
654
        ib_uint64_t     lsn;            /* lsn used to fix coordinates within
715
655
                                        the log group */
716
 
        ulint           lsn_offset;     /*!< the offset of the above lsn */
717
 
        ulint           n_pending_writes;/*!< number of currently pending flush
 
656
        ulint           lsn_offset;     /* the offset of the above lsn */
 
657
        ulint           n_pending_writes;/* number of currently pending flush
718
658
                                        writes for this log group */
719
 
        byte**          file_header_bufs_ptr;/*!< unaligned buffers */
720
 
        byte**          file_header_bufs;/*!< buffers for each file
721
 
                                        header in the group */
722
 
#ifdef UNIV_LOG_ARCHIVE
 
659
        byte**          file_header_bufs;/* buffers for each file header in the
 
660
                                        group */
723
661
        /*-----------------------------*/
724
 
        byte**          archive_file_header_bufs_ptr;/*!< unaligned buffers */
725
 
        byte**          archive_file_header_bufs;/*!< buffers for each file
 
662
        byte**          archive_file_header_bufs;/* buffers for each file
726
663
                                        header in the group */
727
 
        ulint           archive_space_id;/*!< file space which
728
 
                                        implements the log group
729
 
                                        archive */
730
 
        ulint           archived_file_no;/*!< file number corresponding to
 
664
        ulint           archive_space_id;/* file space which implements the log
 
665
                                        group archive */
 
666
        ulint           archived_file_no;/* file number corresponding to
731
667
                                        log_sys->archived_lsn */
732
 
        ulint           archived_offset;/*!< file offset corresponding to
 
668
        ulint           archived_offset;/* file offset corresponding to
733
669
                                        log_sys->archived_lsn, 0 if we have
734
670
                                        not yet written to the archive file
735
671
                                        number archived_file_no */
736
 
        ulint           next_archived_file_no;/*!< during an archive write,
 
672
        ulint           next_archived_file_no;/* during an archive write,
737
673
                                        until the write is completed, we
738
674
                                        store the next value for
739
675
                                        archived_file_no here: the write
740
676
                                        completion function then sets the new
741
677
                                        value to ..._file_no */
742
 
        ulint           next_archived_offset; /*!< like the preceding field */
743
 
#endif /* UNIV_LOG_ARCHIVE */
 
678
        ulint           next_archived_offset; /* like the preceding field */
744
679
        /*-----------------------------*/
745
 
        ib_uint64_t     scanned_lsn;    /*!< used only in recovery: recovery scan
 
680
        ib_uint64_t     scanned_lsn;    /* used only in recovery: recovery scan
746
681
                                        succeeded up to this lsn in this log
747
682
                                        group */
748
 
        byte*           checkpoint_buf_ptr;/*!< unaligned checkpoint header */
749
 
        byte*           checkpoint_buf; /*!< checkpoint header is written from
 
683
        byte*           checkpoint_buf; /* checkpoint header is written from
750
684
                                        this buffer to the group */
751
685
        UT_LIST_NODE_T(log_group_t)
752
 
                        log_groups;     /*!< list of log groups */
 
686
                        log_groups;     /* list of log groups */
753
687
};
754
688
 
755
 
/** Redo log buffer */
756
689
struct log_struct{
757
 
        byte            pad[64];        /*!< padding to prevent other memory
 
690
        byte            pad[64];        /* padding to prevent other memory
758
691
                                        update hotspots from residing on the
759
692
                                        same memory cache line */
760
 
        ib_uint64_t     lsn;            /*!< log sequence number */
761
 
        ulint           buf_free;       /*!< first free offset within the log
 
693
        ib_uint64_t     lsn;            /* log sequence number */
 
694
        ulint           buf_free;       /* first free offset within the log
762
695
                                        buffer */
763
 
#ifndef UNIV_HOTBACKUP
764
 
        mutex_t         mutex;          /*!< mutex protecting the log */
765
 
#endif /* !UNIV_HOTBACKUP */
766
 
 
767
 
        mutex_t         log_flush_order_mutex;/*!< mutex to serialize access to
768
 
                                        the flush list when we are putting
769
 
                                        dirty blocks in the list. The idea
770
 
                                        behind this mutex is to be able
771
 
                                        to release log_sys->mutex during
772
 
                                        mtr_commit and still ensure that
773
 
                                        insertions in the flush_list happen
774
 
                                        in the LSN order. */
775
 
        byte*           buf_ptr;        /* unaligned log buffer */
776
 
        byte*           buf;            /*!< log buffer */
777
 
        ulint           buf_size;       /*!< log buffer size in bytes */
778
 
        ulint           max_buf_free;   /*!< recommended maximum value of
 
696
        mutex_t         mutex;          /* mutex protecting the log */
 
697
        byte*           buf;            /* log buffer */
 
698
        ulint           buf_size;       /* log buffer size in bytes */
 
699
        ulint           max_buf_free;   /* recommended maximum value of
779
700
                                        buf_free, after which the buffer is
780
701
                                        flushed */
781
 
        ulint           old_buf_free;   /*!< value of buf free when log was
 
702
        ulint           old_buf_free;   /* value of buf free when log was
782
703
                                        last time opened; only in the debug
783
704
                                        version */
784
 
        ib_uint64_t     old_lsn;        /*!< value of lsn when log was
785
 
                                        last time opened; only in the
786
 
                                        debug version */
 
705
        ib_uint64_t     old_lsn;        /* value of lsn when log was last time
 
706
                                        opened; only in the debug version */
787
707
        ibool           check_flush_or_checkpoint;
788
 
                                        /*!< this is set to TRUE when there may
 
708
                                        /* this is set to TRUE when there may
789
709
                                        be need to flush the log buffer, or
790
710
                                        preflush buffer pool pages, or make
791
711
                                        a checkpoint; this MUST be TRUE when
794
714
                                        peeked at by log_free_check(), which
795
715
                                        does not reserve the log mutex */
796
716
        UT_LIST_BASE_NODE_T(log_group_t)
797
 
                        log_groups;     /*!< log groups */
798
 
 
799
 
#ifndef UNIV_HOTBACKUP
800
 
        /** The fields involved in the log buffer flush @{ */
801
 
 
802
 
        ulint           buf_next_to_write;/*!< first offset in the log buffer
 
717
                        log_groups;     /* log groups */
 
718
 
 
719
        /* The fields involved in the log buffer flush */
 
720
 
 
721
        ulint           buf_next_to_write;/* first offset in the log buffer
803
722
                                        where the byte content may not exist
804
723
                                        written to file, e.g., the start
805
724
                                        offset of a log record catenated
807
726
                                        operation is completed to all the log
808
727
                                        groups */
809
728
        ib_uint64_t     written_to_some_lsn;
810
 
                                        /*!< first log sequence number not yet
 
729
                                        /* first log sequence number not yet
811
730
                                        written to any log group; for this to
812
731
                                        be advanced, it is enough that the
813
732
                                        write i/o has been completed for any
814
733
                                        one log group */
815
734
        ib_uint64_t     written_to_all_lsn;
816
 
                                        /*!< first log sequence number not yet
 
735
                                        /* first log sequence number not yet
817
736
                                        written to some log group; for this to
818
737
                                        be advanced, it is enough that the
819
738
                                        write i/o has been completed for all
820
 
                                        log groups.
821
 
                                        Note that since InnoDB currently
822
 
                                        has only one log group therefore
823
 
                                        this value is redundant. Also it
824
 
                                        is possible that this value
825
 
                                        falls behind the
826
 
                                        flushed_to_disk_lsn transiently.
827
 
                                        It is appropriate to use either
828
 
                                        flushed_to_disk_lsn or
829
 
                                        write_lsn which are always
830
 
                                        up-to-date and accurate. */
831
 
        ib_uint64_t     write_lsn;      /*!< end lsn for the current running
 
739
                                        log groups */
 
740
        ib_uint64_t     write_lsn;      /* end lsn for the current running
832
741
                                        write */
833
 
        ulint           write_end_offset;/*!< the data in buffer has
834
 
                                        been written up to this offset
835
 
                                        when the current write ends:
836
 
                                        this field will then be copied
837
 
                                        to buf_next_to_write */
838
 
        ib_uint64_t     current_flush_lsn;/*!< end lsn for the current running
 
742
        ulint           write_end_offset;/* the data in buffer has been written
 
743
                                        up to this offset when the current
 
744
                                        write ends: this field will then
 
745
                                        be copied to buf_next_to_write */
 
746
        ib_uint64_t     current_flush_lsn;/* end lsn for the current running
839
747
                                        write + flush operation */
840
748
        ib_uint64_t     flushed_to_disk_lsn;
841
 
                                        /*!< how far we have written the log
 
749
                                        /* how far we have written the log
842
750
                                        AND flushed to disk */
843
 
        ulint           n_pending_writes;/*!< number of currently
844
 
                                        pending flushes or writes */
 
751
        ulint           n_pending_writes;/* number of currently pending flushes
 
752
                                        or writes */
845
753
        /* NOTE on the 'flush' in names of the fields below: starting from
846
754
        4.0.14, we separate the write of the log file and the actual fsync()
847
755
        or other method to flush it to disk. The names below shhould really
848
756
        be 'flush_or_write'! */
849
 
        os_event_t      no_flush_event; /*!< this event is in the reset state
 
757
        os_event_t      no_flush_event; /* this event is in the reset state
850
758
                                        when a flush or a write is running;
851
759
                                        a thread should wait for this without
852
760
                                        owning the log mutex, but NOTE that
853
761
                                        to set or reset this event, the
854
762
                                        thread MUST own the log mutex! */
855
 
        ibool           one_flushed;    /*!< during a flush, this is
856
 
                                        first FALSE and becomes TRUE
857
 
                                        when one log group has been
858
 
                                        written or flushed */
859
 
        os_event_t      one_flushed_event;/*!< this event is reset when the
 
763
        ibool           one_flushed;    /* during a flush, this is first FALSE
 
764
                                        and becomes TRUE when one log group
 
765
                                        has been written or flushed */
 
766
        os_event_t      one_flushed_event;/* this event is reset when the
860
767
                                        flush or write has not yet completed
861
768
                                        for any log group; e.g., this means
862
769
                                        that a transaction has been committed
865
772
                                        but NOTE that to set or reset this
866
773
                                        event, the thread MUST own the log
867
774
                                        mutex! */
868
 
        ulint           n_log_ios;      /*!< number of log i/os initiated thus
 
775
        ulint           n_log_ios;      /* number of log i/os initiated thus
869
776
                                        far */
870
 
        ulint           n_log_ios_old;  /*!< number of log i/o's at the
 
777
        ulint           n_log_ios_old;  /* number of log i/o's at the
871
778
                                        previous printout */
872
 
        time_t          last_printout_time;/*!< when log_print was last time
 
779
        time_t          last_printout_time;/* when log_print was last time
873
780
                                        called */
874
 
        /* @} */
875
781
 
876
 
        /** Fields involved in checkpoints @{ */
877
 
        ulint           log_group_capacity; /*!< capacity of the log group; if
 
782
        /* Fields involved in checkpoints */
 
783
        ulint           log_group_capacity; /* capacity of the log group; if
878
784
                                        the checkpoint age exceeds this, it is
879
785
                                        a serious error because it is possible
880
786
                                        we will then overwrite log and spoil
881
787
                                        crash recovery */
882
788
        ulint           max_modified_age_async;
883
 
                                        /*!< when this recommended
884
 
                                        value for lsn -
885
 
                                        buf_pool_get_oldest_modification()
886
 
                                        is exceeded, we start an
887
 
                                        asynchronous preflush of pool pages */
 
789
                                        /* when this recommended value for lsn
 
790
                                        - buf_pool_get_oldest_modification()
 
791
                                        is exceeded, we start an asynchronous
 
792
                                        preflush of pool pages */
888
793
        ulint           max_modified_age_sync;
889
 
                                        /*!< when this recommended
890
 
                                        value for lsn -
891
 
                                        buf_pool_get_oldest_modification()
892
 
                                        is exceeded, we start a
893
 
                                        synchronous preflush of pool pages */
 
794
                                        /* when this recommended value for lsn
 
795
                                        - buf_pool_get_oldest_modification()
 
796
                                        is exceeded, we start a synchronous
 
797
                                        preflush of pool pages */
894
798
        ulint           adm_checkpoint_interval;
895
 
                                        /*!< administrator-specified checkpoint
 
799
                                        /* administrator-specified checkpoint
896
800
                                        interval in terms of log growth in
897
801
                                        bytes; the interval actually used by
898
802
                                        the database can be smaller */
899
803
        ulint           max_checkpoint_age_async;
900
 
                                        /*!< when this checkpoint age
901
 
                                        is exceeded we start an
902
 
                                        asynchronous writing of a new
903
 
                                        checkpoint */
 
804
                                        /* when this checkpoint age is exceeded
 
805
                                        we start an asynchronous writing of a
 
806
                                        new checkpoint */
904
807
        ulint           max_checkpoint_age;
905
 
                                        /*!< this is the maximum allowed value
 
808
                                        /* this is the maximum allowed value
906
809
                                        for lsn - last_checkpoint_lsn when a
907
810
                                        new query step is started */
908
811
        ib_uint64_t     next_checkpoint_no;
909
 
                                        /*!< next checkpoint number */
 
812
                                        /* next checkpoint number */
910
813
        ib_uint64_t     last_checkpoint_lsn;
911
 
                                        /*!< latest checkpoint lsn */
 
814
                                        /* latest checkpoint lsn */
912
815
        ib_uint64_t     next_checkpoint_lsn;
913
 
                                        /*!< next checkpoint lsn */
 
816
                                        /* next checkpoint lsn */
914
817
        ulint           n_pending_checkpoint_writes;
915
 
                                        /*!< number of currently pending
 
818
                                        /* number of currently pending
916
819
                                        checkpoint writes */
917
 
        rw_lock_t       checkpoint_lock;/*!< this latch is x-locked when a
 
820
        rw_lock_t       checkpoint_lock;/* this latch is x-locked when a
918
821
                                        checkpoint write is running; a thread
919
822
                                        should wait for this without owning
920
823
                                        the log mutex */
921
 
#endif /* !UNIV_HOTBACKUP */
922
 
        byte*           checkpoint_buf_ptr;/* unaligned checkpoint header */
923
 
        byte*           checkpoint_buf; /*!< checkpoint header is read to this
 
824
        byte*           checkpoint_buf; /* checkpoint header is read to this
924
825
                                        buffer */
925
 
        /* @} */
926
826
#ifdef UNIV_LOG_ARCHIVE
927
 
        /** Fields involved in archiving @{ */
928
 
        ulint           archiving_state;/*!< LOG_ARCH_ON, LOG_ARCH_STOPPING
 
827
        /* Fields involved in archiving */
 
828
        ulint           archiving_state;/* LOG_ARCH_ON, LOG_ARCH_STOPPING
929
829
                                        LOG_ARCH_STOPPED, LOG_ARCH_OFF */
930
 
        ib_uint64_t     archived_lsn;   /*!< archiving has advanced to this
 
830
        ib_uint64_t     archived_lsn;   /* archiving has advanced to this
931
831
                                        lsn */
932
832
        ulint           max_archived_lsn_age_async;
933
 
                                        /*!< recommended maximum age of
 
833
                                        /* recommended maximum age of
934
834
                                        archived_lsn, before we start
935
835
                                        asynchronous copying to the archive */
936
836
        ulint           max_archived_lsn_age;
937
 
                                        /*!< maximum allowed age for
 
837
                                        /* maximum allowed age for
938
838
                                        archived_lsn */
939
 
        ib_uint64_t     next_archived_lsn;/*!< during an archive write,
 
839
        ib_uint64_t     next_archived_lsn;/* during an archive write,
940
840
                                        until the write is completed, we
941
841
                                        store the next value for
942
842
                                        archived_lsn here: the write
943
843
                                        completion function then sets the new
944
844
                                        value to archived_lsn */
945
 
        ulint           archiving_phase;/*!< LOG_ARCHIVE_READ or
 
845
        ulint           archiving_phase;/* LOG_ARCHIVE_READ or
946
846
                                        LOG_ARCHIVE_WRITE */
947
847
        ulint           n_pending_archive_ios;
948
 
                                        /*!< number of currently pending reads
 
848
                                        /* number of currently pending reads
949
849
                                        or writes in archiving */
950
 
        rw_lock_t       archive_lock;   /*!< this latch is x-locked when an
 
850
        rw_lock_t       archive_lock;   /* this latch is x-locked when an
951
851
                                        archive write is running; a thread
952
852
                                        should wait for this without owning
953
853
                                        the log mutex */
954
 
        ulint           archive_buf_size;/*!< size of archive_buf */
955
 
        byte*           archive_buf;    /*!< log segment is written to the
 
854
        ulint           archive_buf_size;/* size of archive_buf */
 
855
        byte*           archive_buf;    /* log segment is written to the
956
856
                                        archive from this buffer */
957
 
        os_event_t      archiving_on;   /*!< if archiving has been stopped,
 
857
        os_event_t      archiving_on;   /* if archiving has been stopped,
958
858
                                        a thread can wait for this event to
959
859
                                        become signaled */
960
 
        /* @} */
961
860
#endif /* UNIV_LOG_ARCHIVE */
962
861
};
963
862
 
964
 
/** Test if flush order mutex is owned. */
965
 
#define log_flush_order_mutex_own()     \
966
 
        mutex_own(&log_sys->log_flush_order_mutex)
967
 
 
968
 
/** Acquire the flush order mutex. */
969
 
#define log_flush_order_mutex_enter() do {              \
970
 
        mutex_enter(&log_sys->log_flush_order_mutex);   \
971
 
} while (0)
972
 
/** Release the flush order mutex. */
973
 
# define log_flush_order_mutex_exit() do {              \
974
 
        mutex_exit(&log_sys->log_flush_order_mutex);    \
975
 
} while (0)
976
 
 
977
 
#ifdef UNIV_LOG_ARCHIVE
978
 
/** Archiving state @{ */
979
863
#define LOG_ARCH_ON             71
980
864
#define LOG_ARCH_STOPPING       72
981
865
#define LOG_ARCH_STOPPING2      73
982
866
#define LOG_ARCH_STOPPED        74
983
867
#define LOG_ARCH_OFF            75
984
 
/* @} */
985
 
#endif /* UNIV_LOG_ARCHIVE */
986
868
 
987
869
#ifndef UNIV_NONINL
988
870
#include "log0log.ic"