← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/log/log0log.c

  • Committer: Brian Aker
  • Date: 2010-12-17 00:08:06 UTC
  • mfrom: (2002.1.4 clean)
  • Revision ID: brian@tangent.org-20101217000806-fa6kmggjnhsl4q85
Rollup for field encapsulation, monty fix for bzrignore, and Andrew bug
fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/log/log0log.c
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (C) 1995, 2010, Innobase Oy. All Rights Reserved.
4
 
Copyright (C) 2009 Google Inc.
 
3
Copyright (c) 1995, 2010, Innobase Oy. All Rights Reserved.
 
4
Copyright (c) 2009, Google Inc.
5
5
 
6
6
Portions of this file contain modifications contributed and copyrighted by
7
7
Google, Inc. Those modifications are gratefully acknowledged and are described
49
49
#include "trx0sys.h"
50
50
#include "trx0trx.h"
51
51
 
52
 
#include <drizzled/errmsg_print.h>
53
 
 
54
52
/*
55
53
General philosophy of InnoDB redo-logs:
56
54
 
330
328
        str_len -= len;
331
329
        str = str + len;
332
330
 
333
 
        log_block = static_cast<unsigned char *>(ut_align_down(log->buf + log->buf_free,
334
 
                                OS_FILE_LOG_BLOCK_SIZE));
 
331
        log_block = ut_align_down(log->buf + log->buf_free,
 
332
                                  OS_FILE_LOG_BLOCK_SIZE);
335
333
        log_block_set_data_len(log_block, data_len);
336
334
 
337
335
        if (data_len == OS_FILE_LOG_BLOCK_SIZE - LOG_BLOCK_TRL_SIZE) {
380
378
 
381
379
        lsn = log->lsn;
382
380
 
383
 
        log_block = static_cast<unsigned char *>(ut_align_down(log->buf + log->buf_free,
384
 
                                OS_FILE_LOG_BLOCK_SIZE));
 
381
        log_block = ut_align_down(log->buf + log->buf_free,
 
382
                                  OS_FILE_LOG_BLOCK_SIZE);
385
383
        first_rec_group = log_block_get_first_rec_group(log_block);
386
384
 
387
385
        if (first_rec_group == 0) {
768
766
log_init(void)
769
767
/*==========*/
770
768
{
771
 
        log_sys = static_cast<log_t *>(mem_alloc(sizeof(log_t)));
 
769
        log_sys = mem_alloc(sizeof(log_t));
772
770
 
773
771
        mutex_create(log_sys_mutex_key, &log_sys->mutex, SYNC_LOG);
774
772
 
786
784
        ut_a(LOG_BUFFER_SIZE >= 16 * OS_FILE_LOG_BLOCK_SIZE);
787
785
        ut_a(LOG_BUFFER_SIZE >= 4 * UNIV_PAGE_SIZE);
788
786
 
789
 
        log_sys->buf_ptr = static_cast<unsigned char *>(mem_alloc(LOG_BUFFER_SIZE + OS_FILE_LOG_BLOCK_SIZE));
790
 
        log_sys->buf = static_cast<unsigned char *>(ut_align(log_sys->buf_ptr, OS_FILE_LOG_BLOCK_SIZE));
 
787
        log_sys->buf_ptr = mem_alloc(LOG_BUFFER_SIZE + OS_FILE_LOG_BLOCK_SIZE);
 
788
        log_sys->buf = ut_align(log_sys->buf_ptr, OS_FILE_LOG_BLOCK_SIZE);
791
789
 
792
790
        log_sys->buf_size = LOG_BUFFER_SIZE;
793
791
 
833
831
        rw_lock_create(checkpoint_lock_key, &log_sys->checkpoint_lock,
834
832
                       SYNC_NO_ORDER_CHECK);
835
833
 
836
 
        log_sys->checkpoint_buf_ptr = static_cast<unsigned char *>(mem_alloc(2 * OS_FILE_LOG_BLOCK_SIZE));
837
 
        log_sys->checkpoint_buf = static_cast<unsigned char *>(ut_align(log_sys->checkpoint_buf_ptr,
838
 
                                OS_FILE_LOG_BLOCK_SIZE));
 
834
        log_sys->checkpoint_buf_ptr = mem_alloc(2 * OS_FILE_LOG_BLOCK_SIZE);
 
835
        log_sys->checkpoint_buf = ut_align(log_sys->checkpoint_buf_ptr,
 
836
                                           OS_FILE_LOG_BLOCK_SIZE);
839
837
        memset(log_sys->checkpoint_buf, '\0', OS_FILE_LOG_BLOCK_SIZE);
840
838
        /*----------------------------*/
841
839
 
897
895
        ulint   space_id,               /*!< in: space id of the file space
898
896
                                        which contains the log files of this
899
897
                                        group */
900
 
        ulint   /*archive_space_id __attribute__((unused))*/)
 
898
        ulint   archive_space_id __attribute__((unused)))
901
899
                                        /*!< in: space id of the file space
902
900
                                        which contains some archived log
903
901
                                        files for this group; currently, only
908
906
 
909
907
        log_group_t*    group;
910
908
 
911
 
        group = static_cast<log_group_t *>(mem_alloc(sizeof(log_group_t)));
 
909
        group = mem_alloc(sizeof(log_group_t));
912
910
 
913
911
        group->id = id;
914
912
        group->n_files = n_files;
919
917
        group->lsn_offset = LOG_FILE_HDR_SIZE;
920
918
        group->n_pending_writes = 0;
921
919
 
922
 
        group->file_header_bufs_ptr = static_cast<unsigned char **>(mem_alloc(sizeof(byte*) * n_files));
923
 
        group->file_header_bufs = static_cast<unsigned char **>(mem_alloc(sizeof(byte*) * n_files));
 
920
        group->file_header_bufs_ptr = mem_alloc(sizeof(byte*) * n_files);
 
921
        group->file_header_bufs = mem_alloc(sizeof(byte*) * n_files);
924
922
#ifdef UNIV_LOG_ARCHIVE
925
923
        group->archive_file_header_bufs_ptr = mem_alloc(
926
924
                sizeof(byte*) * n_files);
928
926
#endif /* UNIV_LOG_ARCHIVE */
929
927
 
930
928
        for (i = 0; i < n_files; i++) {
931
 
                group->file_header_bufs_ptr[i] = static_cast<unsigned char *>(mem_alloc(
932
 
                        LOG_FILE_HDR_SIZE + OS_FILE_LOG_BLOCK_SIZE));
 
929
                group->file_header_bufs_ptr[i] = mem_alloc(
 
930
                        LOG_FILE_HDR_SIZE + OS_FILE_LOG_BLOCK_SIZE);
933
931
 
934
 
                group->file_header_bufs[i] = static_cast<unsigned char *>(ut_align(
 
932
                group->file_header_bufs[i] = ut_align(
935
933
                        group->file_header_bufs_ptr[i],
936
 
                        OS_FILE_LOG_BLOCK_SIZE));
 
934
                        OS_FILE_LOG_BLOCK_SIZE);
937
935
 
938
936
                memset(*(group->file_header_bufs + i), '\0',
939
937
                       LOG_FILE_HDR_SIZE);
958
956
        group->archived_offset = 0;
959
957
#endif /* UNIV_LOG_ARCHIVE */
960
958
 
961
 
        group->checkpoint_buf_ptr = static_cast<unsigned char *>(mem_alloc(2 * OS_FILE_LOG_BLOCK_SIZE));
962
 
        group->checkpoint_buf = static_cast<unsigned char*>(ut_align(group->checkpoint_buf_ptr,
963
 
                                         OS_FILE_LOG_BLOCK_SIZE));
 
959
        group->checkpoint_buf_ptr = mem_alloc(2 * OS_FILE_LOG_BLOCK_SIZE);
 
960
        group->checkpoint_buf = ut_align(group->checkpoint_buf_ptr,
 
961
                                         OS_FILE_LOG_BLOCK_SIZE);
964
962
 
965
963
        memset(group->checkpoint_buf, '\0', OS_FILE_LOG_BLOCK_SIZE);
966
964
 
2074
2072
{
2075
2073
        /* Preflush pages synchronously */
2076
2074
 
2077
 
        while (!log_preflush_pool_modified_pages(lsn, TRUE)) {}
 
2075
        while (!log_preflush_pool_modified_pages(lsn, TRUE));
2078
2076
 
2079
 
        while (!log_checkpoint(TRUE, write_always)) {}
 
2077
        while (!log_checkpoint(TRUE, write_always));
2080
2078
}
2081
2079
 
2082
2080
/****************************************************************//**
2243
2241
log_archived_file_name_gen(
2244
2242
/*=======================*/
2245
2243
        char*   buf,    /*!< in: buffer where to write */
2246
 
        ulint   /*id __attribute__((unused))*/,
 
2244
        ulint   id __attribute__((unused)),
2247
2245
                        /*!< in: group id;
2248
2246
                        currently we only archive the first group */
2249
2247
        ulint   file_no)/*!< in: file number */
3100
3098
 
3101
3099
        if (srv_fast_shutdown < 2
3102
3100
           && (srv_error_monitor_active
3103
 
              || srv_lock_timeout_active
3104
 
              || srv_monitor_active)) {
 
3101
              || srv_lock_timeout_active || srv_monitor_active)) {
3105
3102
 
3106
3103
                mutex_exit(&kernel_mutex);
3107
3104
 
3108
 
                os_event_set(srv_error_event);
3109
 
                os_event_set(srv_monitor_event);
3110
 
                os_event_set(srv_timeout_event);
3111
 
 
3112
3105
                goto loop;
3113
3106
        }
3114
3107
 
3135
3128
 
3136
3129
                log_buffer_flush_to_disk();
3137
3130
 
3138
 
                mutex_exit(&kernel_mutex);
3139
 
 
3140
3131
                return; /* We SKIP ALL THE REST !! */
3141
3132
        }
3142
3133
 
3236
3227
        ut_a(lsn == log_sys->lsn);
3237
3228
 
3238
3229
        if (lsn < srv_start_lsn) {
3239
 
          drizzled::errmsg_printf(drizzled::error::ERROR,
3240
 
                                  "InnoDB: Error: log sequence number at shutdown %"PRIu64" is lower than at startup %"PRIu64"!",
3241
 
                                  lsn, srv_start_lsn);
 
3230
                fprintf(stderr,
 
3231
                        "InnoDB: Error: log sequence number"
 
3232
                        " at shutdown %"PRIu64"\n"
 
3233
                        "InnoDB: is lower than at startup %"PRIu64"!\n",
 
3234
                        lsn, srv_start_lsn);
3242
3235
        }
3243
3236
 
3244
3237
        srv_shutdown_lsn = lsn;