← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/trx/trx0sys.cc

  • Committer: Monty Taylor
  • Date: 2011-02-13 17:26:39 UTC
  • mfrom: (2157.2.2 give-in-to-pkg-config)
  • mto: This revision was merged to the branch mainline in revision 2166.
  • Revision ID: mordred@inaugust.com-20110213172639-nhy7i72sfhoq13ms
Merged in pkg-config fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/trx/trx0sys.cc
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (c) 1996, 2010, Innobase Oy. All Rights Reserved.
 
3
Copyright (C) 1996, 2010, Innobase Oy. All Rights Reserved.
4
4
 
5
5
This program is free software; you can redistribute it and/or modify it under
6
6
the terms of the GNU General Public License as published by the Free Software
39
39
#include "srv0srv.h"
40
40
#include "trx0purge.h"
41
41
#include "log0log.h"
 
42
#include "log0recv.h"
42
43
#include "os0file.h"
43
44
#include "read0read.h"
44
45
 
89
90
UNIV_INTERN char        trx_sys_mysql_bin_log_name[TRX_SYS_MYSQL_LOG_NAME_LEN];
90
91
/** Binlog file position, or -1 if unknown */
91
92
UNIV_INTERN ib_int64_t  trx_sys_mysql_bin_log_pos       = -1;
 
93
 
 
94
UNIV_INTERN drizzled::atomic<uint64_t> trx_sys_commit_id;
 
95
 
92
96
/* @} */
93
97
#endif /* !UNIV_HOTBACKUP */
94
98
 
126
130
static const ulint      FILE_FORMAT_NAME_N
127
131
        = sizeof(file_format_name_map) / sizeof(file_format_name_map[0]);
128
132
 
 
133
#ifdef UNIV_PFS_MUTEX
 
134
/* Key to register the mutex with performance schema */
 
135
UNIV_INTERN mysql_pfs_key_t     trx_doublewrite_mutex_key;
 
136
UNIV_INTERN mysql_pfs_key_t     file_format_max_mutex_key;
 
137
#endif /* UNIV_PFS_MUTEX */
 
138
 
129
139
#ifndef UNIV_HOTBACKUP
130
140
/** This is used to track the maximum file format id known to InnoDB. It's
131
 
updated via SET GLOBAL innodb_file_format_check = 'x' or when we open
 
141
updated via SET GLOBAL innodb_file_format_max = 'x' or when we open
132
142
or create a table. */
133
143
static  file_format_t   file_format_max;
134
144
 
171
181
        byte*   doublewrite)    /*!< in: pointer to the doublewrite buf
172
182
                                header on trx sys page */
173
183
{
174
 
        trx_doublewrite = mem_alloc(sizeof(trx_doublewrite_t));
 
184
  trx_doublewrite = static_cast<trx_doublewrite_t *>(mem_alloc(sizeof(trx_doublewrite_t)));
175
185
 
176
186
        /* Since we now start to use the doublewrite buffer, no need to call
177
187
        fsync() after every write to a data file */
179
189
        os_do_not_call_flush_at_each_write = TRUE;
180
190
#endif /* UNIV_DO_FLUSH */
181
191
 
182
 
        mutex_create(&trx_doublewrite->mutex, SYNC_DOUBLEWRITE);
 
192
        mutex_create(trx_doublewrite_mutex_key,
 
193
                     &trx_doublewrite->mutex, SYNC_DOUBLEWRITE);
183
194
 
184
195
        trx_doublewrite->first_free = 0;
185
196
 
187
198
                doublewrite + TRX_SYS_DOUBLEWRITE_BLOCK1);
188
199
        trx_doublewrite->block2 = mach_read_from_4(
189
200
                doublewrite + TRX_SYS_DOUBLEWRITE_BLOCK2);
190
 
        trx_doublewrite->write_buf_unaligned = ut_malloc(
191
 
                (1 + 2 * TRX_SYS_DOUBLEWRITE_BLOCK_SIZE) * UNIV_PAGE_SIZE);
 
201
        trx_doublewrite->write_buf_unaligned = static_cast<byte *>(ut_malloc(
 
202
                                                                             (1 + 2 * TRX_SYS_DOUBLEWRITE_BLOCK_SIZE) * UNIV_PAGE_SIZE));
192
203
 
193
 
        trx_doublewrite->write_buf = ut_align(
194
 
                trx_doublewrite->write_buf_unaligned, UNIV_PAGE_SIZE);
195
 
        trx_doublewrite->buf_block_arr = mem_alloc(
196
 
                2 * TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * sizeof(void*));
 
204
        trx_doublewrite->write_buf = static_cast<byte *>(ut_align(
 
205
                                                                  trx_doublewrite->write_buf_unaligned, UNIV_PAGE_SIZE));
 
206
        trx_doublewrite->buf_block_arr = static_cast<buf_page_t **>(mem_alloc(
 
207
                                                                             2 * TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * sizeof(void*)));
197
208
}
198
209
 
199
210
/****************************************************************//**
241
252
{
242
253
        buf_block_t*    block;
243
254
        buf_block_t*    block2;
 
255
#ifdef UNIV_SYNC_DEBUG
244
256
        buf_block_t*    new_block;
 
257
#endif /* UNIV_SYNC_DEBUG */
245
258
        byte*   doublewrite;
246
259
        byte*   fseg_header;
247
260
        ulint   page_no;
344
357
                        the page position in the tablespace, then the page
345
358
                        has not been written to in doublewrite. */
346
359
 
347
 
                        new_block = buf_page_get(TRX_SYS_SPACE, 0, page_no,
348
 
                                                 RW_X_LATCH, &mtr);
 
360
#ifdef UNIV_SYNC_DEBUG
 
361
                        new_block =
 
362
#endif /* UNIV_SYNC_DEBUG */
 
363
                        buf_page_get(TRX_SYS_SPACE, 0, page_no,
 
364
                                     RW_X_LATCH, &mtr);
349
365
                        buf_block_dbg_add_level(new_block,
350
366
                                                SYNC_NO_ORDER_CHECK);
351
367
 
427
443
 
428
444
        /* We do the file i/o past the buffer pool */
429
445
 
430
 
        unaligned_read_buf = ut_malloc(2 * UNIV_PAGE_SIZE);
431
 
        read_buf = ut_align(unaligned_read_buf, UNIV_PAGE_SIZE);
 
446
        unaligned_read_buf = static_cast<byte *>(ut_malloc(2 * UNIV_PAGE_SIZE));
 
447
        read_buf = static_cast<byte *>(ut_align(unaligned_read_buf, UNIV_PAGE_SIZE));
432
448
 
433
449
        /* Read the trx sys header to check if we are using the doublewrite
434
450
        buffer */
656
672
 
657
673
        sys_header = trx_sysf_get(&mtr);
658
674
 
659
 
        mlog_write_dulint(sys_header + TRX_SYS_TRX_ID_STORE,
660
 
                          trx_sys->max_trx_id, &mtr);
 
675
        mlog_write_ull(sys_header + TRX_SYS_TRX_ID_STORE,
 
676
                       trx_sys->max_trx_id, &mtr);
661
677
        mtr_commit(&mtr);
662
678
}
663
679
 
664
 
/*****************************************************************//**
665
 
Updates the offset information about the end of the MySQL binlog entry
666
 
which corresponds to the transaction just being committed. In a MySQL
667
 
replication slave updates the latest master binlog position up to which
668
 
replication has proceeded. */
669
680
UNIV_INTERN
670
681
void
671
 
trx_sys_update_mysql_binlog_offset(
672
 
/*===============================*/
673
 
        const char*     file_name,/*!< in: MySQL log file name */
674
 
        ib_int64_t      offset, /*!< in: position in that log file */
675
 
        ulint           field,  /*!< in: offset of the MySQL log info field in
676
 
                                the trx sys header */
677
 
        mtr_t*          mtr)    /*!< in: mtr */
 
682
trx_sys_flush_commit_id(uint64_t commit_id, ulint field, mtr_t* mtr)
678
683
{
679
 
        trx_sysf_t*     sys_header;
680
 
 
681
 
        if (ut_strlen(file_name) >= TRX_SYS_MYSQL_LOG_NAME_LEN) {
682
 
 
683
 
                /* We cannot fit the name to the 512 bytes we have reserved */
684
 
 
685
 
                return;
686
 
        }
687
 
 
 
684
        trx_sysf_t*     sys_header;
 
685
  
688
686
        sys_header = trx_sysf_get(mtr);
689
687
 
690
 
        if (mach_read_from_4(sys_header + field
691
 
                             + TRX_SYS_MYSQL_LOG_MAGIC_N_FLD)
692
 
            != TRX_SYS_MYSQL_LOG_MAGIC_N) {
693
 
 
694
 
                mlog_write_ulint(sys_header + field
695
 
                                 + TRX_SYS_MYSQL_LOG_MAGIC_N_FLD,
696
 
                                 TRX_SYS_MYSQL_LOG_MAGIC_N,
697
 
                                 MLOG_4BYTES, mtr);
698
 
        }
699
 
 
700
 
        if (0 != strcmp((char*) (sys_header + field + TRX_SYS_MYSQL_LOG_NAME),
701
 
                        file_name)) {
702
 
 
703
 
                mlog_write_string(sys_header + field
704
 
                                  + TRX_SYS_MYSQL_LOG_NAME,
705
 
                                  (byte*) file_name, 1 + ut_strlen(file_name),
706
 
                                  mtr);
707
 
        }
708
 
 
709
 
        if (mach_read_from_4(sys_header + field
710
 
                             + TRX_SYS_MYSQL_LOG_OFFSET_HIGH) > 0
711
 
            || (offset >> 32) > 0) {
712
 
 
713
 
                mlog_write_ulint(sys_header + field
714
 
                                 + TRX_SYS_MYSQL_LOG_OFFSET_HIGH,
715
 
                                 (ulint)(offset >> 32),
716
 
                                 MLOG_4BYTES, mtr);
717
 
        }
718
 
 
719
 
        mlog_write_ulint(sys_header + field
720
 
                         + TRX_SYS_MYSQL_LOG_OFFSET_LOW,
721
 
                         (ulint)(offset & 0xFFFFFFFFUL),
722
 
                         MLOG_4BYTES, mtr);
 
688
        mlog_write_ull(sys_header + field + TRX_SYS_DRIZZLE_MAX_COMMIT_ID, 
 
689
                       commit_id, mtr);
723
690
}
724
691
 
725
 
/*****************************************************************//**
726
 
Stores the MySQL binlog offset info in the trx system header if
727
 
the magic number shows it valid, and print the info to stderr */
 
692
 
728
693
UNIV_INTERN
729
694
void
730
 
trx_sys_print_mysql_binlog_offset(void)
 
695
trx_sys_read_commit_id(void)
731
696
/*===================================*/
732
697
{
733
 
        trx_sysf_t*     sys_header;
734
 
        mtr_t           mtr;
735
 
        ulint           trx_sys_mysql_bin_log_pos_high;
736
 
        ulint           trx_sys_mysql_bin_log_pos_low;
737
 
 
738
 
        mtr_start(&mtr);
739
 
 
740
 
        sys_header = trx_sysf_get(&mtr);
741
 
 
742
 
        if (mach_read_from_4(sys_header + TRX_SYS_MYSQL_LOG_INFO
743
 
                             + TRX_SYS_MYSQL_LOG_MAGIC_N_FLD)
744
 
            != TRX_SYS_MYSQL_LOG_MAGIC_N) {
745
 
 
746
 
                mtr_commit(&mtr);
747
 
 
748
 
                return;
749
 
        }
750
 
 
751
 
        trx_sys_mysql_bin_log_pos_high = mach_read_from_4(
752
 
                sys_header + TRX_SYS_MYSQL_LOG_INFO
753
 
                + TRX_SYS_MYSQL_LOG_OFFSET_HIGH);
754
 
        trx_sys_mysql_bin_log_pos_low = mach_read_from_4(
755
 
                sys_header + TRX_SYS_MYSQL_LOG_INFO
756
 
                + TRX_SYS_MYSQL_LOG_OFFSET_LOW);
757
 
 
758
 
        trx_sys_mysql_bin_log_pos
759
 
                = (((ib_int64_t)trx_sys_mysql_bin_log_pos_high) << 32)
760
 
                + (ib_int64_t)trx_sys_mysql_bin_log_pos_low;
761
 
 
762
 
        ut_memcpy(trx_sys_mysql_bin_log_name,
763
 
                  sys_header + TRX_SYS_MYSQL_LOG_INFO
764
 
                  + TRX_SYS_MYSQL_LOG_NAME, TRX_SYS_MYSQL_LOG_NAME_LEN);
765
 
 
766
 
        fprintf(stderr,
767
 
                "InnoDB: Last MySQL binlog file position %lu %lu,"
768
 
                " file name %s\n",
769
 
                trx_sys_mysql_bin_log_pos_high, trx_sys_mysql_bin_log_pos_low,
770
 
                trx_sys_mysql_bin_log_name);
771
 
 
772
 
        mtr_commit(&mtr);
773
 
}
774
 
 
775
 
/*****************************************************************//**
776
 
Prints to stderr the MySQL master log offset info in the trx system header if
777
 
the magic number shows it valid. */
778
 
UNIV_INTERN
779
 
void
780
 
trx_sys_print_mysql_master_log_pos(void)
781
 
/*====================================*/
782
 
{
783
 
        trx_sysf_t*     sys_header;
784
 
        mtr_t           mtr;
785
 
 
786
 
        mtr_start(&mtr);
787
 
 
788
 
        sys_header = trx_sysf_get(&mtr);
789
 
 
790
 
        if (mach_read_from_4(sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
791
 
                             + TRX_SYS_MYSQL_LOG_MAGIC_N_FLD)
792
 
            != TRX_SYS_MYSQL_LOG_MAGIC_N) {
793
 
 
794
 
                mtr_commit(&mtr);
795
 
 
796
 
                return;
797
 
        }
798
 
 
799
 
        fprintf(stderr,
800
 
                "InnoDB: In a MySQL replication slave the last"
801
 
                " master binlog file\n"
802
 
                "InnoDB: position %lu %lu, file name %s\n",
803
 
                (ulong) mach_read_from_4(sys_header
804
 
                                         + TRX_SYS_MYSQL_MASTER_LOG_INFO
805
 
                                         + TRX_SYS_MYSQL_LOG_OFFSET_HIGH),
806
 
                (ulong) mach_read_from_4(sys_header
807
 
                                         + TRX_SYS_MYSQL_MASTER_LOG_INFO
808
 
                                         + TRX_SYS_MYSQL_LOG_OFFSET_LOW),
809
 
                sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
810
 
                + TRX_SYS_MYSQL_LOG_NAME);
811
 
        /* Copy the master log position info to global variables we can
812
 
        use in ha_innobase.cc to initialize glob_mi to right values */
813
 
 
814
 
        ut_memcpy(trx_sys_mysql_master_log_name,
815
 
                  sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
816
 
                  + TRX_SYS_MYSQL_LOG_NAME,
817
 
                  TRX_SYS_MYSQL_LOG_NAME_LEN);
818
 
 
819
 
        trx_sys_mysql_master_log_pos
820
 
                = (((ib_int64_t) mach_read_from_4(
821
 
                            sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
822
 
                            + TRX_SYS_MYSQL_LOG_OFFSET_HIGH)) << 32)
823
 
                + ((ib_int64_t) mach_read_from_4(
824
 
                           sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
825
 
                           + TRX_SYS_MYSQL_LOG_OFFSET_LOW));
 
698
        trx_sysf_t*     sys_header;
 
699
        mtr_t           mtr;
 
700
 
 
701
        mtr_start(&mtr);
 
702
 
 
703
        sys_header = trx_sysf_get(&mtr);
 
704
 
 
705
        trx_sys_commit_id = mach_read_from_8(sys_header + TRX_SYS_DRIZZLE_LOG_INFO 
 
706
                                             + TRX_SYS_DRIZZLE_MAX_COMMIT_ID);
 
707
 
826
708
        mtr_commit(&mtr);
827
709
}
828
710
 
870
752
        buf_block_t*    block;
871
753
        page_t*         page;
872
754
        ulint           page_no;
873
 
        ulint           i;
 
755
        byte*           ptr;
 
756
        ulint           len;
874
757
 
875
758
        ut_ad(mtr);
876
759
 
903
786
        sys_header = trx_sysf_get(mtr);
904
787
 
905
788
        /* Start counting transaction ids from number 1 up */
906
 
        mlog_write_dulint(sys_header + TRX_SYS_TRX_ID_STORE,
907
 
                          ut_dulint_create(0, 1), mtr);
908
 
 
909
 
        /* Reset the rollback segment slots */
910
 
        for (i = 0; i < TRX_SYS_N_RSEGS; i++) {
911
 
 
912
 
                trx_sysf_rseg_set_space(sys_header, i, ULINT_UNDEFINED, mtr);
913
 
                trx_sysf_rseg_set_page_no(sys_header, i, FIL_NULL, mtr);
914
 
        }
915
 
 
916
 
        /* The remaining area (up to the page trailer) is uninitialized.
917
 
        Silence Valgrind warnings about it. */
918
 
        UNIV_MEM_VALID(sys_header + (TRX_SYS_RSEGS
919
 
                                     + TRX_SYS_N_RSEGS * TRX_SYS_RSEG_SLOT_SIZE
920
 
                                     + TRX_SYS_RSEG_SPACE),
921
 
                       (UNIV_PAGE_SIZE - FIL_PAGE_DATA_END
922
 
                        - (TRX_SYS_RSEGS
923
 
                           + TRX_SYS_N_RSEGS * TRX_SYS_RSEG_SLOT_SIZE
924
 
                           + TRX_SYS_RSEG_SPACE))
925
 
                       + page - sys_header);
 
789
        mach_write_to_8(sys_header + TRX_SYS_TRX_ID_STORE, 1);
 
790
 
 
791
        /* Reset the rollback segment slots.  Old versions of InnoDB
 
792
        define TRX_SYS_N_RSEGS as 256 (TRX_SYS_OLD_N_RSEGS) and expect
 
793
        that the whole array is initialized. */
 
794
        ptr = TRX_SYS_RSEGS + sys_header;
 
795
        len = ut_max(TRX_SYS_OLD_N_RSEGS, TRX_SYS_N_RSEGS)
 
796
                * TRX_SYS_RSEG_SLOT_SIZE;
 
797
        memset(ptr, 0xff, len);
 
798
        ptr += len;
 
799
        ut_a(ptr <= page + (UNIV_PAGE_SIZE - FIL_PAGE_DATA_END));
 
800
 
 
801
        /* Initialize all of the page.  This part used to be uninitialized. */
 
802
        memset(ptr, 0, UNIV_PAGE_SIZE - FIL_PAGE_DATA_END + page - ptr);
 
803
 
 
804
        mlog_log_string(sys_header, UNIV_PAGE_SIZE - FIL_PAGE_DATA_END
 
805
                        + page - sys_header, mtr);
926
806
 
927
807
        /* Create the first rollback segment in the SYSTEM tablespace */
928
 
        page_no = trx_rseg_header_create(TRX_SYS_SPACE, 0, ULINT_MAX, &slot_no,
 
808
        slot_no = trx_sysf_rseg_find_free(mtr);
 
809
        page_no = trx_rseg_header_create(TRX_SYS_SPACE, 0, ULINT_MAX, slot_no,
929
810
                                         mtr);
930
811
        ut_a(slot_no == TRX_SYS_SYSTEM_RSEG_ID);
931
 
        ut_a(page_no != FIL_NULL);
 
812
        ut_a(page_no == FSP_FIRST_RSEG_PAGE_NO);
932
813
 
933
814
        mutex_exit(&kernel_mutex);
934
815
}
942
823
/*==========================*/
943
824
{
944
825
        trx_sysf_t*     sys_header;
945
 
        ib_int64_t      rows_to_undo    = 0;
 
826
        ib_uint64_t     rows_to_undo    = 0;
946
827
        const char*     unit            = "";
947
828
        trx_t*          trx;
948
829
        mtr_t           mtr;
953
834
 
954
835
        mutex_enter(&kernel_mutex);
955
836
 
956
 
        trx_sys = mem_alloc(sizeof(trx_sys_t));
 
837
        trx_sys = static_cast<trx_sys_t *>(mem_alloc(sizeof(trx_sys_t)));
957
838
 
958
839
        sys_header = trx_sysf_get(&mtr);
959
840
 
968
849
        to the disk-based header! Thus trx id values will not overlap when
969
850
        the database is repeatedly started! */
970
851
 
971
 
        trx_sys->max_trx_id = ut_dulint_add(
972
 
                ut_dulint_align_up(mtr_read_dulint(
973
 
                                           sys_header
974
 
                                           + TRX_SYS_TRX_ID_STORE, &mtr),
975
 
                                   TRX_SYS_TRX_ID_WRITE_MARGIN),
976
 
                2 * TRX_SYS_TRX_ID_WRITE_MARGIN);
 
852
        trx_sys->max_trx_id = 2 * TRX_SYS_TRX_ID_WRITE_MARGIN
 
853
                + ut_uint64_align_up(mach_read_from_8(sys_header
 
854
                                                   + TRX_SYS_TRX_ID_STORE),
 
855
                                     TRX_SYS_TRX_ID_WRITE_MARGIN);
977
856
 
978
857
        UT_LIST_INIT(trx_sys->mysql_trx_list);
979
858
        trx_dummy_sess = sess_open();
984
863
 
985
864
                for (;;) {
986
865
 
987
 
                        if ( trx->conc_state != TRX_PREPARED) {
988
 
                                rows_to_undo += ut_conv_dulint_to_longlong(
989
 
                                        trx->undo_no);
 
866
                        if (trx->conc_state != TRX_PREPARED) {
 
867
                                rows_to_undo += trx->undo_no;
990
868
                        }
991
869
 
992
870
                        trx = UT_LIST_GET_NEXT(trx_list, trx);
1009
887
                        (ulong) rows_to_undo, unit);
1010
888
 
1011
889
                fprintf(stderr, "InnoDB: Trx id counter is " TRX_ID_FMT "\n",
1012
 
                        TRX_ID_PREP_PRINTF(trx_sys->max_trx_id));
 
890
                        trx_sys->max_trx_id);
1013
891
        }
1014
892
 
1015
893
        UT_LIST_INIT(trx_sys->view_list);
1053
931
        mtr_t           mtr;
1054
932
        byte*           ptr;
1055
933
        buf_block_t*    block;
1056
 
        ulint           tag_value_low;
 
934
        ib_uint64_t     tag_value;
1057
935
 
1058
936
        mtr_start(&mtr);
1059
937
 
1064
942
        file_format_max.name = trx_sys_file_format_id_to_name(format_id);
1065
943
 
1066
944
        ptr = buf_block_get_frame(block) + TRX_SYS_FILE_FORMAT_TAG;
1067
 
        tag_value_low = format_id + TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_LOW;
 
945
        tag_value = format_id + TRX_SYS_FILE_FORMAT_TAG_MAGIC_N;
1068
946
 
1069
947
        if (name) {
1070
948
                *name = file_format_max.name;
1071
949
        }
1072
950
 
1073
 
        mlog_write_dulint(
1074
 
                ptr,
1075
 
                ut_dulint_create(TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_HIGH,
1076
 
                                 tag_value_low),
1077
 
                &mtr);
 
951
        mlog_write_ull(ptr, tag_value, &mtr);
1078
952
 
1079
953
        mtr_commit(&mtr);
1080
954
 
1092
966
        mtr_t                   mtr;
1093
967
        const byte*             ptr;
1094
968
        const buf_block_t*      block;
1095
 
        ulint                   format_id;
1096
 
        dulint                  file_format_id;
 
969
        ib_id_t                 file_format_id;
1097
970
 
1098
971
        /* Since this is called during the startup phase it's safe to
1099
972
        read the value without a covering mutex. */
1107
980
 
1108
981
        mtr_commit(&mtr);
1109
982
 
1110
 
        format_id = file_format_id.low - TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_LOW;
 
983
        file_format_id -= TRX_SYS_FILE_FORMAT_TAG_MAGIC_N;
1111
984
 
1112
 
        if (file_format_id.high != TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_HIGH
1113
 
            || format_id >= FILE_FORMAT_NAME_N) {
 
985
        if (file_format_id >= FILE_FORMAT_NAME_N) {
1114
986
 
1115
987
                /* Either it has never been tagged, or garbage in it. */
1116
988
                return(ULINT_UNDEFINED);
1117
989
        }
1118
990
 
1119
 
        return(format_id);
 
991
        return((ulint) file_format_id);
1120
992
}
1121
993
 
1122
994
/*****************************************************************//**
1152
1024
        if (format_id == ULINT_UNDEFINED) {
1153
1025
                /* Format ID was not set. Set it to minimum possible
1154
1026
                value. */
1155
 
                format_id = DICT_TF_FORMAT_51;
 
1027
                format_id = DICT_TF_FORMAT_MIN;
1156
1028
        }
1157
1029
 
1158
1030
        ut_print_timestamp(stderr);
1232
1104
 
1233
1105
        /* If format_id is not set then set it to the minimum. */
1234
1106
        if (format_id == ULINT_UNDEFINED) {
1235
 
                trx_sys_file_format_max_set(DICT_TF_FORMAT_51, NULL);
 
1107
                trx_sys_file_format_max_set(DICT_TF_FORMAT_MIN, NULL);
1236
1108
        }
1237
1109
}
1238
1110
 
1283
1155
trx_sys_file_format_init(void)
1284
1156
/*==========================*/
1285
1157
{
1286
 
        mutex_create(&file_format_max.mutex, SYNC_FILE_FORMAT_TAG);
 
1158
        mutex_create(file_format_max_mutex_key,
 
1159
                     &file_format_max.mutex, SYNC_FILE_FORMAT_TAG);
1287
1160
 
1288
1161
        /* We don't need a mutex here, as this function should only
1289
1162
        be called once at start up. */
1290
 
        file_format_max.id = DICT_TF_FORMAT_51;
 
1163
        file_format_max.id = DICT_TF_FORMAT_MIN;
1291
1164
 
1292
1165
        file_format_max.name = trx_sys_file_format_id_to_name(
1293
1166
                file_format_max.id);
1302
1175
{
1303
1176
        /* Does nothing at the moment */
1304
1177
}
 
1178
 
 
1179
/*********************************************************************
 
1180
Creates the rollback segments */
 
1181
UNIV_INTERN
 
1182
void
 
1183
trx_sys_create_rsegs(
 
1184
/*=================*/
 
1185
        ulint   n_rsegs)        /*!< number of rollback segments to create */
 
1186
{
 
1187
        ulint   new_rsegs = 0;
 
1188
 
 
1189
        /* Do not create additional rollback segments if
 
1190
        innodb_force_recovery has been set and the database
 
1191
        was not shutdown cleanly. */
 
1192
        if (!srv_force_recovery && !recv_needed_recovery) {
 
1193
                ulint   i;
 
1194
 
 
1195
                for (i = 0;  i < n_rsegs; ++i) {
 
1196
 
 
1197
                        if (trx_rseg_create() != NULL) {
 
1198
                                ++new_rsegs;
 
1199
                        } else {
 
1200
                                break;
 
1201
                        }
 
1202
                }
 
1203
        }
 
1204
 
 
1205
        if (new_rsegs > 0) {
 
1206
                fprintf(stderr,
 
1207
                        "InnoDB: %lu rollback segment(s) active.\n",
 
1208
                        new_rsegs);
 
1209
        }
 
1210
}
 
1211
 
1305
1212
#else /* !UNIV_HOTBACKUP */
1306
 
/*****************************************************************//**
1307
 
Prints to stderr the MySQL binlog info in the system header if the
1308
 
magic number shows it valid. */
1309
 
UNIV_INTERN
1310
 
void
1311
 
trx_sys_print_mysql_binlog_offset_from_page(
1312
 
/*========================================*/
1313
 
        const byte*     page)   /*!< in: buffer containing the trx
1314
 
                                system header page, i.e., page number
1315
 
                                TRX_SYS_PAGE_NO in the tablespace */
1316
 
{
1317
 
        const trx_sysf_t*       sys_header;
1318
 
 
1319
 
        sys_header = page + TRX_SYS;
1320
 
 
1321
 
        if (mach_read_from_4(sys_header + TRX_SYS_MYSQL_LOG_INFO
1322
 
                             + TRX_SYS_MYSQL_LOG_MAGIC_N_FLD)
1323
 
            == TRX_SYS_MYSQL_LOG_MAGIC_N) {
1324
 
 
1325
 
                fprintf(stderr,
1326
 
                        "ibbackup: Last MySQL binlog file position %lu %lu,"
1327
 
                        " file name %s\n",
1328
 
                        (ulong) mach_read_from_4(
1329
 
                                sys_header + TRX_SYS_MYSQL_LOG_INFO
1330
 
                                + TRX_SYS_MYSQL_LOG_OFFSET_HIGH),
1331
 
                        (ulong) mach_read_from_4(
1332
 
                                sys_header + TRX_SYS_MYSQL_LOG_INFO
1333
 
                                + TRX_SYS_MYSQL_LOG_OFFSET_LOW),
1334
 
                        sys_header + TRX_SYS_MYSQL_LOG_INFO
1335
 
                        + TRX_SYS_MYSQL_LOG_NAME);
1336
 
        }
1337
 
}
1338
 
 
1339
1213
 
1340
1214
/* THESE ARE COPIED FROM NON-HOTBACKUP PART OF THE INNODB SOURCE TREE
1341
1215
   (This code duplicaton should be fixed at some point!)
1373
1247
        byte            buf[UNIV_PAGE_SIZE * 2];
1374
1248
        page_t*         page = ut_align(buf, UNIV_PAGE_SIZE);
1375
1249
        const byte*     ptr;
1376
 
        dulint          file_format_id;
 
1250
        ib_id_t         file_format_id;
1377
1251
 
1378
1252
        *format_id = ULINT_UNDEFINED;
1379
 
        
 
1253
 
1380
1254
        file = os_file_create_simple_no_error_handling(
 
1255
                innodb_file_data_key,
1381
1256
                pathname,
1382
1257
                OS_FILE_OPEN,
1383
1258
                OS_FILE_READ_ONLY,
1386
1261
        if (!success) {
1387
1262
                /* The following call prints an error message */
1388
1263
                os_file_get_last_error(TRUE);
1389
 
        
 
1264
 
1390
1265
                ut_print_timestamp(stderr);
1391
 
        
 
1266
 
1392
1267
                fprintf(stderr,
1393
1268
"  ibbackup: Error: trying to read system tablespace file format,\n"
1394
1269
"  ibbackup: but could not open the tablespace file %s!\n",
1405
1280
        if (!success) {
1406
1281
                /* The following call prints an error message */
1407
1282
                os_file_get_last_error(TRUE);
1408
 
        
 
1283
 
1409
1284
                ut_print_timestamp(stderr);
1410
 
        
 
1285
 
1411
1286
                fprintf(stderr,
1412
1287
"  ibbackup: Error: trying to read system table space file format,\n"
1413
1288
"  ibbackup: but failed to read the tablespace file %s!\n",
1421
1296
        /* get the file format from the page */
1422
1297
        ptr = page + TRX_SYS_FILE_FORMAT_TAG;
1423
1298
        file_format_id = mach_read_from_8(ptr);
1424
 
 
1425
 
        *format_id = file_format_id.low - TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_LOW;
1426
 
 
1427
 
        if (file_format_id.high != TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_HIGH
1428
 
            || *format_id >= FILE_FORMAT_NAME_N) {
 
1299
        file_format_id -= TRX_SYS_FILE_FORMAT_TAG_MAGIC_N;
 
1300
 
 
1301
        if (file_format_id >= FILE_FORMAT_NAME_N) {
1429
1302
 
1430
1303
                /* Either it has never been tagged, or garbage in it. */
1431
 
                *format_id = ULINT_UNDEFINED;
1432
1304
                return(TRUE);
1433
1305
        }
1434
 
        
 
1306
 
 
1307
        *format_id = (ulint) file_format_id;
 
1308
 
1435
1309
        return(TRUE);
1436
1310
}
1437
1311
 
1456
1330
        ib_uint32_t     flags;
1457
1331
 
1458
1332
        *format_id = ULINT_UNDEFINED;
1459
 
        
 
1333
 
1460
1334
        file = os_file_create_simple_no_error_handling(
 
1335
                innodb_file_data_key,
1461
1336
                pathname,
1462
1337
                OS_FILE_OPEN,
1463
1338
                OS_FILE_READ_ONLY,
1556
1431
                        "InnoDB: Error: all read views were not closed"
1557
1432
                        " before shutdown:\n"
1558
1433
                        "InnoDB: %lu read views open \n",
1559
 
                        UT_LIST_GET_LEN(trx_sys->view_list) - 1);
 
1434
                        static_cast<ulint>(UT_LIST_GET_LEN(trx_sys->view_list)) - 1);
1560
1435
        }
1561
1436
 
1562
1437
        sess_close(trx_dummy_sess);