← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

Renamed strings to mystrings, for include/lib naming consistency.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/trx/trx0purge.c
27
27
#include "os0thread.h"
28
28
 
29
29
/* The global data structure coordinating a purge */
30
 
UNIV_INTERN trx_purge_t*        purge_sys = NULL;
 
30
trx_purge_t*    purge_sys = NULL;
31
31
 
32
32
/* A dummy undo record used as a return value when we have a whole undo log
33
33
which needs no purge */
34
 
UNIV_INTERN trx_undo_rec_t      trx_purge_dummy_rec;
 
34
trx_undo_rec_t  trx_purge_dummy_rec;
35
35
 
36
36
/*********************************************************************
37
37
Checks if trx_id is >= purge_view: then it is guaranteed that its update
38
38
undo log still exists in the system. */
39
 
UNIV_INTERN
 
39
 
40
40
ibool
41
41
trx_purge_update_undo_must_exist(
42
42
/*=============================*/
192
192
/************************************************************************
193
193
Creates the global purge system control structure and inits the history
194
194
mutex. */
195
 
UNIV_INTERN
 
195
 
196
196
void
197
197
trx_purge_sys_create(void)
198
198
/*======================*/
236
236
/************************************************************************
237
237
Adds the update undo log as the first log in the history list. Removes the
238
238
update undo log segment from the rseg slot if it is too big for reuse. */
239
 
UNIV_INTERN
 
239
 
240
240
void
241
241
trx_purge_add_update_undo_to_history(
242
242
/*=================================*/
261
261
 
262
262
        ut_ad(mutex_own(&(rseg->mutex)));
263
263
 
264
 
        rseg_header = trx_rsegf_get(rseg->space, rseg->zip_size,
265
 
                                    rseg->page_no, mtr);
 
264
        rseg_header = trx_rsegf_get(rseg->space, rseg->page_no, mtr);
266
265
 
267
266
        undo_header = undo_page + undo->hdr_offset;
268
267
        seg_header  = undo_page + TRX_UNDO_SEG_HDR;
344
343
        mtr_start(&mtr);
345
344
        mutex_enter(&(rseg->mutex));
346
345
 
347
 
        rseg_hdr = trx_rsegf_get(rseg->space, rseg->zip_size,
348
 
                                 rseg->page_no, &mtr);
 
346
        rseg_hdr = trx_rsegf_get(rseg->space, rseg->page_no, &mtr);
349
347
 
350
 
        undo_page = trx_undo_page_get(rseg->space, rseg->zip_size,
351
 
                                      hdr_addr.page, &mtr);
 
348
        undo_page = trx_undo_page_get(rseg->space, hdr_addr.page, &mtr);
352
349
        seg_hdr = undo_page + TRX_UNDO_SEG_HDR;
353
350
        log_hdr = undo_page + hdr_addr.boffset;
354
351
 
448
445
        mtr_start(&mtr);
449
446
        mutex_enter(&(rseg->mutex));
450
447
 
451
 
        rseg_hdr = trx_rsegf_get(rseg->space, rseg->zip_size,
452
 
                                 rseg->page_no, &mtr);
 
448
        rseg_hdr = trx_rsegf_get(rseg->space, rseg->page_no, &mtr);
453
449
 
454
450
        hdr_addr = trx_purge_get_log_from_hist(
455
451
                flst_get_last(rseg_hdr + TRX_RSEG_HISTORY, &mtr));
463
459
                return;
464
460
        }
465
461
 
466
 
        undo_page = trx_undo_page_get(rseg->space, rseg->zip_size,
467
 
                                      hdr_addr.page, &mtr);
 
462
        undo_page = trx_undo_page_get(rseg->space, hdr_addr.page, &mtr);
468
463
 
469
464
        log_hdr = undo_page + hdr_addr.boffset;
470
465
 
516
511
        mtr_start(&mtr);
517
512
        mutex_enter(&(rseg->mutex));
518
513
 
519
 
        rseg_hdr = trx_rsegf_get(rseg->space, rseg->zip_size,
520
 
                                 rseg->page_no, &mtr);
 
514
        rseg_hdr = trx_rsegf_get(rseg->space, rseg->page_no, &mtr);
521
515
 
522
516
        hdr_addr = prev_hdr_addr;
523
517
 
541
535
        trx_purge_arr_get_biggest(purge_sys->arr, &limit_trx_no,
542
536
                                  &limit_undo_no);
543
537
 
544
 
        if (ut_dulint_is_zero(limit_trx_no)) {
 
538
        if (ut_dulint_cmp(limit_trx_no, ut_dulint_zero) == 0) {
545
539
 
546
540
                limit_trx_no = purge_sys->purge_trx_no;
547
541
                limit_undo_no = purge_sys->purge_undo_no;
617
611
 
618
612
        mtr_start(&mtr);
619
613
 
620
 
        undo_page = trx_undo_page_get_s_latched(rseg->space, rseg->zip_size,
 
614
        undo_page = trx_undo_page_get_s_latched(rseg->space,
621
615
                                                rseg->last_page_no, &mtr);
622
616
        log_hdr = undo_page + rseg->last_offset;
623
617
        seg_hdr = undo_page + TRX_UNDO_SEG_HDR;
669
663
        /* Read the trx number and del marks from the previous log header */
670
664
        mtr_start(&mtr);
671
665
 
672
 
        log_hdr = trx_undo_page_get_s_latched(rseg->space, rseg->zip_size,
 
666
        log_hdr = trx_undo_page_get_s_latched(rseg->space,
673
667
                                              prev_log_addr.page, &mtr)
674
668
                + prev_log_addr.boffset;
675
669
 
704
698
        trx_rseg_t*     min_rseg;
705
699
        dulint          min_trx_no;
706
700
        ulint           space = 0;   /* remove warning (??? bug ???) */
707
 
        ulint           zip_size = 0;
708
701
        ulint           page_no = 0; /* remove warning (??? bug ???) */
709
702
        ulint           offset = 0;  /* remove warning (??? bug ???) */
710
703
        mtr_t           mtr;
730
723
                                min_rseg = rseg;
731
724
                                min_trx_no = rseg->last_trx_no;
732
725
                                space = rseg->space;
733
 
                                zip_size = rseg->zip_size;
734
726
                                ut_a(space == 0); /* We assume in purge of
735
727
                                                  externally stored fields
736
728
                                                  that space id == 0 */
756
748
 
757
749
                rec = &trx_purge_dummy_rec;
758
750
        } else {
759
 
                rec = trx_undo_get_first_rec(space, zip_size, page_no, offset,
 
751
                rec = trx_undo_get_first_rec(space, page_no, offset,
760
752
                                             RW_S_LATCH, &mtr);
761
753
                if (rec == NULL) {
762
754
                        /* Undo log empty */
781
773
        } else {
782
774
                purge_sys->purge_undo_no = trx_undo_rec_get_undo_no(rec);
783
775
 
784
 
                purge_sys->page_no = page_get_page_no(page_align(rec));
785
 
                purge_sys->offset = page_offset(rec);
 
776
                purge_sys->page_no = buf_frame_get_page_no(rec);
 
777
                purge_sys->offset = rec - buf_frame_align(rec);
786
778
        }
787
779
 
788
780
        mtr_commit(&mtr);
807
799
        ulint           offset;
808
800
        ulint           page_no;
809
801
        ulint           space;
810
 
        ulint           zip_size;
811
802
        ulint           type;
812
803
        ulint           cmpl_info;
813
804
        mtr_t           mtr;
816
807
        ut_ad(purge_sys->next_stored);
817
808
 
818
809
        space = purge_sys->rseg->space;
819
 
        zip_size = purge_sys->rseg->zip_size;
820
810
        page_no = purge_sys->page_no;
821
811
        offset = purge_sys->offset;
822
812
 
835
825
 
836
826
        mtr_start(&mtr);
837
827
 
838
 
        undo_page = trx_undo_page_get_s_latched(space, zip_size,
839
 
                                                page_no, &mtr);
 
828
        undo_page = trx_undo_page_get_s_latched(space, page_no, &mtr);
840
829
        rec = undo_page + offset;
841
830
 
842
831
        rec2 = rec;
887
876
 
888
877
                mtr_start(&mtr);
889
878
 
890
 
                undo_page = trx_undo_page_get_s_latched(space, zip_size,
891
 
                                                        page_no, &mtr);
 
879
                undo_page = trx_undo_page_get_s_latched(space, page_no, &mtr);
892
880
 
893
881
                rec = undo_page + offset;
894
882
        } else {
895
 
                page = page_align(rec2);
 
883
                page = buf_frame_align(rec2);
896
884
 
897
885
                purge_sys->purge_undo_no = trx_undo_rec_get_undo_no(rec2);
898
 
                purge_sys->page_no = page_get_page_no(page);
 
886
                purge_sys->page_no = buf_frame_get_page_no(page);
899
887
                purge_sys->offset = rec2 - page;
900
888
 
901
889
                if (undo_page != page) {
914
902
/************************************************************************
915
903
Fetches the next undo log record from the history list to purge. It must be
916
904
released with the corresponding release function. */
917
 
UNIV_INTERN
 
905
 
918
906
trx_undo_rec_t*
919
907
trx_purge_fetch_next_rec(
920
908
/*=====================*/
1009
997
 
1010
998
/***********************************************************************
1011
999
Releases a reserved purge undo record. */
1012
 
UNIV_INTERN
 
1000
 
1013
1001
void
1014
1002
trx_purge_rec_release(
1015
1003
/*==================*/
1028
1016
 
1029
1017
/***********************************************************************
1030
1018
This function runs a purge batch. */
1031
 
UNIV_INTERN
 
1019
 
1032
1020
ulint
1033
1021
trx_purge(void)
1034
1022
/*===========*/
1136
1124
 
1137
1125
/**********************************************************************
1138
1126
Prints information of the purge system to stderr. */
1139
 
UNIV_INTERN
 
1127
 
1140
1128
void
1141
1129
trx_purge_sys_print(void)
1142
1130
/*=====================*/
1144
1132
        fprintf(stderr, "InnoDB: Purge system view:\n");
1145
1133
        read_view_print(purge_sys->view);
1146
1134
 
1147
 
        fprintf(stderr, "InnoDB: Purge trx n:o " TRX_ID_FMT
1148
 
                ", undo n:o " TRX_ID_FMT "\n",
1149
 
                TRX_ID_PREP_PRINTF(purge_sys->purge_trx_no),
1150
 
                TRX_ID_PREP_PRINTF(purge_sys->purge_undo_no));
 
1135
        fprintf(stderr, "InnoDB: Purge trx n:o %lu %lu, undo n_o %lu %lu\n",
 
1136
                (ulong) ut_dulint_get_high(purge_sys->purge_trx_no),
 
1137
                (ulong) ut_dulint_get_low(purge_sys->purge_trx_no),
 
1138
                (ulong) ut_dulint_get_high(purge_sys->purge_undo_no),
 
1139
                (ulong) ut_dulint_get_low(purge_sys->purge_undo_no));
1151
1140
        fprintf(stderr,
1152
1141
                "InnoDB: Purge next stored %lu, page_no %lu, offset %lu,\n"
1153
1142
                "InnoDB: Purge hdr_page_no %lu, hdr_offset %lu\n",