1
/******************************************************
6
Created 12/9/1995 Heikki Tuuri
7
*******************************************************/
14
#include "sync0sync.h"
17
typedef struct log_struct log_t;
18
typedef struct log_group_struct log_group_t;
21
extern ibool log_do_write;
22
extern ibool log_debug_writes;
23
#else /* UNIV_DEBUG */
24
# define log_do_write TRUE
25
#endif /* UNIV_DEBUG */
27
/* Wait modes for log_write_up_to */
28
#define LOG_NO_WAIT 91
29
#define LOG_WAIT_ONE_GROUP 92
30
#define LOG_WAIT_ALL_GROUPS 93
31
#define LOG_MAX_N_GROUPS 32
33
/********************************************************************
34
Sets the global variable log_fsp_current_free_limit. Also makes a checkpoint,
35
so that we know that the limit has been written to a log checkpoint field
39
log_fsp_current_free_limit_set_and_checkpoint(
40
/*==========================================*/
41
ulint limit); /* in: limit to set */
42
/***********************************************************************
43
Calculates where in log files we find a specified lsn. */
46
log_calc_where_lsn_is(
47
/*==================*/
48
/* out: log file number */
49
ib_int64_t* log_file_offset, /* out: offset in that file
50
(including the header) */
51
ib_uint64_t first_header_lsn, /* in: first log file start
53
ib_uint64_t lsn, /* in: lsn whose position to
55
ulint n_log_files, /* in: total number of log
57
ib_int64_t log_file_size); /* in: log file size
58
(including the header) */
59
/****************************************************************
60
Writes to the log the string given. The log must be released with
64
log_reserve_and_write_fast(
65
/*=======================*/
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
/***************************************************************************
73
Releases the log mutex. */
78
/***************************************************************************
79
Checks if there is need for a log buffer flush or a new checkpoint, and does
80
this if yes. Any database operation should call this when it has modified
81
more than about 4 pages. NOTE that this function may only be called when the
82
OS thread owns no synchronization objects except the dictionary mutex. */
87
/****************************************************************
88
Opens the log for log_write_low. The log must be closed with log_close and
89
released with log_release. */
94
/* out: start lsn of the log record */
95
ulint len); /* in: length of data to be catenated */
96
/****************************************************************
97
Writes to the log the string given. It is assumed that the caller holds the
103
byte* str, /* in: string */
104
ulint str_len); /* in: string length */
105
/****************************************************************
112
/****************************************************************
113
Gets the current lsn. */
118
/* out: current lsn */
119
/**********************************************************
120
Initializes the log. */
125
/**********************************************************************
126
Inits a log group to the log system. */
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
135
which contains the log files of this
137
ulint archive_space_id); /* in: space id of the file space
138
which contains some archived log
139
files for this group; currently, only
140
for the first log group this is
142
/**********************************************************
143
Completes an i/o to a log file. */
148
log_group_t* group); /* in: log group */
149
/**********************************************************
150
This function is called, e.g., when a transaction wants to commit. It checks
151
that the log has been written to the log file up to the last log entry written
152
by the transaction. If there is a flush running, it waits and checks if the
153
flush flushed enough. If not, starts a new flush. */
158
ib_uint64_t lsn, /* in: log sequence number up to which
159
the log should be written,
160
IB_ULONGLONG_MAX if not specified */
161
ulint wait, /* in: LOG_NO_WAIT, LOG_WAIT_ONE_GROUP,
162
or LOG_WAIT_ALL_GROUPS */
163
ibool flush_to_disk);
164
/* in: TRUE if we want the written log
165
also to be flushed to disk */
166
/********************************************************************
167
Does a syncronous flush of the log buffer to disk. */
170
log_buffer_flush_to_disk(void);
171
/*==========================*/
172
/********************************************************************
173
Advances the smallest lsn for which there are unflushed dirty blocks in the
174
buffer pool and also may make a new checkpoint. NOTE: this function may only
175
be called if the calling thread owns no synchronization objects! */
178
log_preflush_pool_modified_pages(
179
/*=============================*/
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
185
ib_uint64_t new_oldest, /* in: try to advance
186
oldest_modified_lsn at least
188
ibool sync); /* in: TRUE if synchronous
189
operation is desired */
190
/**********************************************************
191
Makes a checkpoint. Note that this function does not flush dirty
192
blocks from the buffer pool: it only checks what is lsn of the oldest
193
modification in the pool, and writes information about the lsn in
194
log files. Use log_make_checkpoint_at to flush also the pool. */
199
/* out: TRUE if success, FALSE if a checkpoint
200
write was already running */
201
ibool sync, /* in: TRUE if synchronous operation is
203
ibool write_always); /* in: the function normally checks if the
204
the new checkpoint would have a greater
205
lsn than the previous one: if not, then no
206
physical write is done; by setting this
207
parameter TRUE, a physical write will always be
209
/********************************************************************
210
Makes a checkpoint at a given lsn or later. */
213
log_make_checkpoint_at(
214
/*===================*/
215
ib_uint64_t lsn, /* in: make a checkpoint at this or a
216
later lsn, if IB_ULONGLONG_MAX, makes
217
a checkpoint at the latest lsn */
218
ibool write_always); /* in: the function normally checks if
219
the the new checkpoint would have a
220
greater lsn than the previous one: if
221
not, then no physical write is done;
222
by setting this parameter TRUE, a
223
physical write will always be made to
225
/********************************************************************
226
Makes a checkpoint at the latest lsn and writes it to first page of each
227
data file in the database, so that we know that the file spaces contain
228
all modifications up to that lsn. This can only be called at database
229
shutdown. This function also writes all log in log files to the log archive. */
232
logs_empty_and_mark_files_at_shutdown(void);
233
/*=======================================*/
234
/**********************************************************
235
Reads a checkpoint info from a log group header to log_sys->checkpoint_buf. */
238
log_group_read_checkpoint_info(
239
/*===========================*/
240
log_group_t* group, /* in: log group */
241
ulint field); /* in: LOG_CHECKPOINT_1 or LOG_CHECKPOINT_2 */
242
/***********************************************************************
243
Gets info from a checkpoint about a log group. */
246
log_checkpoint_get_nth_group_info(
247
/*==============================*/
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
/**********************************************************
253
Writes checkpoint info to groups. */
256
log_groups_write_checkpoint_info(void);
257
/*==================================*/
258
/**********************************************************
259
Writes info to a buffer of a log group when log files are created in
260
backup restoration. */
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. */
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
281
/********************************************************************
282
Writes the log contents to the archive up to the lsn when this function was
283
called, and stops the archiving. When archiving is started again, the archived
284
log file numbers start from a number one higher, so that the archiving will
285
not write again to the archived log files which exist when this function
289
log_archive_stop(void);
290
/*==================*/
291
/* out: DB_SUCCESS or DB_ERROR */
292
/********************************************************************
293
Starts again archiving which has been stopped. */
296
log_archive_start(void);
297
/*===================*/
298
/* out: DB_SUCCESS or DB_ERROR */
299
/********************************************************************
300
Stop archiving the log so that a gap may occur in the archived log files. */
303
log_archive_noarchivelog(void);
304
/*==========================*/
305
/* out: DB_SUCCESS or DB_ERROR */
306
/********************************************************************
307
Start archiving the log so that a gap may occur in the archived log files. */
310
log_archive_archivelog(void);
311
/*========================*/
312
/* out: DB_SUCCESS or DB_ERROR */
313
/**********************************************************
314
Generates an archived log file name. */
317
log_archived_file_name_gen(
318
/*=======================*/
319
char* buf, /* in: buffer where to write */
320
ulint id, /* in: group id */
321
ulint file_no);/* in: file number */
322
/************************************************************************
323
Checks that there is enough free space in the log to start a new query step.
324
Flushes the log buffer or makes a new checkpoint if necessary. NOTE: this
325
function may only be called if the calling thread owns no synchronization
329
log_check_margins(void);
330
/*===================*/
331
/**********************************************************
332
Reads a specified log segment to a buffer. */
335
log_group_read_log_seg(
336
/*===================*/
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
/**********************************************************
343
Writes a buffer to a log file group. */
348
log_group_t* group, /* in: log group */
349
byte* buf, /* in: buffer */
350
ulint len, /* in: buffer len; must be divisible
351
by OS_FILE_LOG_BLOCK_SIZE */
352
ib_uint64_t start_lsn, /* in: start lsn of the buffer; must
354
OS_FILE_LOG_BLOCK_SIZE */
355
ulint new_data_offset);/* in: start offset of new data in
356
buf: this parameter is used to decide
357
if we have to write a new log file
359
/************************************************************
360
Sets the field values in group to correspond to a given lsn. For this function
361
to work, the values must already be correctly initialized to correspond to
362
some lsn, for instance, a checkpoint lsn. */
365
log_group_set_fields(
366
/*=================*/
367
log_group_t* group, /* in: group */
368
ib_uint64_t lsn); /* in: lsn for which the values should be
370
/**********************************************************
371
Calculates the data capacity of a log group, when the log file headers are not
375
log_group_get_capacity(
376
/*===================*/
377
/* out: capacity in bytes */
378
log_group_t* group); /* in: log group */
379
/****************************************************************
380
Gets a log block flush bit. */
383
log_block_get_flush_bit(
384
/*====================*/
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. */
392
log_block_get_hdr_no(
393
/*=================*/
394
/* out: log block number stored in the block
396
byte* log_block); /* in: log block */
397
/****************************************************************
398
Gets a log block data length. */
401
log_block_get_data_len(
402
/*===================*/
403
/* out: log block data length measured as a
404
byte offset from the block start */
405
byte* log_block); /* in: log block */
406
/****************************************************************
407
Sets the log block data length. */
410
log_block_set_data_len(
411
/*===================*/
412
byte* log_block, /* in: log block */
413
ulint len); /* in: data length */
414
/****************************************************************
415
Calculates the checksum for a log block. */
418
log_block_calc_checksum(
419
/*====================*/
421
const byte* block); /* in: log block */
422
/****************************************************************
423
Gets a log block checksum field value. */
426
log_block_get_checksum(
427
/*===================*/
429
const byte* log_block); /* in: log block */
430
/****************************************************************
431
Sets a log block checksum field value. */
434
log_block_set_checksum(
435
/*===================*/
436
byte* log_block, /* in: log block */
437
ulint checksum); /* in: checksum */
438
/****************************************************************
439
Gets a log block first mtr log record group offset. */
442
log_block_get_first_rec_group(
443
/*==========================*/
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
/****************************************************************
448
Sets the log block first mtr log record group offset. */
451
log_block_set_first_rec_group(
452
/*==========================*/
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). */
459
log_block_get_checkpoint_no(
460
/*========================*/
461
/* out: checkpoint no (4 lowest bytes) */
462
byte* log_block); /* in: log block */
463
/****************************************************************
464
Initializes a log block in the log buffer. */
469
byte* log_block, /* in: pointer to the log buffer */
470
ib_uint64_t lsn); /* in: lsn within the log block */
471
/****************************************************************
472
Initializes a log block in the log buffer in the old, < 3.23.52 format, where
473
there was no checksum yet. */
476
log_block_init_in_old_format(
477
/*=========================*/
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. */
484
log_block_convert_lsn_to_no(
485
/*========================*/
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
/**********************************************************
490
Prints info of the log. */
495
FILE* file); /* in: file where to print */
496
/**********************************************************
497
Peeks the current lsn. */
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
/**************************************************************************
506
Refreshes the statistics used to print per-second averages. */
509
log_refresh_stats(void);
510
/*===================*/
512
extern log_t* log_sys;
514
/* Values used as flags */
515
#define LOG_FLUSH 7652559
516
#define LOG_CHECKPOINT 78656949
517
#define LOG_ARCHIVE 11122331
518
#define LOG_RECOVER 98887331
520
/* The counting of lsn's starts from this value: this must be non-zero */
521
#define LOG_START_LSN ((ib_uint64_t) (16 * OS_FILE_LOG_BLOCK_SIZE))
523
#define LOG_BUFFER_SIZE (srv_log_buffer_size * UNIV_PAGE_SIZE)
524
#define LOG_ARCHIVE_BUF_SIZE (srv_log_buffer_size * UNIV_PAGE_SIZE / 4)
526
/* Offsets of a log block header */
527
#define LOG_BLOCK_HDR_NO 0 /* block number which must be > 0 and
528
is allowed to wrap around at 2G; the
529
highest bit is set to 1 if this is the
530
first log block in a log flush write
532
#define LOG_BLOCK_FLUSH_BIT_MASK 0x80000000UL
533
/* mask used to get the highest bit in
534
the preceding field */
535
#define LOG_BLOCK_HDR_DATA_LEN 4 /* number of bytes of log written to
537
#define LOG_BLOCK_FIRST_REC_GROUP 6 /* offset of the first start of an
538
mtr log record group in this log block,
539
0 if none; if the value is the same
540
as LOG_BLOCK_HDR_DATA_LEN, it means
541
that the first rec group has not yet
542
been catenated to this log block, but
543
if it will, it will start at this
544
offset; an archive recovery can
545
start parsing the log records starting
546
from this offset in this log block,
548
#define LOG_BLOCK_CHECKPOINT_NO 8 /* 4 lower bytes of the value of
549
log_sys->next_checkpoint_no when the
550
log block was last written to: if the
551
block has not yet been written full,
552
this value is only updated before a
554
#define LOG_BLOCK_HDR_SIZE 12 /* size of the log block header in
557
/* Offsets of a log block trailer from the end of the block */
558
#define LOG_BLOCK_CHECKSUM 4 /* 4 byte checksum of the log block
559
contents; in InnoDB versions
560
< 3.23.52 this did not contain the
561
checksum but the same value as
563
#define LOG_BLOCK_TRL_SIZE 4 /* trailer size in bytes */
565
/* Offsets for a checkpoint field */
566
#define LOG_CHECKPOINT_NO 0
567
#define LOG_CHECKPOINT_LSN 8
568
#define LOG_CHECKPOINT_OFFSET 16
569
#define LOG_CHECKPOINT_LOG_BUF_SIZE 20
570
#define LOG_CHECKPOINT_ARCHIVED_LSN 24
571
#define LOG_CHECKPOINT_GROUP_ARRAY 32
573
/* For each value < LOG_MAX_N_GROUPS the following 8 bytes: */
575
#define LOG_CHECKPOINT_ARCHIVED_FILE_NO 0
576
#define LOG_CHECKPOINT_ARCHIVED_OFFSET 4
578
#define LOG_CHECKPOINT_ARRAY_END (LOG_CHECKPOINT_GROUP_ARRAY\
579
+ LOG_MAX_N_GROUPS * 8)
580
#define LOG_CHECKPOINT_CHECKSUM_1 LOG_CHECKPOINT_ARRAY_END
581
#define LOG_CHECKPOINT_CHECKSUM_2 (4 + LOG_CHECKPOINT_ARRAY_END)
582
#define LOG_CHECKPOINT_FSP_FREE_LIMIT (8 + LOG_CHECKPOINT_ARRAY_END)
583
/* current fsp free limit in
584
tablespace 0, in units of one
585
megabyte; this information is only used
586
by ibbackup to decide if it can
587
truncate unused ends of
588
non-auto-extending data files in space
590
#define LOG_CHECKPOINT_FSP_MAGIC_N (12 + LOG_CHECKPOINT_ARRAY_END)
591
/* this magic number tells if the
592
checkpoint contains the above field:
593
the field was added to
595
#define LOG_CHECKPOINT_SIZE (16 + LOG_CHECKPOINT_ARRAY_END)
597
#define LOG_CHECKPOINT_FSP_MAGIC_N_VAL 1441231243
599
/* Offsets of a log file header */
600
#define LOG_GROUP_ID 0 /* log group number */
601
#define LOG_FILE_START_LSN 4 /* lsn of the start of data in this
603
#define LOG_FILE_NO 12 /* 4-byte archived log file number;
604
this field is only defined in an
606
#define LOG_FILE_WAS_CREATED_BY_HOT_BACKUP 16
607
/* a 32-byte field which contains
608
the string 'ibbackup' and the
609
creation time if the log file was
610
created by ibbackup --restore;
611
when mysqld is first time started
612
on the restored database, it can
613
print helpful info for the user */
614
#define LOG_FILE_ARCH_COMPLETED OS_FILE_LOG_BLOCK_SIZE
615
/* this 4-byte field is TRUE when
616
the writing of an archived log file
617
has been completed; this field is
618
only defined in an archived log file */
619
#define LOG_FILE_END_LSN (OS_FILE_LOG_BLOCK_SIZE + 4)
620
/* lsn where the archived log file
621
at least extends: actually the
622
archived log file may extend to a
623
later lsn, as long as it is within the
624
same log block as this lsn; this field
625
is defined only when an archived log
626
file has been completely written */
627
#define LOG_CHECKPOINT_1 OS_FILE_LOG_BLOCK_SIZE
628
/* first checkpoint field in the log
629
header; we write alternately to the
630
checkpoint fields when we make new
631
checkpoints; this field is only defined
632
in the first log file of a log group */
633
#define LOG_CHECKPOINT_2 (3 * OS_FILE_LOG_BLOCK_SIZE)
634
/* second checkpoint field in the log
636
#define LOG_FILE_HDR_SIZE (4 * OS_FILE_LOG_BLOCK_SIZE)
638
#define LOG_GROUP_OK 301
639
#define LOG_GROUP_CORRUPTED 302
641
/* Log group consists of a number of log files, each of the same size; a log
642
group is implemented as a space in the sense of the module fil0fil. */
644
struct log_group_struct{
645
/* The following fields are protected by log_sys->mutex */
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,
649
including the log file header */
650
ulint space_id; /* file space which implements the log
652
ulint state; /* LOG_GROUP_OK or
653
LOG_GROUP_CORRUPTED */
654
ib_uint64_t lsn; /* lsn used to fix coordinates within
656
ulint lsn_offset; /* the offset of the above lsn */
657
ulint n_pending_writes;/* number of currently pending flush
658
writes for this log group */
659
byte** file_header_bufs;/* buffers for each file header in the
661
/*-----------------------------*/
662
byte** archive_file_header_bufs;/* buffers for each file
663
header in the group */
664
ulint archive_space_id;/* file space which implements the log
666
ulint archived_file_no;/* file number corresponding to
667
log_sys->archived_lsn */
668
ulint archived_offset;/* file offset corresponding to
669
log_sys->archived_lsn, 0 if we have
670
not yet written to the archive file
671
number archived_file_no */
672
ulint next_archived_file_no;/* during an archive write,
673
until the write is completed, we
674
store the next value for
675
archived_file_no here: the write
676
completion function then sets the new
677
value to ..._file_no */
678
ulint next_archived_offset; /* like the preceding field */
679
/*-----------------------------*/
680
ib_uint64_t scanned_lsn; /* used only in recovery: recovery scan
681
succeeded up to this lsn in this log
683
byte* checkpoint_buf; /* checkpoint header is written from
684
this buffer to the group */
685
UT_LIST_NODE_T(log_group_t)
686
log_groups; /* list of log groups */
690
byte pad[64]; /* padding to prevent other memory
691
update hotspots from residing on the
692
same memory cache line */
693
ib_uint64_t lsn; /* log sequence number */
694
ulint buf_free; /* first free offset within the log
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
700
buf_free, after which the buffer is
702
ulint old_buf_free; /* value of buf free when log was
703
last time opened; only in the debug
705
ib_uint64_t old_lsn; /* value of lsn when log was last time
706
opened; only in the debug version */
707
ibool check_flush_or_checkpoint;
708
/* this is set to TRUE when there may
709
be need to flush the log buffer, or
710
preflush buffer pool pages, or make
711
a checkpoint; this MUST be TRUE when
712
lsn - last_checkpoint_lsn >
713
max_checkpoint_age; this flag is
714
peeked at by log_free_check(), which
715
does not reserve the log mutex */
716
UT_LIST_BASE_NODE_T(log_group_t)
717
log_groups; /* log groups */
719
/* The fields involved in the log buffer flush */
721
ulint buf_next_to_write;/* first offset in the log buffer
722
where the byte content may not exist
723
written to file, e.g., the start
724
offset of a log record catenated
725
later; this is advanced when a flush
726
operation is completed to all the log
728
ib_uint64_t written_to_some_lsn;
729
/* first log sequence number not yet
730
written to any log group; for this to
731
be advanced, it is enough that the
732
write i/o has been completed for any
734
ib_uint64_t written_to_all_lsn;
735
/* first log sequence number not yet
736
written to some log group; for this to
737
be advanced, it is enough that the
738
write i/o has been completed for all
740
ib_uint64_t write_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
747
write + flush operation */
748
ib_uint64_t flushed_to_disk_lsn;
749
/* how far we have written the log
750
AND flushed to disk */
751
ulint n_pending_writes;/* number of currently pending flushes
753
/* NOTE on the 'flush' in names of the fields below: starting from
754
4.0.14, we separate the write of the log file and the actual fsync()
755
or other method to flush it to disk. The names below shhould really
756
be 'flush_or_write'! */
757
os_event_t no_flush_event; /* this event is in the reset state
758
when a flush or a write is running;
759
a thread should wait for this without
760
owning the log mutex, but NOTE that
761
to set or reset this event, the
762
thread MUST own the log mutex! */
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
767
flush or write has not yet completed
768
for any log group; e.g., this means
769
that a transaction has been committed
770
when this is set; a thread should wait
771
for this without owning the log mutex,
772
but NOTE that to set or reset this
773
event, the thread MUST own the log
775
ulint n_log_ios; /* number of log i/os initiated thus
777
ulint n_log_ios_old; /* number of log i/o's at the
779
time_t last_printout_time;/* when log_print was last time
782
/* Fields involved in checkpoints */
783
ulint log_group_capacity; /* capacity of the log group; if
784
the checkpoint age exceeds this, it is
785
a serious error because it is possible
786
we will then overwrite log and spoil
788
ulint max_modified_age_async;
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 */
793
ulint max_modified_age_sync;
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 */
798
ulint adm_checkpoint_interval;
799
/* administrator-specified checkpoint
800
interval in terms of log growth in
801
bytes; the interval actually used by
802
the database can be smaller */
803
ulint max_checkpoint_age_async;
804
/* when this checkpoint age is exceeded
805
we start an asynchronous writing of a
807
ulint max_checkpoint_age;
808
/* this is the maximum allowed value
809
for lsn - last_checkpoint_lsn when a
810
new query step is started */
811
ib_uint64_t next_checkpoint_no;
812
/* next checkpoint number */
813
ib_uint64_t last_checkpoint_lsn;
814
/* latest checkpoint lsn */
815
ib_uint64_t next_checkpoint_lsn;
816
/* next checkpoint lsn */
817
ulint n_pending_checkpoint_writes;
818
/* number of currently pending
820
rw_lock_t checkpoint_lock;/* this latch is x-locked when a
821
checkpoint write is running; a thread
822
should wait for this without owning
824
byte* checkpoint_buf; /* checkpoint header is read to this
826
#ifdef UNIV_LOG_ARCHIVE
827
/* Fields involved in archiving */
828
ulint archiving_state;/* LOG_ARCH_ON, LOG_ARCH_STOPPING
829
LOG_ARCH_STOPPED, LOG_ARCH_OFF */
830
ib_uint64_t archived_lsn; /* archiving has advanced to this
832
ulint max_archived_lsn_age_async;
833
/* recommended maximum age of
834
archived_lsn, before we start
835
asynchronous copying to the archive */
836
ulint max_archived_lsn_age;
837
/* maximum allowed age for
839
ib_uint64_t next_archived_lsn;/* during an archive write,
840
until the write is completed, we
841
store the next value for
842
archived_lsn here: the write
843
completion function then sets the new
844
value to archived_lsn */
845
ulint archiving_phase;/* LOG_ARCHIVE_READ or
847
ulint n_pending_archive_ios;
848
/* number of currently pending reads
849
or writes in archiving */
850
rw_lock_t archive_lock; /* this latch is x-locked when an
851
archive write is running; a thread
852
should wait for this without owning
854
ulint archive_buf_size;/* size of archive_buf */
855
byte* archive_buf; /* log segment is written to the
856
archive from this buffer */
857
os_event_t archiving_on; /* if archiving has been stopped,
858
a thread can wait for this event to
860
#endif /* UNIV_LOG_ARCHIVE */
863
#define LOG_ARCH_ON 71
864
#define LOG_ARCH_STOPPING 72
865
#define LOG_ARCH_STOPPING2 73
866
#define LOG_ARCH_STOPPED 74
867
#define LOG_ARCH_OFF 75
870
#include "log0log.ic"
added
removed
storage/innobase/include/log0log.h
