← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/trx/trx0sys.c

  • Committer: Monty Taylor
  • Date: 2009-08-12 06:25:19 UTC
  • mto: (1114.1.1 innodb-plugin-merge)
  • mto: This revision was merged to the branch mainline in revision 1183.
  • Revision ID: mordred@inaugust.com-20090812062519-cij02mrrunvnxblt
Tags: innodb-plugin-1.0.4
InnoDB Plugin 1.0.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/trx/trx0sys.c
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (C) 1996, 2010, Innobase Oy. All Rights Reserved.
 
3
Copyright (c) 1996, 2009, 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
11
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
12
 
13
13
You should have received a copy of the GNU General Public License along with
14
 
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15
 
St, Fifth Floor, Boston, MA 02110-1301 USA
 
14
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 
15
Place, Suite 330, Boston, MA 02111-1307 USA
16
16
 
17
17
*****************************************************************************/
18
18
 
39
39
#include "srv0srv.h"
40
40
#include "trx0purge.h"
41
41
#include "log0log.h"
42
 
#include "log0recv.h"
43
42
#include "os0file.h"
44
 
#include "read0read.h"
45
43
 
46
44
/** The file format tag structure with id and name. */
47
45
struct file_format_struct {
90
88
UNIV_INTERN char        trx_sys_mysql_bin_log_name[TRX_SYS_MYSQL_LOG_NAME_LEN];
91
89
/** Binlog file position, or -1 if unknown */
92
90
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
 
 
96
91
/* @} */
97
92
#endif /* !UNIV_HOTBACKUP */
98
93
 
130
125
static const ulint      FILE_FORMAT_NAME_N
131
126
        = sizeof(file_format_name_map) / sizeof(file_format_name_map[0]);
132
127
 
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
 
 
139
128
#ifndef UNIV_HOTBACKUP
140
129
/** This is used to track the maximum file format id known to InnoDB. It's
141
 
updated via SET GLOBAL innodb_file_format_max = 'x' or when we open
 
130
updated via SET GLOBAL innodb_file_format_check = 'x' or when we open
142
131
or create a table. */
143
132
static  file_format_t   file_format_max;
144
133
 
181
170
        byte*   doublewrite)    /*!< in: pointer to the doublewrite buf
182
171
                                header on trx sys page */
183
172
{
184
 
  trx_doublewrite = static_cast<trx_doublewrite_t *>(mem_alloc(sizeof(trx_doublewrite_t)));
 
173
        trx_doublewrite = mem_alloc(sizeof(trx_doublewrite_t));
185
174
 
186
175
        /* Since we now start to use the doublewrite buffer, no need to call
187
176
        fsync() after every write to a data file */
189
178
        os_do_not_call_flush_at_each_write = TRUE;
190
179
#endif /* UNIV_DO_FLUSH */
191
180
 
192
 
        mutex_create(trx_doublewrite_mutex_key,
193
 
                     &trx_doublewrite->mutex, SYNC_DOUBLEWRITE);
 
181
        mutex_create(&trx_doublewrite->mutex, SYNC_DOUBLEWRITE);
194
182
 
195
183
        trx_doublewrite->first_free = 0;
196
184
 
198
186
                doublewrite + TRX_SYS_DOUBLEWRITE_BLOCK1);
199
187
        trx_doublewrite->block2 = mach_read_from_4(
200
188
                doublewrite + TRX_SYS_DOUBLEWRITE_BLOCK2);
201
 
        trx_doublewrite->write_buf_unaligned = static_cast<byte *>(ut_malloc(
202
 
                                                                             (1 + 2 * TRX_SYS_DOUBLEWRITE_BLOCK_SIZE) * UNIV_PAGE_SIZE));
 
189
        trx_doublewrite->write_buf_unaligned = ut_malloc(
 
190
                (1 + 2 * TRX_SYS_DOUBLEWRITE_BLOCK_SIZE) * UNIV_PAGE_SIZE);
203
191
 
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*)));
 
192
        trx_doublewrite->write_buf = ut_align(
 
193
                trx_doublewrite->write_buf_unaligned, UNIV_PAGE_SIZE);
 
194
        trx_doublewrite->buf_block_arr = mem_alloc(
 
195
                2 * TRX_SYS_DOUBLEWRITE_BLOCK_SIZE * sizeof(void*));
208
196
}
209
197
 
210
198
/****************************************************************//**
252
240
{
253
241
        buf_block_t*    block;
254
242
        buf_block_t*    block2;
255
 
#ifdef UNIV_SYNC_DEBUG
256
243
        buf_block_t*    new_block;
257
 
#endif /* UNIV_SYNC_DEBUG */
258
244
        byte*   doublewrite;
259
245
        byte*   fseg_header;
260
246
        ulint   page_no;
357
343
                        the page position in the tablespace, then the page
358
344
                        has not been written to in doublewrite. */
359
345
 
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);
 
346
                        new_block = buf_page_get(TRX_SYS_SPACE, 0, page_no,
 
347
                                                 RW_X_LATCH, &mtr);
365
348
                        buf_block_dbg_add_level(new_block,
366
349
                                                SYNC_NO_ORDER_CHECK);
367
350
 
443
426
 
444
427
        /* We do the file i/o past the buffer pool */
445
428
 
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));
 
429
        unaligned_read_buf = ut_malloc(2 * UNIV_PAGE_SIZE);
 
430
        read_buf = ut_align(unaligned_read_buf, UNIV_PAGE_SIZE);
448
431
 
449
432
        /* Read the trx sys header to check if we are using the doublewrite
450
433
        buffer */
600
583
                                                " recover the database"
601
584
                                                " with the my.cnf\n"
602
585
                                                "InnoDB: option:\n"
603
 
                                                "InnoDB:"
604
 
                                                " innodb_force_recovery=6\n");
 
586
                                                "InnoDB: set-variable="
 
587
                                                "innodb_force_recovery=6\n");
605
588
                                        exit(1);
606
589
                                }
607
590
 
672
655
 
673
656
        sys_header = trx_sysf_get(&mtr);
674
657
 
675
 
        mlog_write_ull(sys_header + TRX_SYS_TRX_ID_STORE,
676
 
                       trx_sys->max_trx_id, &mtr);
 
658
        mlog_write_dulint(sys_header + TRX_SYS_TRX_ID_STORE,
 
659
                          trx_sys->max_trx_id, &mtr);
677
660
        mtr_commit(&mtr);
678
661
}
679
662
 
 
663
/*****************************************************************//**
 
664
Updates the offset information about the end of the MySQL binlog entry
 
665
which corresponds to the transaction just being committed. In a MySQL
 
666
replication slave updates the latest master binlog position up to which
 
667
replication has proceeded. */
680
668
UNIV_INTERN
681
669
void
682
 
trx_sys_flush_commit_id(uint64_t commit_id, ulint field, mtr_t* mtr)
 
670
trx_sys_update_mysql_binlog_offset(
 
671
/*===============================*/
 
672
        const char*     file_name,/*!< in: MySQL log file name */
 
673
        ib_int64_t      offset, /*!< in: position in that log file */
 
674
        ulint           field,  /*!< in: offset of the MySQL log info field in
 
675
                                the trx sys header */
 
676
        mtr_t*          mtr)    /*!< in: mtr */
683
677
{
684
 
        trx_sysf_t*     sys_header;
685
 
  
 
678
        trx_sysf_t*     sys_header;
 
679
 
 
680
        if (ut_strlen(file_name) >= TRX_SYS_MYSQL_LOG_NAME_LEN) {
 
681
 
 
682
                /* We cannot fit the name to the 512 bytes we have reserved */
 
683
 
 
684
                return;
 
685
        }
 
686
 
686
687
        sys_header = trx_sysf_get(mtr);
687
688
 
688
 
        mlog_write_ull(sys_header + field + TRX_SYS_DRIZZLE_MAX_COMMIT_ID, 
689
 
                       commit_id, mtr);
 
689
        if (mach_read_from_4(sys_header + field
 
690
                             + TRX_SYS_MYSQL_LOG_MAGIC_N_FLD)
 
691
            != TRX_SYS_MYSQL_LOG_MAGIC_N) {
 
692
 
 
693
                mlog_write_ulint(sys_header + field
 
694
                                 + TRX_SYS_MYSQL_LOG_MAGIC_N_FLD,
 
695
                                 TRX_SYS_MYSQL_LOG_MAGIC_N,
 
696
                                 MLOG_4BYTES, mtr);
 
697
        }
 
698
 
 
699
        if (0 != strcmp((char*) (sys_header + field + TRX_SYS_MYSQL_LOG_NAME),
 
700
                        file_name)) {
 
701
 
 
702
                mlog_write_string(sys_header + field
 
703
                                  + TRX_SYS_MYSQL_LOG_NAME,
 
704
                                  (byte*) file_name, 1 + ut_strlen(file_name),
 
705
                                  mtr);
 
706
        }
 
707
 
 
708
        if (mach_read_from_4(sys_header + field
 
709
                             + TRX_SYS_MYSQL_LOG_OFFSET_HIGH) > 0
 
710
            || (offset >> 32) > 0) {
 
711
 
 
712
                mlog_write_ulint(sys_header + field
 
713
                                 + TRX_SYS_MYSQL_LOG_OFFSET_HIGH,
 
714
                                 (ulint)(offset >> 32),
 
715
                                 MLOG_4BYTES, mtr);
 
716
        }
 
717
 
 
718
        mlog_write_ulint(sys_header + field
 
719
                         + TRX_SYS_MYSQL_LOG_OFFSET_LOW,
 
720
                         (ulint)(offset & 0xFFFFFFFFUL),
 
721
                         MLOG_4BYTES, mtr);
690
722
}
691
723
 
692
 
 
 
724
/*****************************************************************//**
 
725
Stores the MySQL binlog offset info in the trx system header if
 
726
the magic number shows it valid, and print the info to stderr */
693
727
UNIV_INTERN
694
728
void
695
 
trx_sys_read_commit_id(void)
 
729
trx_sys_print_mysql_binlog_offset(void)
696
730
/*===================================*/
697
731
{
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
 
 
 
732
        trx_sysf_t*     sys_header;
 
733
        mtr_t           mtr;
 
734
        ulint           trx_sys_mysql_bin_log_pos_high;
 
735
        ulint           trx_sys_mysql_bin_log_pos_low;
 
736
 
 
737
        mtr_start(&mtr);
 
738
 
 
739
        sys_header = trx_sysf_get(&mtr);
 
740
 
 
741
        if (mach_read_from_4(sys_header + TRX_SYS_MYSQL_LOG_INFO
 
742
                             + TRX_SYS_MYSQL_LOG_MAGIC_N_FLD)
 
743
            != TRX_SYS_MYSQL_LOG_MAGIC_N) {
 
744
 
 
745
                mtr_commit(&mtr);
 
746
 
 
747
                return;
 
748
        }
 
749
 
 
750
        trx_sys_mysql_bin_log_pos_high = mach_read_from_4(
 
751
                sys_header + TRX_SYS_MYSQL_LOG_INFO
 
752
                + TRX_SYS_MYSQL_LOG_OFFSET_HIGH);
 
753
        trx_sys_mysql_bin_log_pos_low = mach_read_from_4(
 
754
                sys_header + TRX_SYS_MYSQL_LOG_INFO
 
755
                + TRX_SYS_MYSQL_LOG_OFFSET_LOW);
 
756
 
 
757
        trx_sys_mysql_bin_log_pos
 
758
                = (((ib_int64_t)trx_sys_mysql_bin_log_pos_high) << 32)
 
759
                + (ib_int64_t)trx_sys_mysql_bin_log_pos_low;
 
760
 
 
761
        ut_memcpy(trx_sys_mysql_bin_log_name,
 
762
                  sys_header + TRX_SYS_MYSQL_LOG_INFO
 
763
                  + TRX_SYS_MYSQL_LOG_NAME, TRX_SYS_MYSQL_LOG_NAME_LEN);
 
764
 
 
765
        fprintf(stderr,
 
766
                "InnoDB: Last MySQL binlog file position %lu %lu,"
 
767
                " file name %s\n",
 
768
                trx_sys_mysql_bin_log_pos_high, trx_sys_mysql_bin_log_pos_low,
 
769
                trx_sys_mysql_bin_log_name);
 
770
 
 
771
        mtr_commit(&mtr);
 
772
}
 
773
 
 
774
/*****************************************************************//**
 
775
Prints to stderr the MySQL master log offset info in the trx system header if
 
776
the magic number shows it valid. */
 
777
UNIV_INTERN
 
778
void
 
779
trx_sys_print_mysql_master_log_pos(void)
 
780
/*====================================*/
 
781
{
 
782
        trx_sysf_t*     sys_header;
 
783
        mtr_t           mtr;
 
784
 
 
785
        mtr_start(&mtr);
 
786
 
 
787
        sys_header = trx_sysf_get(&mtr);
 
788
 
 
789
        if (mach_read_from_4(sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
 
790
                             + TRX_SYS_MYSQL_LOG_MAGIC_N_FLD)
 
791
            != TRX_SYS_MYSQL_LOG_MAGIC_N) {
 
792
 
 
793
                mtr_commit(&mtr);
 
794
 
 
795
                return;
 
796
        }
 
797
 
 
798
        fprintf(stderr,
 
799
                "InnoDB: In a MySQL replication slave the last"
 
800
                " master binlog file\n"
 
801
                "InnoDB: position %lu %lu, file name %s\n",
 
802
                (ulong) mach_read_from_4(sys_header
 
803
                                         + TRX_SYS_MYSQL_MASTER_LOG_INFO
 
804
                                         + TRX_SYS_MYSQL_LOG_OFFSET_HIGH),
 
805
                (ulong) mach_read_from_4(sys_header
 
806
                                         + TRX_SYS_MYSQL_MASTER_LOG_INFO
 
807
                                         + TRX_SYS_MYSQL_LOG_OFFSET_LOW),
 
808
                sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
 
809
                + TRX_SYS_MYSQL_LOG_NAME);
 
810
        /* Copy the master log position info to global variables we can
 
811
        use in ha_innobase.cc to initialize glob_mi to right values */
 
812
 
 
813
        ut_memcpy(trx_sys_mysql_master_log_name,
 
814
                  sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
 
815
                  + TRX_SYS_MYSQL_LOG_NAME,
 
816
                  TRX_SYS_MYSQL_LOG_NAME_LEN);
 
817
 
 
818
        trx_sys_mysql_master_log_pos
 
819
                = (((ib_int64_t) mach_read_from_4(
 
820
                            sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
 
821
                            + TRX_SYS_MYSQL_LOG_OFFSET_HIGH)) << 32)
 
822
                + ((ib_int64_t) mach_read_from_4(
 
823
                           sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
 
824
                           + TRX_SYS_MYSQL_LOG_OFFSET_LOW));
708
825
        mtr_commit(&mtr);
709
826
}
710
827
 
752
869
        buf_block_t*    block;
753
870
        page_t*         page;
754
871
        ulint           page_no;
755
 
        byte*           ptr;
756
 
        ulint           len;
 
872
        ulint           i;
757
873
 
758
874
        ut_ad(mtr);
759
875
 
786
902
        sys_header = trx_sysf_get(mtr);
787
903
 
788
904
        /* Start counting transaction ids from number 1 up */
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);
 
905
        mlog_write_dulint(sys_header + TRX_SYS_TRX_ID_STORE,
 
906
                          ut_dulint_create(0, 1), mtr);
 
907
 
 
908
        /* Reset the rollback segment slots */
 
909
        for (i = 0; i < TRX_SYS_N_RSEGS; i++) {
 
910
 
 
911
                trx_sysf_rseg_set_space(sys_header, i, ULINT_UNDEFINED, mtr);
 
912
                trx_sysf_rseg_set_page_no(sys_header, i, FIL_NULL, mtr);
 
913
        }
 
914
 
 
915
        /* The remaining area (up to the page trailer) is uninitialized.
 
916
        Silence Valgrind warnings about it. */
 
917
        UNIV_MEM_VALID(sys_header + (TRX_SYS_RSEGS
 
918
                                     + TRX_SYS_N_RSEGS * TRX_SYS_RSEG_SLOT_SIZE
 
919
                                     + TRX_SYS_RSEG_SPACE),
 
920
                       (UNIV_PAGE_SIZE - FIL_PAGE_DATA_END
 
921
                        - (TRX_SYS_RSEGS
 
922
                           + TRX_SYS_N_RSEGS * TRX_SYS_RSEG_SLOT_SIZE
 
923
                           + TRX_SYS_RSEG_SPACE))
 
924
                       + page - sys_header);
806
925
 
807
926
        /* Create the first rollback segment in the SYSTEM tablespace */
808
 
        slot_no = trx_sysf_rseg_find_free(mtr);
809
 
        page_no = trx_rseg_header_create(TRX_SYS_SPACE, 0, ULINT_MAX, slot_no,
 
927
        page_no = trx_rseg_header_create(TRX_SYS_SPACE, 0, ULINT_MAX, &slot_no,
810
928
                                         mtr);
811
929
        ut_a(slot_no == TRX_SYS_SYSTEM_RSEG_ID);
812
 
        ut_a(page_no == FSP_FIRST_RSEG_PAGE_NO);
 
930
        ut_a(page_no != FIL_NULL);
813
931
 
814
932
        mutex_exit(&kernel_mutex);
815
933
}
823
941
/*==========================*/
824
942
{
825
943
        trx_sysf_t*     sys_header;
826
 
        ib_uint64_t     rows_to_undo    = 0;
 
944
        ib_int64_t      rows_to_undo    = 0;
827
945
        const char*     unit            = "";
828
946
        trx_t*          trx;
829
947
        mtr_t           mtr;
834
952
 
835
953
        mutex_enter(&kernel_mutex);
836
954
 
837
 
        trx_sys = static_cast<trx_sys_t *>(mem_alloc(sizeof(trx_sys_t)));
 
955
        trx_sys = mem_alloc(sizeof(trx_sys_t));
838
956
 
839
957
        sys_header = trx_sysf_get(&mtr);
840
958
 
849
967
        to the disk-based header! Thus trx id values will not overlap when
850
968
        the database is repeatedly started! */
851
969
 
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);
 
970
        trx_sys->max_trx_id = ut_dulint_add(
 
971
                ut_dulint_align_up(mtr_read_dulint(
 
972
                                           sys_header
 
973
                                           + TRX_SYS_TRX_ID_STORE, &mtr),
 
974
                                   TRX_SYS_TRX_ID_WRITE_MARGIN),
 
975
                2 * TRX_SYS_TRX_ID_WRITE_MARGIN);
856
976
 
857
977
        UT_LIST_INIT(trx_sys->mysql_trx_list);
858
978
        trx_dummy_sess = sess_open();
863
983
 
864
984
                for (;;) {
865
985
 
866
 
                        if (trx->conc_state != TRX_PREPARED) {
867
 
                                rows_to_undo += trx->undo_no;
 
986
                        if ( trx->conc_state != TRX_PREPARED) {
 
987
                                rows_to_undo += ut_conv_dulint_to_longlong(
 
988
                                        trx->undo_no);
868
989
                        }
869
990
 
870
991
                        trx = UT_LIST_GET_NEXT(trx_list, trx);
887
1008
                        (ulong) rows_to_undo, unit);
888
1009
 
889
1010
                fprintf(stderr, "InnoDB: Trx id counter is " TRX_ID_FMT "\n",
890
 
                        trx_sys->max_trx_id);
 
1011
                        TRX_ID_PREP_PRINTF(trx_sys->max_trx_id));
891
1012
        }
892
1013
 
893
1014
        UT_LIST_INIT(trx_sys->view_list);
931
1052
        mtr_t           mtr;
932
1053
        byte*           ptr;
933
1054
        buf_block_t*    block;
934
 
        ib_uint64_t     tag_value;
 
1055
        ulint           tag_value_low;
935
1056
 
936
1057
        mtr_start(&mtr);
937
1058
 
942
1063
        file_format_max.name = trx_sys_file_format_id_to_name(format_id);
943
1064
 
944
1065
        ptr = buf_block_get_frame(block) + TRX_SYS_FILE_FORMAT_TAG;
945
 
        tag_value = format_id + TRX_SYS_FILE_FORMAT_TAG_MAGIC_N;
 
1066
        tag_value_low = format_id + TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_LOW;
946
1067
 
947
1068
        if (name) {
948
1069
                *name = file_format_max.name;
949
1070
        }
950
1071
 
951
 
        mlog_write_ull(ptr, tag_value, &mtr);
 
1072
        mlog_write_dulint(
 
1073
                ptr,
 
1074
                ut_dulint_create(TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_HIGH,
 
1075
                                 tag_value_low),
 
1076
                &mtr);
952
1077
 
953
1078
        mtr_commit(&mtr);
954
1079
 
966
1091
        mtr_t                   mtr;
967
1092
        const byte*             ptr;
968
1093
        const buf_block_t*      block;
969
 
        ib_id_t                 file_format_id;
 
1094
        ulint                   format_id;
 
1095
        dulint                  file_format_id;
970
1096
 
971
1097
        /* Since this is called during the startup phase it's safe to
972
1098
        read the value without a covering mutex. */
980
1106
 
981
1107
        mtr_commit(&mtr);
982
1108
 
983
 
        file_format_id -= TRX_SYS_FILE_FORMAT_TAG_MAGIC_N;
 
1109
        format_id = file_format_id.low - TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_LOW;
984
1110
 
985
 
        if (file_format_id >= FILE_FORMAT_NAME_N) {
 
1111
        if (file_format_id.high != TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_HIGH
 
1112
            || format_id >= FILE_FORMAT_NAME_N) {
986
1113
 
987
1114
                /* Either it has never been tagged, or garbage in it. */
988
1115
                return(ULINT_UNDEFINED);
989
1116
        }
990
1117
 
991
 
        return((ulint) file_format_id);
 
1118
        return(format_id);
992
1119
}
993
1120
 
994
1121
/*****************************************************************//**
1024
1151
        if (format_id == ULINT_UNDEFINED) {
1025
1152
                /* Format ID was not set. Set it to minimum possible
1026
1153
                value. */
1027
 
                format_id = DICT_TF_FORMAT_MIN;
 
1154
                format_id = DICT_TF_FORMAT_51;
1028
1155
        }
1029
1156
 
1030
1157
        ut_print_timestamp(stderr);
1104
1231
 
1105
1232
        /* If format_id is not set then set it to the minimum. */
1106
1233
        if (format_id == ULINT_UNDEFINED) {
1107
 
                trx_sys_file_format_max_set(DICT_TF_FORMAT_MIN, NULL);
 
1234
                trx_sys_file_format_max_set(DICT_TF_FORMAT_51, NULL);
1108
1235
        }
1109
1236
}
1110
1237
 
1155
1282
trx_sys_file_format_init(void)
1156
1283
/*==========================*/
1157
1284
{
1158
 
        mutex_create(file_format_max_mutex_key,
1159
 
                     &file_format_max.mutex, SYNC_FILE_FORMAT_TAG);
 
1285
        mutex_create(&file_format_max.mutex, SYNC_FILE_FORMAT_TAG);
1160
1286
 
1161
1287
        /* We don't need a mutex here, as this function should only
1162
1288
        be called once at start up. */
1163
 
        file_format_max.id = DICT_TF_FORMAT_MIN;
 
1289
        file_format_max.id = DICT_TF_FORMAT_51;
1164
1290
 
1165
1291
        file_format_max.name = trx_sys_file_format_id_to_name(
1166
1292
                file_format_max.id);
1175
1301
{
1176
1302
        /* Does nothing at the moment */
1177
1303
}
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
 
 
1212
1304
#else /* !UNIV_HOTBACKUP */
 
1305
/*****************************************************************//**
 
1306
Prints to stderr the MySQL binlog info in the system header if the
 
1307
magic number shows it valid. */
 
1308
UNIV_INTERN
 
1309
void
 
1310
trx_sys_print_mysql_binlog_offset_from_page(
 
1311
/*========================================*/
 
1312
        const byte*     page)   /*!< in: buffer containing the trx
 
1313
                                system header page, i.e., page number
 
1314
                                TRX_SYS_PAGE_NO in the tablespace */
 
1315
{
 
1316
        const trx_sysf_t*       sys_header;
 
1317
 
 
1318
        sys_header = page + TRX_SYS;
 
1319
 
 
1320
        if (mach_read_from_4(sys_header + TRX_SYS_MYSQL_LOG_INFO
 
1321
                             + TRX_SYS_MYSQL_LOG_MAGIC_N_FLD)
 
1322
            == TRX_SYS_MYSQL_LOG_MAGIC_N) {
 
1323
 
 
1324
                fprintf(stderr,
 
1325
                        "ibbackup: Last MySQL binlog file position %lu %lu,"
 
1326
                        " file name %s\n",
 
1327
                        (ulong) mach_read_from_4(
 
1328
                                sys_header + TRX_SYS_MYSQL_LOG_INFO
 
1329
                                + TRX_SYS_MYSQL_LOG_OFFSET_HIGH),
 
1330
                        (ulong) mach_read_from_4(
 
1331
                                sys_header + TRX_SYS_MYSQL_LOG_INFO
 
1332
                                + TRX_SYS_MYSQL_LOG_OFFSET_LOW),
 
1333
                        sys_header + TRX_SYS_MYSQL_LOG_INFO
 
1334
                        + TRX_SYS_MYSQL_LOG_NAME);
 
1335
        }
 
1336
}
 
1337
 
1213
1338
 
1214
1339
/* THESE ARE COPIED FROM NON-HOTBACKUP PART OF THE INNODB SOURCE TREE
1215
1340
   (This code duplicaton should be fixed at some point!)
1247
1372
        byte            buf[UNIV_PAGE_SIZE * 2];
1248
1373
        page_t*         page = ut_align(buf, UNIV_PAGE_SIZE);
1249
1374
        const byte*     ptr;
1250
 
        ib_id_t         file_format_id;
 
1375
        dulint          file_format_id;
1251
1376
 
1252
1377
        *format_id = ULINT_UNDEFINED;
1253
 
 
 
1378
        
1254
1379
        file = os_file_create_simple_no_error_handling(
1255
 
                innodb_file_data_key,
1256
1380
                pathname,
1257
1381
                OS_FILE_OPEN,
1258
1382
                OS_FILE_READ_ONLY,
1261
1385
        if (!success) {
1262
1386
                /* The following call prints an error message */
1263
1387
                os_file_get_last_error(TRUE);
1264
 
 
 
1388
        
1265
1389
                ut_print_timestamp(stderr);
1266
 
 
 
1390
        
1267
1391
                fprintf(stderr,
1268
1392
"  ibbackup: Error: trying to read system tablespace file format,\n"
1269
1393
"  ibbackup: but could not open the tablespace file %s!\n",
1280
1404
        if (!success) {
1281
1405
                /* The following call prints an error message */
1282
1406
                os_file_get_last_error(TRUE);
1283
 
 
 
1407
        
1284
1408
                ut_print_timestamp(stderr);
1285
 
 
 
1409
        
1286
1410
                fprintf(stderr,
1287
1411
"  ibbackup: Error: trying to read system table space file format,\n"
1288
1412
"  ibbackup: but failed to read the tablespace file %s!\n",
1296
1420
        /* get the file format from the page */
1297
1421
        ptr = page + TRX_SYS_FILE_FORMAT_TAG;
1298
1422
        file_format_id = mach_read_from_8(ptr);
1299
 
        file_format_id -= TRX_SYS_FILE_FORMAT_TAG_MAGIC_N;
1300
 
 
1301
 
        if (file_format_id >= FILE_FORMAT_NAME_N) {
 
1423
 
 
1424
        *format_id = file_format_id.low - TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_LOW;
 
1425
 
 
1426
        if (file_format_id.high != TRX_SYS_FILE_FORMAT_TAG_MAGIC_N_HIGH
 
1427
            || *format_id >= FILE_FORMAT_NAME_N) {
1302
1428
 
1303
1429
                /* Either it has never been tagged, or garbage in it. */
 
1430
                *format_id = ULINT_UNDEFINED;
1304
1431
                return(TRUE);
1305
1432
        }
1306
 
 
1307
 
        *format_id = (ulint) file_format_id;
1308
 
 
 
1433
        
1309
1434
        return(TRUE);
1310
1435
}
1311
1436
 
1330
1455
        ib_uint32_t     flags;
1331
1456
 
1332
1457
        *format_id = ULINT_UNDEFINED;
1333
 
 
 
1458
        
1334
1459
        file = os_file_create_simple_no_error_handling(
1335
 
                innodb_file_data_key,
1336
1460
                pathname,
1337
1461
                OS_FILE_OPEN,
1338
1462
                OS_FILE_READ_ONLY,
1409
1533
}
1410
1534
 
1411
1535
#endif /* !UNIV_HOTBACKUP */
1412
 
 
1413
 
#ifndef UNIV_HOTBACKUP
1414
 
/*********************************************************************
1415
 
Shutdown/Close the transaction system. */
1416
 
UNIV_INTERN
1417
 
void
1418
 
trx_sys_close(void)
1419
 
/*===============*/
1420
 
{
1421
 
        trx_rseg_t*     rseg;
1422
 
        read_view_t*    view;
1423
 
 
1424
 
        ut_ad(trx_sys != NULL);
1425
 
 
1426
 
        /* Check that all read views are closed except read view owned
1427
 
        by a purge. */
1428
 
 
1429
 
        if (UT_LIST_GET_LEN(trx_sys->view_list) > 1) {
1430
 
                fprintf(stderr,
1431
 
                        "InnoDB: Error: all read views were not closed"
1432
 
                        " before shutdown:\n"
1433
 
                        "InnoDB: %lu read views open \n",
1434
 
                        static_cast<ulint>(UT_LIST_GET_LEN(trx_sys->view_list)) - 1);
1435
 
        }
1436
 
 
1437
 
        sess_close(trx_dummy_sess);
1438
 
        trx_dummy_sess = NULL;
1439
 
 
1440
 
        trx_purge_sys_close();
1441
 
 
1442
 
        mutex_enter(&kernel_mutex);
1443
 
 
1444
 
        /* Free the double write data structures. */
1445
 
        ut_a(trx_doublewrite != NULL);
1446
 
        ut_free(trx_doublewrite->write_buf_unaligned);
1447
 
        trx_doublewrite->write_buf_unaligned = NULL;
1448
 
 
1449
 
        mem_free(trx_doublewrite->buf_block_arr);
1450
 
        trx_doublewrite->buf_block_arr = NULL;
1451
 
 
1452
 
        mutex_free(&trx_doublewrite->mutex);
1453
 
        mem_free(trx_doublewrite);
1454
 
        trx_doublewrite = NULL;
1455
 
 
1456
 
        /* There can't be any active transactions. */
1457
 
        rseg = UT_LIST_GET_FIRST(trx_sys->rseg_list);
1458
 
 
1459
 
        while (rseg != NULL) {
1460
 
                trx_rseg_t*     prev_rseg = rseg;
1461
 
 
1462
 
                rseg = UT_LIST_GET_NEXT(rseg_list, prev_rseg);
1463
 
                UT_LIST_REMOVE(rseg_list, trx_sys->rseg_list, prev_rseg);
1464
 
 
1465
 
                trx_rseg_mem_free(prev_rseg);
1466
 
        }
1467
 
 
1468
 
        view = UT_LIST_GET_FIRST(trx_sys->view_list);
1469
 
 
1470
 
        while (view != NULL) {
1471
 
                read_view_t*    prev_view = view;
1472
 
 
1473
 
                view = UT_LIST_GET_NEXT(view_list, prev_view);
1474
 
 
1475
 
                /* Views are allocated from the trx_sys->global_read_view_heap.
1476
 
                So, we simply remove the element here. */
1477
 
                UT_LIST_REMOVE(view_list, trx_sys->view_list, prev_view);
1478
 
        }
1479
 
 
1480
 
        ut_a(UT_LIST_GET_LEN(trx_sys->trx_list) == 0);
1481
 
        ut_a(UT_LIST_GET_LEN(trx_sys->rseg_list) == 0);
1482
 
        ut_a(UT_LIST_GET_LEN(trx_sys->view_list) == 0);
1483
 
        ut_a(UT_LIST_GET_LEN(trx_sys->mysql_trx_list) == 0);
1484
 
 
1485
 
        mem_free(trx_sys);
1486
 
 
1487
 
        trx_sys = NULL;
1488
 
        mutex_exit(&kernel_mutex);
1489
 
}
1490
 
#endif /* !UNIV_HOTBACKUP */