Main Page | Modules | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Class Members | File Members | Related Pages | Search for 
mysql-5.0.2-alpha / innobase / include

log0log.h File Reference

#include "univ.i"
#include "ut0byte.h"
#include "sync0sync.h"
#include "sync0rw.h"

Include dependency graph for log0log.h:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Classes

struct  log_group_struct
struct  log_struct

Defines

#define LOG_NO_WAIT   91
#define LOG_WAIT_ONE_GROUP   92
#define LOG_WAIT_ALL_GROUPS   93
#define LOG_MAX_N_GROUPS   32
#define LOG_FLUSH   7652559
#define LOG_CHECKPOINT   78656949
#define LOG_ARCHIVE   11122331
#define LOG_RECOVER   98887331
#define LOG_START_LSN   ut_dulint_create(0, 16 * OS_FILE_LOG_BLOCK_SIZE)
#define LOG_BUFFER_SIZE   (srv_log_buffer_size * UNIV_PAGE_SIZE)
#define LOG_ARCHIVE_BUF_SIZE   (srv_log_buffer_size * UNIV_PAGE_SIZE / 4)
#define LOG_BLOCK_HDR_NO   0
#define LOG_BLOCK_FLUSH_BIT_MASK   0x80000000UL
#define LOG_BLOCK_HDR_DATA_LEN   4
#define LOG_BLOCK_FIRST_REC_GROUP   6
#define LOG_BLOCK_CHECKPOINT_NO   8
#define LOG_BLOCK_HDR_SIZE   12
#define LOG_BLOCK_CHECKSUM   4
#define LOG_BLOCK_TRL_SIZE   4
#define LOG_CHECKPOINT_NO   0
#define LOG_CHECKPOINT_LSN   8
#define LOG_CHECKPOINT_OFFSET   16
#define LOG_CHECKPOINT_LOG_BUF_SIZE   20
#define LOG_CHECKPOINT_ARCHIVED_LSN   24
#define LOG_CHECKPOINT_GROUP_ARRAY   32
#define LOG_CHECKPOINT_ARCHIVED_FILE_NO   0
#define LOG_CHECKPOINT_ARCHIVED_OFFSET   4
#define LOG_CHECKPOINT_ARRAY_END
#define LOG_CHECKPOINT_CHECKSUM_1   LOG_CHECKPOINT_ARRAY_END
#define LOG_CHECKPOINT_CHECKSUM_2   (4 + LOG_CHECKPOINT_ARRAY_END)
#define LOG_CHECKPOINT_FSP_FREE_LIMIT   (8 + LOG_CHECKPOINT_ARRAY_END)
#define LOG_CHECKPOINT_FSP_MAGIC_N   (12 + LOG_CHECKPOINT_ARRAY_END)
#define LOG_CHECKPOINT_SIZE   (16 + LOG_CHECKPOINT_ARRAY_END)
#define LOG_CHECKPOINT_FSP_MAGIC_N_VAL   1441231243
#define LOG_GROUP_ID   0
#define LOG_FILE_START_LSN   4
#define LOG_FILE_NO   12
#define LOG_FILE_WAS_CREATED_BY_HOT_BACKUP   16
#define LOG_FILE_ARCH_COMPLETED   OS_FILE_LOG_BLOCK_SIZE
#define LOG_FILE_END_LSN   (OS_FILE_LOG_BLOCK_SIZE + 4)
#define LOG_CHECKPOINT_1   OS_FILE_LOG_BLOCK_SIZE
#define LOG_CHECKPOINT_2   (3 * OS_FILE_LOG_BLOCK_SIZE)
#define LOG_FILE_HDR_SIZE   (4 * OS_FILE_LOG_BLOCK_SIZE)
#define LOG_GROUP_OK   301
#define LOG_GROUP_CORRUPTED   302
#define LOG_ARCH_ON   71
#define LOG_ARCH_STOPPING   72
#define LOG_ARCH_STOPPING2   73
#define LOG_ARCH_STOPPED   74
#define LOG_ARCH_OFF   75

Typedefs

typedef log_struct log_t
typedef log_group_struct log_group_t

Functions

void log_fsp_current_free_limit_set_and_checkpoint (ulint limit)
ulint log_calc_where_lsn_is (ib_longlong *log_file_offset, dulint first_header_lsn, dulint lsn, ulint n_log_files, ib_longlong log_file_size)
dulint log_reserve_and_write_fast (unsigned char *str, ulint len, dulint *start_lsn, ulint *success)
void log_release (void)
void log_free_check (void)
dulint log_reserve_and_open (ulint len)
void log_write_low (unsigned char *str, ulint str_len)
dulint log_close (void)
dulint log_get_lsn (void)
void log_init (void)
void log_group_init (ulint id, ulint n_files, ulint file_size, ulint space_id, ulint archive_space_id)
void log_io_complete (log_group_t *group)
void log_write_up_to (dulint lsn, ulint wait, ulint flush_to_disk)
void log_buffer_flush_to_disk (void)
ulint log_preflush_pool_modified_pages (dulint new_oldest, ulint sync)
ulint log_checkpoint (ulint sync, ulint write_always)
void log_make_checkpoint_at (dulint lsn, ulint write_always)
void logs_empty_and_mark_files_at_shutdown (void)
void log_group_read_checkpoint_info (log_group_t *group, ulint field)
void log_checkpoint_get_nth_group_info (unsigned char *buf, ulint n, ulint *file_no, ulint *offset)
void log_groups_write_checkpoint_info (void)
void log_reset_first_header_and_checkpoint (unsigned char *hdr_buf, dulint start)
ulint log_archive_do (ulint sync, ulint *n_bytes)
ulint log_archive_stop (void)
ulint log_archive_start (void)
ulint log_archive_noarchivelog (void)
ulint log_archive_archivelog (void)
void log_archived_file_name_gen (char *buf, ulint id, ulint file_no)
void log_check_margins (void)
void log_group_read_log_seg (ulint type, unsigned char *buf, log_group_t *group, dulint start_lsn, dulint end_lsn)
void log_group_write_buf (log_group_t *group, unsigned char *buf, ulint len, dulint start_lsn, ulint new_data_offset)
void log_group_set_fields (log_group_t *group, dulint lsn)
ulint log_group_get_capacity (log_group_t *group)
ulint log_block_get_flush_bit (unsigned char *log_block)
ulint log_block_get_hdr_no (unsigned char *log_block)
ulint log_block_get_data_len (unsigned char *log_block)
void log_block_set_data_len (unsigned char *log_block, ulint len)
ulint log_block_calc_checksum (unsigned char *block)
ulint log_block_get_checksum (unsigned char *log_block)
void log_block_set_checksum (unsigned char *log_block, ulint checksum)
ulint log_block_get_first_rec_group (unsigned char *log_block)
void log_block_set_first_rec_group (unsigned char *log_block, ulint offset)
ulint log_block_get_checkpoint_no (unsigned char *log_block)
void log_block_init (unsigned char *log_block, dulint lsn)
void log_block_init_in_old_format (unsigned char *log_block, dulint lsn)
ulint log_block_convert_lsn_to_no (dulint lsn)
void log_print (FILE *file)
ulint log_peek_lsn (dulint *lsn)
void log_refresh_stats (void)

Variables

ulint log_do_write
ulint log_debug_writes
log_t * log_sys

Define Documentation

#define LOG_ARCH_OFF   75
 

#define LOG_ARCH_ON   71
 

#define LOG_ARCH_STOPPED   74
 

#define LOG_ARCH_STOPPING   72
 

#define LOG_ARCH_STOPPING2   73
 

#define LOG_ARCHIVE   11122331
 

#define LOG_ARCHIVE_BUF_SIZE   (srv_log_buffer_size * UNIV_PAGE_SIZE / 4)
 

#define LOG_BLOCK_CHECKPOINT_NO   8
 

#define LOG_BLOCK_CHECKSUM   4
 

#define LOG_BLOCK_FIRST_REC_GROUP   6
 

#define LOG_BLOCK_FLUSH_BIT_MASK   0x80000000UL
 

#define LOG_BLOCK_HDR_DATA_LEN   4
 

#define LOG_BLOCK_HDR_NO   0
 

#define LOG_BLOCK_HDR_SIZE   12
 

#define LOG_BLOCK_TRL_SIZE   4
 

#define LOG_BUFFER_SIZE   (srv_log_buffer_size * UNIV_PAGE_SIZE)
 

#define LOG_CHECKPOINT   78656949
 

#define LOG_CHECKPOINT_1   OS_FILE_LOG_BLOCK_SIZE
 

#define LOG_CHECKPOINT_2   (3 * OS_FILE_LOG_BLOCK_SIZE)
 

#define LOG_CHECKPOINT_ARCHIVED_FILE_NO   0
 

#define LOG_CHECKPOINT_ARCHIVED_LSN   24
 

#define LOG_CHECKPOINT_ARCHIVED_OFFSET   4
 

#define LOG_CHECKPOINT_ARRAY_END
 

Value:

(LOG_CHECKPOINT_GROUP_ARRAY\
                                                        + LOG_MAX_N_GROUPS * 8)

#define LOG_CHECKPOINT_CHECKSUM_1   LOG_CHECKPOINT_ARRAY_END
 

#define LOG_CHECKPOINT_CHECKSUM_2   (4 + LOG_CHECKPOINT_ARRAY_END)
 

#define LOG_CHECKPOINT_FSP_FREE_LIMIT   (8 + LOG_CHECKPOINT_ARRAY_END)
 

#define LOG_CHECKPOINT_FSP_MAGIC_N   (12 + LOG_CHECKPOINT_ARRAY_END)
 

#define LOG_CHECKPOINT_FSP_MAGIC_N_VAL   1441231243
 

#define LOG_CHECKPOINT_GROUP_ARRAY   32
 

#define LOG_CHECKPOINT_LOG_BUF_SIZE   20
 

#define LOG_CHECKPOINT_LSN   8
 

#define LOG_CHECKPOINT_NO   0
 

#define LOG_CHECKPOINT_OFFSET   16
 

#define LOG_CHECKPOINT_SIZE   (16 + LOG_CHECKPOINT_ARRAY_END)
 

#define LOG_FILE_ARCH_COMPLETED   OS_FILE_LOG_BLOCK_SIZE
 

#define LOG_FILE_END_LSN   (OS_FILE_LOG_BLOCK_SIZE + 4)
 

#define LOG_FILE_HDR_SIZE   (4 * OS_FILE_LOG_BLOCK_SIZE)
 

#define LOG_FILE_NO   12
 

#define LOG_FILE_START_LSN   4
 

#define LOG_FILE_WAS_CREATED_BY_HOT_BACKUP   16
 

#define LOG_FLUSH   7652559
 

#define LOG_GROUP_CORRUPTED   302
 

#define LOG_GROUP_ID   0
 

#define LOG_GROUP_OK   301
 

#define LOG_MAX_N_GROUPS   32
 

#define LOG_NO_WAIT   91
 

#define LOG_RECOVER   98887331
 

#define LOG_START_LSN   ut_dulint_create(0, 16 * OS_FILE_LOG_BLOCK_SIZE)
 

#define LOG_WAIT_ALL_GROUPS   93
 

#define LOG_WAIT_ONE_GROUP   92
 

Typedef Documentation

typedef struct log_group_struct log_group_t
 

typedef struct log_struct log_t
 

Function Documentation

ulint log_archive_archivelog (  void   ) 
 

ulint log_archive_do (  ulint  sync,
ulint *  n_bytes
) 
 

ulint log_archive_noarchivelog (  void   ) 
 

ulint log_archive_start (  void   ) 
 

ulint log_archive_stop (  void   ) 
 

void log_archived_file_name_gen (  char *  buf,
ulint  id,
ulint  file_no
) 
 

ulint log_block_calc_checksum (  unsigned char *  block  ) 
 

ulint log_block_convert_lsn_to_no (  dulint  lsn  ) 
 

ulint log_block_get_checkpoint_no (  unsigned char *  log_block  ) 
 

ulint log_block_get_checksum (  unsigned char *  log_block  ) 
 

ulint log_block_get_data_len (  unsigned char *  log_block  ) 
 

ulint log_block_get_first_rec_group (  unsigned char *  log_block  ) 
 

ulint log_block_get_flush_bit (  unsigned char *  log_block  ) 
 

ulint log_block_get_hdr_no (  unsigned char *  log_block  ) 
 

void log_block_init (  unsigned char *  log_block,
dulint  lsn
) 
 

void log_block_init_in_old_format (  unsigned char *  log_block,
dulint  lsn
) 
 

void log_block_set_checksum (  unsigned char *  log_block,
ulint  checksum
) 
 

void log_block_set_data_len (  unsigned char *  log_block,
ulint  len
) 
 

void log_block_set_first_rec_group (  unsigned char *  log_block,
ulint  offset
) 
 

void log_buffer_flush_to_disk (  void   ) 
  

01481 {
01482         dulint  lsn;
01483 
01484         mutex_enter(&(log_sys->mutex));
01485 
01486         lsn = log_sys->lsn;
01487 
01488         mutex_exit(&(log_sys->mutex));
01489 
01490         log_write_up_to(lsn, LOG_WAIT_ALL_GROUPS, TRUE);
01491 }

ulint log_calc_where_lsn_is (  ib_longlong *  log_file_offset,
dulint  first_header_lsn,
dulint  lsn,
ulint  n_log_files,
ib_longlong  log_file_size
) 
  

00540                                                       : log file number */
00541         ib_longlong*    log_file_offset,        /* out: offset in that file
00542                                                 (including the header) */
00543         dulint          first_header_lsn,       /* in: first log file start
00544                                                 lsn */
00545         dulint          lsn,                    /* in: lsn whose position to
00546                                                 determine */
00547         ulint           n_log_files,            /* in: total number of log
00548                                                 files */
00549         ib_longlong     log_file_size)          /* in: log file size
00550                                                 (including the header) */
00551 {
00552         ib_longlong     ib_lsn;
00553         ib_longlong     ib_first_header_lsn;
00554         ib_longlong     capacity        = log_file_size - LOG_FILE_HDR_SIZE;
00555         ulint           file_no;
00556         ib_longlong     add_this_many;
00557         
00558         ib_lsn = ut_conv_dulint_to_longlong(lsn);
00559         ib_first_header_lsn = ut_conv_dulint_to_longlong(first_header_lsn);
00560 
00561         if (ib_lsn < ib_first_header_lsn) {
00562                 add_this_many = 1 + (ib_first_header_lsn - ib_lsn)
00563                                 / (capacity * (ib_longlong)n_log_files);
00564                 ib_lsn += add_this_many
00565                           * capacity * (ib_longlong)n_log_files;
00566         }
00567 
00568         ut_a(ib_lsn >= ib_first_header_lsn);
00569         
00570         file_no = ((ulint)((ib_lsn - ib_first_header_lsn) / capacity))
00571                           % n_log_files;
00572         *log_file_offset = (ib_lsn - ib_first_header_lsn) % capacity;
00573 
00574         *log_file_offset = *log_file_offset + LOG_FILE_HDR_SIZE;
00575 
00576         return(file_no);
00577 }

void log_check_margins (  void   ) 
  

02976 {
02977 loop:
02978         log_flush_margin();
02979 
02980         log_checkpoint_margin();
02981 
02982 #ifdef UNIV_LOG_ARCHIVE
02983         log_archive_margin();
02984 #endif /* UNIV_LOG_ARCHIVE */
02985 
02986         mutex_enter(&(log_sys->mutex));
02987         
02988         if (log_sys->check_flush_or_checkpoint) {
02989 
02990                 mutex_exit(&(log_sys->mutex));
02991 
02992                 goto loop;
02993         }
02994 
02995         mutex_exit(&(log_sys->mutex));
02996 }

ulint log_checkpoint (  ulint  sync,
ulint  write_always
) 
 

void log_checkpoint_get_nth_group_info (  unsigned char *  buf,
ulint  n,
ulint *  file_no,
ulint *  offset
) 
 

dulint log_close (  void   ) 
  

00307                               : lsn */
00308 {
00309         byte*   log_block;
00310         ulint   first_rec_group;
00311         dulint  oldest_lsn;
00312         dulint  lsn;
00313         log_t*  log     = log_sys;
00314         ulint   checkpoint_age;
00315 
00316 #ifdef UNIV_SYNC_DEBUG
00317         ut_ad(mutex_own(&(log->mutex)));
00318 #endif /* UNIV_SYNC_DEBUG */
00319 
00320         lsn = log->lsn;
00321         
00322         log_block = ut_align_down(log->buf + log->buf_free,
00323                                                 OS_FILE_LOG_BLOCK_SIZE);
00324         first_rec_group = log_block_get_first_rec_group(log_block);
00325 
00326         if (first_rec_group == 0) {
00327                 /* We initialized a new log block which was not written
00328                 full by the current mtr: the next mtr log record group
00329                 will start within this block at the offset data_len */
00330 
00331                 log_block_set_first_rec_group(log_block,
00332                                         log_block_get_data_len(log_block));
00333         }
00334 
00335         if (log->buf_free > log->max_buf_free) {
00336 
00337                 log->check_flush_or_checkpoint = TRUE;
00338         }
00339 
00340         checkpoint_age = ut_dulint_minus(lsn, log->last_checkpoint_lsn);
00341 
00342         if (checkpoint_age >= log->log_group_capacity) {
00343                 /* TODO: split btr_store_big_rec_extern_fields() into small
00344                 steps so that we can release all latches in the middle, and
00345                 call log_free_check() to ensure we never write over log written
00346                 after the latest checkpoint. In principle, we should split all
00347                 big_rec operations, but other operations are smaller. */
00348 
00349                 if (!log_has_printed_chkp_warning
00350                     || difftime(time(NULL), log_last_warning_time) > 15) {
00351 
00352                         log_has_printed_chkp_warning = TRUE;
00353                         log_last_warning_time = time(NULL);
00354                         
00355                         ut_print_timestamp(stderr);
00356                         fprintf(stderr,
00357 "  InnoDB: ERROR: the age of the last checkpoint is %lu,\n"
00358 "InnoDB: which exceeds the log group capacity %lu.\n"
00359 "InnoDB: If you are using big BLOB or TEXT rows, you must set the\n"
00360 "InnoDB: combined size of log files at least 10 times bigger than the\n"
00361 "InnoDB: largest such row.\n",
00362                                 (ulong) checkpoint_age,
00363                                 (ulong) log->log_group_capacity);
00364                 }
00365         }
00366 
00367         if (checkpoint_age <= log->max_modified_age_async) {
00368 
00369                 goto function_exit;
00370         }
00371 
00372         oldest_lsn = buf_pool_get_oldest_modification();
00373 
00374         if (ut_dulint_is_zero(oldest_lsn)
00375             || (ut_dulint_minus(lsn, oldest_lsn)
00376                                         > log->max_modified_age_async)
00377             || checkpoint_age > log->max_checkpoint_age_async) {
00378 
00379                 log->check_flush_or_checkpoint = TRUE;
00380         }
00381 function_exit:
00382 
00383 #ifdef UNIV_LOG_DEBUG
00384         log_check_log_recs(log->buf + log->old_buf_free,
00385                         log->buf_free - log->old_buf_free, log->old_lsn);
00386 #endif
00387 
00388         return(lsn);
00389 }

void log_free_check (  void   ) 
 

void log_fsp_current_free_limit_set_and_checkpoint (  ulint  limit  ) 
  

00112                              : limit to set */
00113 {
00114         ibool   success;
00115 
00116         mutex_enter(&(log_sys->mutex));
00117 
00118         log_fsp_current_free_limit = limit;
00119 
00120         mutex_exit(&(log_sys->mutex));
00121 
00122         /* Try to make a synchronous checkpoint */
00123         
00124         success = FALSE;
00125 
00126         while (!success) {
00127                 success = log_checkpoint(TRUE, TRUE);
00128         }
00129 }

dulint log_get_lsn (  void   ) 
 

ulint log_group_get_capacity (  log_group_t *  group  ) 
  

00433                                       : capacity in bytes */
00434         log_group_t*    group)  /* in: log group */
00435 {
00436 #ifdef UNIV_SYNC_DEBUG
00437         ut_ad(mutex_own(&(log_sys->mutex)));
00438 #endif /* UNIV_SYNC_DEBUG */
00439 
00440         return((group->file_size - LOG_FILE_HDR_SIZE) * group->n_files); 
00441 }

void log_group_init (  ulint  id,
ulint  n_files,
ulint  file_size,
ulint  space_id,
ulint  archive_space_id
) 
 

void log_group_read_checkpoint_info (  log_group_t *  group,
ulint  field
) 
  

01828                                      : log group */
01829         ulint           field)  /* in: LOG_CHECKPOINT_1 or LOG_CHECKPOINT_2 */
01830 {
01831 #ifdef UNIV_SYNC_DEBUG
01832         ut_ad(mutex_own(&(log_sys->mutex)));
01833 #endif /* UNIV_SYNC_DEBUG */
01834 
01835         log_sys->n_log_ios++;
01836         
01837         fil_io(OS_FILE_READ | OS_FILE_LOG, TRUE, group->space_id,
01838                         field / UNIV_PAGE_SIZE, field % UNIV_PAGE_SIZE,
01839                         OS_FILE_LOG_BLOCK_SIZE, log_sys->checkpoint_buf, NULL);
01840 }

void log_group_read_log_seg (  ulint  type,
unsigned char *  buf,
log_group_t *  group,
dulint  start_lsn,
dulint  end_lsn
) 
 

void log_group_set_fields (  log_group_t *  group,
dulint  lsn
) 
  

00587                                      : group */
00588         dulint          lsn)    /* in: lsn for which the values should be
00589                                 set */
00590 {
00591         group->lsn_offset = log_group_calc_lsn_offset(lsn, group);
00592         group->lsn = lsn;
00593 }

void log_group_write_buf (  log_group_t *  group,
unsigned char *  buf,
ulint  len,
dulint  start_lsn,
ulint  new_data_offset
) 
 

void log_groups_write_checkpoint_info (  void   ) 
  

01848 {
01849         log_group_t*    group;
01850 
01851 #ifdef UNIV_SYNC_DEBUG
01852         ut_ad(mutex_own(&(log_sys->mutex)));
01853 #endif /* UNIV_SYNC_DEBUG */
01854 
01855         group = UT_LIST_GET_FIRST(log_sys->log_groups);
01856 
01857         while (group) {
01858                 log_group_checkpoint(group);
01859 
01860                 group = UT_LIST_GET_NEXT(log_groups, group);
01861         }
01862 }

void log_init (  void   ) 
  

00712 {
00713         byte*   buf;
00714 
00715         log_sys = mem_alloc(sizeof(log_t));
00716 
00717         mutex_create(&(log_sys->mutex));
00718         mutex_set_level(&(log_sys->mutex), SYNC_LOG);
00719 
00720         mutex_enter(&(log_sys->mutex));
00721 
00722         /* Start the lsn from one log block from zero: this way every
00723         log record has a start lsn != zero, a fact which we will use */
00724         
00725         log_sys->lsn = LOG_START_LSN;
00726 
00727         ut_a(LOG_BUFFER_SIZE >= 16 * OS_FILE_LOG_BLOCK_SIZE);
00728         ut_a(LOG_BUFFER_SIZE >= 4 * UNIV_PAGE_SIZE);
00729 
00730         buf = ut_malloc(LOG_BUFFER_SIZE + OS_FILE_LOG_BLOCK_SIZE);
00731         log_sys->buf = ut_align(buf, OS_FILE_LOG_BLOCK_SIZE);
00732 
00733         log_sys->buf_size = LOG_BUFFER_SIZE;
00734 
00735         memset(log_sys->buf, '\0', LOG_BUFFER_SIZE);
00736 
00737         log_sys->max_buf_free = log_sys->buf_size / LOG_BUF_FLUSH_RATIO
00738                                 - LOG_BUF_FLUSH_MARGIN;
00739         log_sys->check_flush_or_checkpoint = TRUE;
00740         UT_LIST_INIT(log_sys->log_groups);
00741 
00742         log_sys->n_log_ios = 0; 
00743 
00744         log_sys->n_log_ios_old = log_sys->n_log_ios;
00745         log_sys->last_printout_time = time(NULL);
00746         /*----------------------------*/
00747         
00748         log_sys->buf_next_to_write = 0;
00749 
00750         log_sys->write_lsn = ut_dulint_zero;
00751         log_sys->current_flush_lsn = ut_dulint_zero;
00752         log_sys->flushed_to_disk_lsn = ut_dulint_zero;
00753 
00754         log_sys->written_to_some_lsn = log_sys->lsn;
00755         log_sys->written_to_all_lsn = log_sys->lsn;
00756         
00757         log_sys->n_pending_writes = 0;
00758 
00759         log_sys->no_flush_event = os_event_create(NULL);
00760 
00761         os_event_set(log_sys->no_flush_event);
00762 
00763         log_sys->one_flushed_event = os_event_create(NULL);
00764 
00765         os_event_set(log_sys->one_flushed_event);
00766 
00767         /*----------------------------*/
00768         log_sys->adm_checkpoint_interval = ULINT_MAX;
00769 
00770         log_sys->next_checkpoint_no = ut_dulint_zero;
00771         log_sys->last_checkpoint_lsn = log_sys->lsn;
00772         log_sys->n_pending_checkpoint_writes = 0; 
00773 
00774         rw_lock_create(&(log_sys->checkpoint_lock));
00775         rw_lock_set_level(&(log_sys->checkpoint_lock), SYNC_NO_ORDER_CHECK);
00776 
00777         log_sys->checkpoint_buf = ut_align(
00778                                 mem_alloc(2 * OS_FILE_LOG_BLOCK_SIZE),
00779                                                 OS_FILE_LOG_BLOCK_SIZE);
00780         memset(log_sys->checkpoint_buf, '\0', OS_FILE_LOG_BLOCK_SIZE);
00781         /*----------------------------*/
00782 
00783 #ifdef UNIV_LOG_ARCHIVE
00784         /* Under MySQL, log archiving is always off */
00785         log_sys->archiving_state = LOG_ARCH_OFF;
00786         log_sys->archived_lsn = log_sys->lsn;
00787         log_sys->next_archived_lsn = ut_dulint_zero;
00788 
00789         log_sys->n_pending_archive_ios = 0;
00790 
00791         rw_lock_create(&(log_sys->archive_lock));
00792         rw_lock_set_level(&(log_sys->archive_lock), SYNC_NO_ORDER_CHECK);
00793 
00794         log_sys->archive_buf = NULL;
00795 
00796                         /* ut_align(
00797                                 ut_malloc(LOG_ARCHIVE_BUF_SIZE
00798                                           + OS_FILE_LOG_BLOCK_SIZE),
00799                                                 OS_FILE_LOG_BLOCK_SIZE); */
00800         log_sys->archive_buf_size = 0;
00801 
00802         /* memset(log_sys->archive_buf, '\0', LOG_ARCHIVE_BUF_SIZE); */
00803 
00804         log_sys->archiving_on = os_event_create(NULL);
00805 #endif /* UNIV_LOG_ARCHIVE */
00806 
00807         /*----------------------------*/
00808 
00809         log_block_init(log_sys->buf, log_sys->lsn);
00810         log_block_set_first_rec_group(log_sys->buf, LOG_BLOCK_HDR_SIZE);
00811 
00812         log_sys->buf_free = LOG_BLOCK_HDR_SIZE;
00813         log_sys->lsn = ut_dulint_add(LOG_START_LSN, LOG_BLOCK_HDR_SIZE);
00814         
00815         mutex_exit(&(log_sys->mutex));
00816 
00817 #ifdef UNIV_LOG_DEBUG
00818         recv_sys_create();
00819