← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Lee Bieber
  • Date: 2010-11-14 23:15:42 UTC
  • mfrom: (1929.1.42 warning-stack-frame)
  • Revision ID: kalebral@gmail.com-20101114231542-fnnu6ydd2p17n582
Merge Monty - fix bug 672372: some functions use > 32k stack

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
82
82
/* Global log system variable */
83
83
UNIV_INTERN log_t*      log_sys = NULL;
84
84
 
85
 
#ifdef UNIV_PFS_RWLOCK
86
 
UNIV_INTERN mysql_pfs_key_t     checkpoint_lock_key;
87
 
# ifdef UNIV_LOG_ARCHIVE
88
 
UNIV_INTERN mysql_pfs_key_t     archive_lock_key;
89
 
# endif
90
 
#endif /* UNIV_PFS_RWLOCK */
91
 
 
92
 
#ifdef UNIV_PFS_MUTEX
93
 
UNIV_INTERN mysql_pfs_key_t     log_sys_mutex_key;
94
 
UNIV_INTERN mysql_pfs_key_t     log_flush_order_mutex_key;
95
 
#endif /* UNIV_PFS_MUTEX */
96
 
 
97
85
#ifdef UNIV_DEBUG
98
86
UNIV_INTERN ibool       log_do_write = TRUE;
99
87
#endif /* UNIV_DEBUG */
328
316
        str_len -= len;
329
317
        str = str + len;
330
318
 
331
 
        log_block = static_cast<unsigned char *>(ut_align_down(log->buf + log->buf_free,
332
 
                                OS_FILE_LOG_BLOCK_SIZE));
 
319
        log_block = ut_align_down(log->buf + log->buf_free,
 
320
                                  OS_FILE_LOG_BLOCK_SIZE);
333
321
        log_block_set_data_len(log_block, data_len);
334
322
 
335
323
        if (data_len == OS_FILE_LOG_BLOCK_SIZE - LOG_BLOCK_TRL_SIZE) {
378
366
 
379
367
        lsn = log->lsn;
380
368
 
381
 
        log_block = static_cast<unsigned char *>(ut_align_down(log->buf + log->buf_free,
382
 
                                OS_FILE_LOG_BLOCK_SIZE));
 
369
        log_block = ut_align_down(log->buf + log->buf_free,
 
370
                                  OS_FILE_LOG_BLOCK_SIZE);
383
371
        first_rec_group = log_block_get_first_rec_group(log_block);
384
372
 
385
373
        if (first_rec_group == 0) {
766
754
log_init(void)
767
755
/*==========*/
768
756
{
769
 
        log_sys = static_cast<log_t *>(mem_alloc(sizeof(log_t)));
770
 
 
771
 
        mutex_create(log_sys_mutex_key, &log_sys->mutex, SYNC_LOG);
772
 
 
773
 
        mutex_create(log_flush_order_mutex_key,
774
 
                     &log_sys->log_flush_order_mutex,
775
 
                     SYNC_LOG_FLUSH_ORDER);
 
757
        log_sys = mem_alloc(sizeof(log_t));
 
758
 
 
759
        mutex_create(&log_sys->mutex, SYNC_LOG);
776
760
 
777
761
        mutex_enter(&(log_sys->mutex));
778
762
 
784
768
        ut_a(LOG_BUFFER_SIZE >= 16 * OS_FILE_LOG_BLOCK_SIZE);
785
769
        ut_a(LOG_BUFFER_SIZE >= 4 * UNIV_PAGE_SIZE);
786
770
 
787
 
        log_sys->buf_ptr = static_cast<unsigned char *>(mem_alloc(LOG_BUFFER_SIZE + OS_FILE_LOG_BLOCK_SIZE));
788
 
        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);
789
773
 
790
774
        log_sys->buf_size = LOG_BUFFER_SIZE;
791
775
 
828
812
        log_sys->last_checkpoint_lsn = log_sys->lsn;
829
813
        log_sys->n_pending_checkpoint_writes = 0;
830
814
 
831
 
        rw_lock_create(checkpoint_lock_key, &log_sys->checkpoint_lock,
832
 
                       SYNC_NO_ORDER_CHECK);
 
815
        rw_lock_create(&log_sys->checkpoint_lock, SYNC_NO_ORDER_CHECK);
833
816
 
834
 
        log_sys->checkpoint_buf_ptr = static_cast<unsigned char *>(mem_alloc(2 * OS_FILE_LOG_BLOCK_SIZE));
835
 
        log_sys->checkpoint_buf = static_cast<unsigned char *>(ut_align(log_sys->checkpoint_buf_ptr,
836
 
                                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);
837
820
        memset(log_sys->checkpoint_buf, '\0', OS_FILE_LOG_BLOCK_SIZE);
838
821
        /*----------------------------*/
839
822
 
845
828
 
846
829
        log_sys->n_pending_archive_ios = 0;
847
830
 
848
 
        rw_lock_create(archive_lock_key, &log_sys->archive_lock,
849
 
                       SYNC_NO_ORDER_CHECK);
 
831
        rw_lock_create(&log_sys->archive_lock, SYNC_NO_ORDER_CHECK);
850
832
 
851
833
        log_sys->archive_buf = NULL;
852
834
 
895
877
        ulint   space_id,               /*!< in: space id of the file space
896
878
                                        which contains the log files of this
897
879
                                        group */
898
 
        ulint   /*archive_space_id __attribute__((unused))*/)
 
880
        ulint   archive_space_id __attribute__((unused)))
899
881
                                        /*!< in: space id of the file space
900
882
                                        which contains some archived log
901
883
                                        files for this group; currently, only
906
888
 
907
889
        log_group_t*    group;
908
890
 
909
 
        group = static_cast<log_group_t *>(mem_alloc(sizeof(log_group_t)));
 
891
        group = mem_alloc(sizeof(log_group_t));
910
892
 
911
893
        group->id = id;
912
894
        group->n_files = n_files;
917
899
        group->lsn_offset = LOG_FILE_HDR_SIZE;
918
900
        group->n_pending_writes = 0;
919
901
 
920
 
        group->file_header_bufs_ptr = static_cast<unsigned char **>(mem_alloc(sizeof(byte*) * n_files));
921
 
        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);
922
904
#ifdef UNIV_LOG_ARCHIVE
923
905
        group->archive_file_header_bufs_ptr = mem_alloc(
924
906
                sizeof(byte*) * n_files);
926
908
#endif /* UNIV_LOG_ARCHIVE */
927
909
 
928
910
        for (i = 0; i < n_files; i++) {
929
 
                group->file_header_bufs_ptr[i] = static_cast<unsigned char *>(mem_alloc(
930
 
                        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);
931
913
 
932
 
                group->file_header_bufs[i] = static_cast<unsigned char *>(ut_align(
 
914
                group->file_header_bufs[i] = ut_align(
933
915
                        group->file_header_bufs_ptr[i],
934
 
                        OS_FILE_LOG_BLOCK_SIZE));
 
916
                        OS_FILE_LOG_BLOCK_SIZE);
935
917
 
936
918
                memset(*(group->file_header_bufs + i), '\0',
937
919
                       LOG_FILE_HDR_SIZE);
956
938
        group->archived_offset = 0;
957
939
#endif /* UNIV_LOG_ARCHIVE */
958
940
 
959
 
        group->checkpoint_buf_ptr = static_cast<unsigned char *>(mem_alloc(2 * OS_FILE_LOG_BLOCK_SIZE));
960
 
        group->checkpoint_buf = static_cast<unsigned char*>(ut_align(group->checkpoint_buf_ptr,
961
 
                                         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);
962
944
 
963
945
        memset(group->checkpoint_buf, '\0', OS_FILE_LOG_BLOCK_SIZE);
964
946
 
1166
1148
        buf = *(group->file_header_bufs + nth_file);
1167
1149
 
1168
1150
        mach_write_to_4(buf + LOG_GROUP_ID, group->id);
1169
 
        mach_write_to_8(buf + LOG_FILE_START_LSN, start_lsn);
 
1151
        mach_write_ull(buf + LOG_FILE_START_LSN, start_lsn);
1170
1152
 
1171
1153
        /* Wipe over possible label of ibbackup --restore */
1172
1154
        memcpy(buf + LOG_FILE_WAS_CREATED_BY_HOT_BACKUP, "    ", 4);
1655
1637
                recv_apply_hashed_log_recs(TRUE);
1656
1638
        }
1657
1639
 
1658
 
        n_pages = buf_flush_list(ULINT_MAX, new_oldest);
 
1640
        n_pages = buf_flush_batch(BUF_FLUSH_LIST, ULINT_MAX, new_oldest);
1659
1641
 
1660
1642
        if (sync) {
1661
 
                buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST);
 
1643
                buf_flush_wait_batch_end(BUF_FLUSH_LIST);
1662
1644
        }
1663
1645
 
1664
1646
        if (n_pages == ULINT_UNDEFINED) {
1769
1751
 
1770
1752
        buf = group->checkpoint_buf;
1771
1753
 
1772
 
        mach_write_to_8(buf + LOG_CHECKPOINT_NO, log_sys->next_checkpoint_no);
1773
 
        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);
1774
1756
 
1775
1757
        mach_write_to_4(buf + LOG_CHECKPOINT_OFFSET,
1776
1758
                        log_group_calc_lsn_offset(
1790
1772
                }
1791
1773
        }
1792
1774
 
1793
 
        mach_write_to_8(buf + LOG_CHECKPOINT_ARCHIVED_LSN, archived_lsn);
 
1775
        mach_write_ull(buf + LOG_CHECKPOINT_ARCHIVED_LSN, archived_lsn);
1794
1776
#else /* UNIV_LOG_ARCHIVE */
1795
 
        mach_write_to_8(buf + LOG_CHECKPOINT_ARCHIVED_LSN, IB_ULONGLONG_MAX);
 
1777
        mach_write_ull(buf + LOG_CHECKPOINT_ARCHIVED_LSN, IB_ULONGLONG_MAX);
1796
1778
#endif /* UNIV_LOG_ARCHIVE */
1797
1779
 
1798
1780
        for (i = 0; i < LOG_MAX_N_GROUPS; i++) {
1884
1866
        ib_uint64_t     lsn;
1885
1867
 
1886
1868
        mach_write_to_4(hdr_buf + LOG_GROUP_ID, 0);
1887
 
        mach_write_to_8(hdr_buf + LOG_FILE_START_LSN, start);
 
1869
        mach_write_ull(hdr_buf + LOG_FILE_START_LSN, start);
1888
1870
 
1889
1871
        lsn = start + LOG_BLOCK_HDR_SIZE;
1890
1872
 
1896
1878
                                + (sizeof "ibbackup ") - 1));
1897
1879
        buf = hdr_buf + LOG_CHECKPOINT_1;
1898
1880
 
1899
 
        mach_write_to_8(buf + LOG_CHECKPOINT_NO, 0);
1900
 
        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);
1901
1883
 
1902
1884
        mach_write_to_4(buf + LOG_CHECKPOINT_OFFSET,
1903
1885
                        LOG_FILE_HDR_SIZE + LOG_BLOCK_HDR_SIZE);
1904
1886
 
1905
1887
        mach_write_to_4(buf + LOG_CHECKPOINT_LOG_BUF_SIZE, 2 * 1024 * 1024);
1906
1888
 
1907
 
        mach_write_to_8(buf + LOG_CHECKPOINT_ARCHIVED_LSN, IB_ULONGLONG_MAX);
 
1889
        mach_write_ull(buf + LOG_CHECKPOINT_ARCHIVED_LSN, IB_ULONGLONG_MAX);
1908
1890
 
1909
1891
        fold = ut_fold_binary(buf, LOG_CHECKPOINT_CHECKSUM_1);
1910
1892
        mach_write_to_4(buf + LOG_CHECKPOINT_CHECKSUM_1, fold);
2072
2054
{
2073
2055
        /* Preflush pages synchronously */
2074
2056
 
2075
 
        while (!log_preflush_pool_modified_pages(lsn, TRUE)) {}
 
2057
        while (!log_preflush_pool_modified_pages(lsn, TRUE));
2076
2058
 
2077
 
        while (!log_checkpoint(TRUE, write_always)) {}
 
2059
        while (!log_checkpoint(TRUE, write_always));
2078
2060
}
2079
2061
 
2080
2062
/****************************************************************//**
2241
2223
log_archived_file_name_gen(
2242
2224
/*=======================*/
2243
2225
        char*   buf,    /*!< in: buffer where to write */
2244
 
        ulint   /*id __attribute__((unused))*/,
 
2226
        ulint   id __attribute__((unused)),
2245
2227
                        /*!< in: group id;
2246
2228
                        currently we only archive the first group */
2247
2229
        ulint   file_no)/*!< in: file number */
2272
2254
        buf = *(group->archive_file_header_bufs + nth_file);
2273
2255
 
2274
2256
        mach_write_to_4(buf + LOG_GROUP_ID, group->id);
2275
 
        mach_write_to_8(buf + LOG_FILE_START_LSN, start_lsn);
 
2257
        mach_write_ull(buf + LOG_FILE_START_LSN, start_lsn);
2276
2258
        mach_write_to_4(buf + LOG_FILE_NO, file_no);
2277
2259
 
2278
2260
        mach_write_to_4(buf + LOG_FILE_ARCH_COMPLETED, FALSE);
2308
2290
        buf = *(group->archive_file_header_bufs + nth_file);
2309
2291
 
2310
2292
        mach_write_to_4(buf + LOG_FILE_ARCH_COMPLETED, TRUE);
2311
 
        mach_write_to_8(buf + LOG_FILE_END_LSN, end_lsn);
 
2293
        mach_write_ull(buf + LOG_FILE_END_LSN, end_lsn);
2312
2294
 
2313
2295
        dest_offset = nth_file * group->file_size + LOG_FILE_ARCH_COMPLETED;
2314
2296
 
2372
2354
                log_archived_file_name_gen(name, group->id,
2373
2355
                                           group->archived_file_no + n_files);
2374
2356
 
2375
 
                file_handle = os_file_create(innodb_file_log_key,
2376
 
                                             name, open_mode,
2377
 
                                             OS_FILE_AIO,
 
2357
                file_handle = os_file_create(name, open_mode, OS_FILE_AIO,
2378
2358
                                             OS_DATA_FILE, &ret);
2379
2359
 
2380
2360
                if (!ret && (open_mode == OS_FILE_CREATE)) {
2381
2361
                        file_handle = os_file_create(
2382
 
                                innodb_file_log_key, name, OS_FILE_OPEN,
2383
 
                                OS_FILE_AIO, OS_DATA_FILE, &ret);
 
2362
                                name, OS_FILE_OPEN, OS_FILE_AIO,
 
2363
                                OS_DATA_FILE, &ret);
2384
2364
                }
2385
2365
 
2386
2366
                if (!ret) {
3098
3078
 
3099
3079
        if (srv_fast_shutdown < 2
3100
3080
           && (srv_error_monitor_active
3101
 
              || srv_lock_timeout_active
3102
 
              || srv_monitor_active)) {
 
3081
              || srv_lock_timeout_active || srv_monitor_active)) {
3103
3082
 
3104
3083
                mutex_exit(&kernel_mutex);
3105
3084
 
3106
 
                os_event_set(srv_error_event);
3107
 
                os_event_set(srv_monitor_event);
3108
 
                os_event_set(srv_timeout_event);
3109
 
 
3110
3085
                goto loop;
3111
3086
        }
3112
3087
 
3133
3108
 
3134
3109
                log_buffer_flush_to_disk();
3135
3110
 
3136
 
                mutex_exit(&kernel_mutex);
3137
 
 
3138
3111
                return; /* We SKIP ALL THE REST !! */
3139
3112
        }
3140
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
 
3141
3123
        mutex_exit(&kernel_mutex);
3142
3124
 
3143
 
        /* Check that the background threads are suspended */
3144
 
 
3145
 
        if (srv_is_any_background_thread_active()) {
3146
 
                goto loop;
3147
 
        }
3148
 
 
3149
3125
        mutex_enter(&(log_sys->mutex));
3150
3126
 
3151
3127
        if (log_sys->n_pending_checkpoint_writes
3203
3179
 
3204
3180
        mutex_exit(&(log_sys->mutex));
3205
3181
 
3206
 
        /* Check that the background threads stay suspended */
3207
 
        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) {
3208
3185
                fprintf(stderr,
3209
 
                        "InnoDB: Warning: some background thread woke up"
 
3186
                        "InnoDB: Warning: the master thread woke up"
3210
3187
                        " during shutdown\n");
3211
3188
 
 
3189
                mutex_exit(&kernel_mutex);
 
3190
 
3212
3191
                goto loop;
3213
3192
        }
 
3193
        mutex_exit(&kernel_mutex);
3214
3194
 
3215
3195
        fil_flush_file_spaces(FIL_TABLESPACE);
3216
3196
        fil_flush_file_spaces(FIL_LOG);
3228
3208
        srv_shutdown_state = SRV_SHUTDOWN_LAST_PHASE;
3229
3209
 
3230
3210
        /* Make some checks that the server really is quiet */
3231
 
        ut_a(!srv_is_any_background_thread_active());
3232
 
 
 
3211
        ut_a(srv_n_threads_active[SRV_MASTER] == 0);
3233
3212
        ut_a(buf_all_freed());
3234
3213
        ut_a(lsn == log_sys->lsn);
3235
3214
 
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);