← 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-11-19 00:00:46 UTC
  • mto: (1945.2.1 quick)
  • mto: This revision was merged to the branch mainline in revision 1944.
  • Revision ID: brian@tangent.org-20101119000046-iajnd847tmo595ts
Fix style issue around table for message (though this is imperfect,...)

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
 
84
82
/* Global log system variable */
85
83
UNIV_INTERN log_t*      log_sys = NULL;
86
84
 
87
 
#ifdef UNIV_PFS_RWLOCK
88
 
UNIV_INTERN mysql_pfs_key_t     checkpoint_lock_key;
89
 
# ifdef UNIV_LOG_ARCHIVE
90
 
UNIV_INTERN mysql_pfs_key_t     archive_lock_key;
91
 
# endif
92
 
#endif /* UNIV_PFS_RWLOCK */
93
 
 
94
 
#ifdef UNIV_PFS_MUTEX
95
 
UNIV_INTERN mysql_pfs_key_t     log_sys_mutex_key;
96
 
UNIV_INTERN mysql_pfs_key_t     log_flush_order_mutex_key;
97
 
#endif /* UNIV_PFS_MUTEX */
98
 
 
99
85
#ifdef UNIV_DEBUG
100
86
UNIV_INTERN ibool       log_do_write = TRUE;
101
87
#endif /* UNIV_DEBUG */
330
316
        str_len -= len;
331
317
        str = str + len;
332
318
 
333
 
        log_block = static_cast<unsigned char *>(ut_align_down(log->buf + log->buf_free,
334
 
                                OS_FILE_LOG_BLOCK_SIZE));
 
319
        log_block = ut_align_down(log->buf + log->buf_free,
 
320
                                  OS_FILE_LOG_BLOCK_SIZE);
335
321
        log_block_set_data_len(log_block, data_len);
336
322
 
337
323
        if (data_len == OS_FILE_LOG_BLOCK_SIZE - LOG_BLOCK_TRL_SIZE) {
380
366
 
381
367
        lsn = log->lsn;
382
368
 
383
 
        log_block = static_cast<unsigned char *>(ut_align_down(log->buf + log->buf_free,
384
 
                                OS_FILE_LOG_BLOCK_SIZE));
 
369
        log_block = ut_align_down(log->buf + log->buf_free,
 
370
                                  OS_FILE_LOG_BLOCK_SIZE);
385
371
        first_rec_group = log_block_get_first_rec_group(log_block);
386
372
 
387
373
        if (first_rec_group == 0) {
768
754
log_init(void)
769
755
/*==========*/
770
756
{
771
 
        log_sys = static_cast<log_t *>(mem_alloc(sizeof(log_t)));
772
 
 
773
 
        mutex_create(log_sys_mutex_key, &log_sys->mutex, SYNC_LOG);
774
 
 
775
 
        mutex_create(log_flush_order_mutex_key,
776
 
                     &log_sys->log_flush_order_mutex,
777
 
                     SYNC_LOG_FLUSH_ORDER);
 
757
        log_sys = mem_alloc(sizeof(log_t));
 
758
 
 
759
        mutex_create(&log_sys->mutex, SYNC_LOG);
778
760
 
779
761
        mutex_enter(&(log_sys->mutex));
780
762
 
786
768
        ut_a(LOG_BUFFER_SIZE >= 16 * OS_FILE_LOG_BLOCK_SIZE);
787
769
        ut_a(LOG_BUFFER_SIZE >= 4 * UNIV_PAGE_SIZE);
788
770
 
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));
 
771
        log_sys->buf_ptr = mem_alloc(LOG_BUFFER_SIZE + OS_FILE_LOG_BLOCK_SIZE);
 
772
        log_sys->buf = ut_align(log_sys->buf_ptr, OS_FILE_LOG_BLOCK_SIZE);
791
773
 
792
774
        log_sys->buf_size = LOG_BUFFER_SIZE;
793
775
 
830
812
        log_sys->last_checkpoint_lsn = log_sys->lsn;
831
813
        log_sys->n_pending_checkpoint_writes = 0;
832
814
 
833
 
        rw_lock_create(checkpoint_lock_key, &log_sys->checkpoint_lock,
834
 
                       SYNC_NO_ORDER_CHECK);
 
815
        rw_lock_create(&log_sys->checkpoint_lock, SYNC_NO_ORDER_CHECK);
835
816
 
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));
 
817
        log_sys->checkpoint_buf_ptr = mem_alloc(2 * OS_FILE_LOG_BLOCK_SIZE);
 
818
        log_sys->checkpoint_buf = ut_align(log_sys->checkpoint_buf_ptr,
 
819
                                           OS_FILE_LOG_BLOCK_SIZE);
839
820
        memset(log_sys->checkpoint_buf, '\0', OS_FILE_LOG_BLOCK_SIZE);
840
821
        /*----------------------------*/
841
822
 
847
828
 
848
829
        log_sys->n_pending_archive_ios = 0;
849
830
 
850
 
        rw_lock_create(archive_lock_key, &log_sys->archive_lock,
851
 
                       SYNC_NO_ORDER_CHECK);
 
831
        rw_lock_create(&log_sys->archive_lock, SYNC_NO_ORDER_CHECK);
852
832
 
853
833
        log_sys->archive_buf = NULL;
854
834
 
897
877
        ulint   space_id,               /*!< in: space id of the file space
898
878
                                        which contains the log files of this
899
879
                                        group */
900
 
        ulint   /*archive_space_id __attribute__((unused))*/)
 
880
        ulint   archive_space_id __attribute__((unused)))
901
881
                                        /*!< in: space id of the file space
902
882
                                        which contains some archived log
903
883
                                        files for this group; currently, only
908
888
 
909
889
        log_group_t*    group;
910
890
 
911
 
        group = static_cast<log_group_t *>(mem_alloc(sizeof(log_group_t)));
 
891
        group = mem_alloc(sizeof(log_group_t));
912
892
 
913
893
        group->id = id;
914
894
        group->n_files = n_files;
919
899
        group->lsn_offset = LOG_FILE_HDR_SIZE;
920
900
        group->n_pending_writes = 0;
921
901
 
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));
 
902
        group->file_header_bufs_ptr = mem_alloc(sizeof(byte*) * n_files);
 
903
        group->file_header_bufs = mem_alloc(sizeof(byte*) * n_files);
924
904
#ifdef UNIV_LOG_ARCHIVE
925
905
        group->archive_file_header_bufs_ptr = mem_alloc(
926
906
                sizeof(byte*) * n_files);
928
908
#endif /* UNIV_LOG_ARCHIVE */
929
909
 
930
910
        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));
 
911
                group->file_header_bufs_ptr[i] = mem_alloc(
 
912
                        LOG_FILE_HDR_SIZE + OS_FILE_LOG_BLOCK_SIZE);
933
913
 
934
 
                group->file_header_bufs[i] = static_cast<unsigned char *>(ut_align(
 
914
                group->file_header_bufs[i] = ut_align(
935
915
                        group->file_header_bufs_ptr[i],
936
 
                        OS_FILE_LOG_BLOCK_SIZE));
 
916
                        OS_FILE_LOG_BLOCK_SIZE);
937
917
 
938
918
                memset(*(group->file_header_bufs + i), '\0',
939
919
                       LOG_FILE_HDR_SIZE);
958
938
        group->archived_offset = 0;
959
939
#endif /* UNIV_LOG_ARCHIVE */
960
940
 
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));
 
941
        group->checkpoint_buf_ptr = mem_alloc(2 * OS_FILE_LOG_BLOCK_SIZE);
 
942
        group->checkpoint_buf = ut_align(group->checkpoint_buf_ptr,
 
943
                                         OS_FILE_LOG_BLOCK_SIZE);
964
944
 
965
945
        memset(group->checkpoint_buf, '\0', OS_FILE_LOG_BLOCK_SIZE);
966
946
 
1168
1148
        buf = *(group->file_header_bufs + nth_file);
1169
1149
 
1170
1150
        mach_write_to_4(buf + LOG_GROUP_ID, group->id);
1171
 
        mach_write_to_8(buf + LOG_FILE_START_LSN, start_lsn);
 
1151
        mach_write_ull(buf + LOG_FILE_START_LSN, start_lsn);
1172
1152
 
1173
1153
        /* Wipe over possible label of ibbackup --restore */
1174
1154
        memcpy(buf + LOG_FILE_WAS_CREATED_BY_HOT_BACKUP, "    ", 4);
1657
1637
                recv_apply_hashed_log_recs(TRUE);
1658
1638
        }
1659
1639
 
1660
 
        n_pages = buf_flush_list(ULINT_MAX, new_oldest);
 
1640
        n_pages = buf_flush_batch(BUF_FLUSH_LIST, ULINT_MAX, new_oldest);
1661
1641
 
1662
1642
        if (sync) {
1663
 
                buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST);
 
1643
                buf_flush_wait_batch_end(BUF_FLUSH_LIST);
1664
1644
        }
1665
1645
 
1666
1646
        if (n_pages == ULINT_UNDEFINED) {
1771
1751
 
1772
1752
        buf = group->checkpoint_buf;
1773
1753
 
1774
 
        mach_write_to_8(buf + LOG_CHECKPOINT_NO, log_sys->next_checkpoint_no);
1775
 
        mach_write_to_8(buf + LOG_CHECKPOINT_LSN, log_sys->next_checkpoint_lsn);
 
1754
        mach_write_ull(buf + LOG_CHECKPOINT_NO, log_sys->next_checkpoint_no);
 
1755
        mach_write_ull(buf + LOG_CHECKPOINT_LSN, log_sys->next_checkpoint_lsn);
1776
1756
 
1777
1757
        mach_write_to_4(buf + LOG_CHECKPOINT_OFFSET,
1778
1758
                        log_group_calc_lsn_offset(
1792
1772
                }
1793
1773
        }
1794
1774
 
1795
 
        mach_write_to_8(buf + LOG_CHECKPOINT_ARCHIVED_LSN, archived_lsn);
 
1775
        mach_write_ull(buf + LOG_CHECKPOINT_ARCHIVED_LSN, archived_lsn);
1796
1776
#else /* UNIV_LOG_ARCHIVE */
1797
 
        mach_write_to_8(buf + LOG_CHECKPOINT_ARCHIVED_LSN, IB_ULONGLONG_MAX);
 
1777
        mach_write_ull(buf + LOG_CHECKPOINT_ARCHIVED_LSN, IB_ULONGLONG_MAX);
1798
1778
#endif /* UNIV_LOG_ARCHIVE */
1799
1779
 
1800
1780
        for (i = 0; i < LOG_MAX_N_GROUPS; i++) {
1886
1866
        ib_uint64_t     lsn;
1887
1867
 
1888
1868
        mach_write_to_4(hdr_buf + LOG_GROUP_ID, 0);
1889
 
        mach_write_to_8(hdr_buf + LOG_FILE_START_LSN, start);
 
1869
        mach_write_ull(hdr_buf + LOG_FILE_START_LSN, start);
1890
1870
 
1891
1871
        lsn = start + LOG_BLOCK_HDR_SIZE;
1892
1872
 
1898
1878
                                + (sizeof "ibbackup ") - 1));
1899
1879
        buf = hdr_buf + LOG_CHECKPOINT_1;
1900
1880
 
1901
 
        mach_write_to_8(buf + LOG_CHECKPOINT_NO, 0);
1902
 
        mach_write_to_8(buf + LOG_CHECKPOINT_LSN, lsn);
 
1881
        mach_write_ull(buf + LOG_CHECKPOINT_NO, 0);
 
1882
        mach_write_ull(buf + LOG_CHECKPOINT_LSN, lsn);
1903
1883
 
1904
1884
        mach_write_to_4(buf + LOG_CHECKPOINT_OFFSET,
1905
1885
                        LOG_FILE_HDR_SIZE + LOG_BLOCK_HDR_SIZE);
1906
1886
 
1907
1887
        mach_write_to_4(buf + LOG_CHECKPOINT_LOG_BUF_SIZE, 2 * 1024 * 1024);
1908
1888
 
1909
 
        mach_write_to_8(buf + LOG_CHECKPOINT_ARCHIVED_LSN, IB_ULONGLONG_MAX);
 
1889
        mach_write_ull(buf + LOG_CHECKPOINT_ARCHIVED_LSN, IB_ULONGLONG_MAX);
1910
1890
 
1911
1891
        fold = ut_fold_binary(buf, LOG_CHECKPOINT_CHECKSUM_1);
1912
1892
        mach_write_to_4(buf + LOG_CHECKPOINT_CHECKSUM_1, fold);
2074
2054
{
2075
2055
        /* Preflush pages synchronously */
2076
2056
 
2077
 
        while (!log_preflush_pool_modified_pages(lsn, TRUE)) {}
 
2057
        while (!log_preflush_pool_modified_pages(lsn, TRUE));
2078
2058
 
2079
 
        while (!log_checkpoint(TRUE, write_always)) {}
 
2059
        while (!log_checkpoint(TRUE, write_always));
2080
2060
}
2081
2061
 
2082
2062
/****************************************************************//**
2243
2223
log_archived_file_name_gen(
2244
2224
/*=======================*/
2245
2225
        char*   buf,    /*!< in: buffer where to write */
2246
 
        ulint   /*id __attribute__((unused))*/,
 
2226
        ulint   id __attribute__((unused)),
2247
2227
                        /*!< in: group id;
2248
2228
                        currently we only archive the first group */
2249
2229
        ulint   file_no)/*!< in: file number */
2274
2254
        buf = *(group->archive_file_header_bufs + nth_file);
2275
2255
 
2276
2256
        mach_write_to_4(buf + LOG_GROUP_ID, group->id);
2277
 
        mach_write_to_8(buf + LOG_FILE_START_LSN, start_lsn);
 
2257
        mach_write_ull(buf + LOG_FILE_START_LSN, start_lsn);
2278
2258
        mach_write_to_4(buf + LOG_FILE_NO, file_no);
2279
2259
 
2280
2260
        mach_write_to_4(buf + LOG_FILE_ARCH_COMPLETED, FALSE);
2310
2290
        buf = *(group->archive_file_header_bufs + nth_file);
2311
2291
 
2312
2292
        mach_write_to_4(buf + LOG_FILE_ARCH_COMPLETED, TRUE);
2313
 
        mach_write_to_8(buf + LOG_FILE_END_LSN, end_lsn);
 
2293
        mach_write_ull(buf + LOG_FILE_END_LSN, end_lsn);
2314
2294
 
2315
2295
        dest_offset = nth_file * group->file_size + LOG_FILE_ARCH_COMPLETED;
2316
2296
 
2374
2354
                log_archived_file_name_gen(name, group->id,
2375
2355
                                           group->archived_file_no + n_files);
2376
2356
 
2377
 
                file_handle = os_file_create(innodb_file_log_key,
2378
 
                                             name, open_mode,
2379
 
                                             OS_FILE_AIO,
 
2357
                file_handle = os_file_create(name, open_mode, OS_FILE_AIO,
2380
2358
                                             OS_DATA_FILE, &ret);
2381
2359
 
2382
2360
                if (!ret && (open_mode == OS_FILE_CREATE)) {
2383
2361
                        file_handle = os_file_create(
2384
 
                                innodb_file_log_key, name, OS_FILE_OPEN,
2385
 
                                OS_FILE_AIO, OS_DATA_FILE, &ret);
 
2362
                                name, OS_FILE_OPEN, OS_FILE_AIO,
 
2363
                                OS_DATA_FILE, &ret);
2386
2364
                }
2387
2365
 
2388
2366
                if (!ret) {
3100
3078
 
3101
3079
        if (srv_fast_shutdown < 2
3102
3080
           && (srv_error_monitor_active
3103
 
              || srv_lock_timeout_active
3104
 
              || srv_monitor_active)) {
 
3081
              || srv_lock_timeout_active || srv_monitor_active)) {
3105
3082
 
3106
3083
                mutex_exit(&kernel_mutex);
3107
3084
 
3108
 
                os_event_set(srv_error_event);
3109
 
                os_event_set(srv_monitor_event);
3110
 
                os_event_set(srv_timeout_event);
3111
 
 
3112
3085
                goto loop;
3113
3086
        }
3114
3087
 
3135
3108
 
3136
3109
                log_buffer_flush_to_disk();
3137
3110
 
3138
 
                mutex_exit(&kernel_mutex);
3139
 
 
3140
3111
                return; /* We SKIP ALL THE REST !! */
3141
3112
        }
3142
3113
 
 
3114
        /* Check that the master thread is suspended */
 
3115
 
 
3116
        if (srv_n_threads_active[SRV_MASTER] != 0) {
 
3117
 
 
3118
                mutex_exit(&kernel_mutex);
 
3119
 
 
3120
                goto loop;
 
3121
        }
 
3122
 
3143
3123
        mutex_exit(&kernel_mutex);
3144
3124
 
3145
 
        /* Check that the background threads are suspended */
3146
 
 
3147
 
        if (srv_is_any_background_thread_active()) {
3148
 
                goto loop;
3149
 
        }
3150
 
 
3151
3125
        mutex_enter(&(log_sys->mutex));
3152
3126
 
3153
3127
        if (log_sys->n_pending_checkpoint_writes
3205
3179
 
3206
3180
        mutex_exit(&(log_sys->mutex));
3207
3181
 
3208
 
        /* Check that the background threads stay suspended */
3209
 
        if (srv_is_any_background_thread_active()) {
 
3182
        mutex_enter(&kernel_mutex);
 
3183
        /* Check that the master thread has stayed suspended */
 
3184
        if (srv_n_threads_active[SRV_MASTER] != 0) {
3210
3185
                fprintf(stderr,
3211
 
                        "InnoDB: Warning: some background thread woke up"
 
3186
                        "InnoDB: Warning: the master thread woke up"
3212
3187
                        " during shutdown\n");
3213
3188
 
 
3189
                mutex_exit(&kernel_mutex);
 
3190
 
3214
3191
                goto loop;
3215
3192
        }
 
3193
        mutex_exit(&kernel_mutex);
3216
3194
 
3217
3195
        fil_flush_file_spaces(FIL_TABLESPACE);
3218
3196
        fil_flush_file_spaces(FIL_LOG);
3230
3208
        srv_shutdown_state = SRV_SHUTDOWN_LAST_PHASE;
3231
3209
 
3232
3210
        /* Make some checks that the server really is quiet */
3233
 
        ut_a(!srv_is_any_background_thread_active());
3234
 
 
 
3211
        ut_a(srv_n_threads_active[SRV_MASTER] == 0);
3235
3212
        ut_a(buf_all_freed());
3236
3213
        ut_a(lsn == log_sys->lsn);
3237
3214
 
3238
3215
        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);
 
3216
                fprintf(stderr,
 
3217
                        "InnoDB: Error: log sequence number"
 
3218
                        " at shutdown %"PRIu64"\n"
 
3219
                        "InnoDB: is lower than at startup %"PRIu64"!\n",
 
3220
                        lsn, srv_start_lsn);
3242
3221
        }
3243
3222
 
3244
3223
        srv_shutdown_lsn = lsn;
3250
3229
        fil_close_all_files();
3251
3230
 
3252
3231
        /* Make some checks that the server really is quiet */
3253
 
        ut_a(!srv_is_any_background_thread_active());
3254
 
 
 
3232
        ut_a(srv_n_threads_active[SRV_MASTER] == 0);
3255
3233
        ut_a(buf_all_freed());
3256
3234
        ut_a(lsn == log_sys->lsn);
3257
3235
}
3292
3270
 
3293
3271
        ut_memcpy(scan_buf, start, end - start);
3294
3272
 
3295
 
        recv_scan_log_recs((buf_pool_get_n_pages()
3296
 
                           - (recv_n_pool_free_frames * srv_buf_pool_instances))
3297
 
                           * UNIV_PAGE_SIZE, FALSE, scan_buf, end - start,
 
3273
        recv_scan_log_recs((buf_pool->curr_size
 
3274
                            - recv_n_pool_free_frames) * UNIV_PAGE_SIZE,
 
3275
                           FALSE, scan_buf, end - start,
3298
3276
                           ut_uint64_align_down(buf_start_lsn,
3299
3277
                                                OS_FILE_LOG_BLOCK_SIZE),
3300
3278
                           &contiguous_lsn, &scanned_lsn);