1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge bk-internal.mysql.com:/home/bk/mysql-5.0

Browse Source 
into mysql.com:/home/my/mysql-5.0
This commit is contained in:
unknown 2005-02-26 12:19:56 +02:00
commit 8167f5e5ed
5 changed files with 175 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
innobase/include/trx0trx.h
View File

@ -157,7 +157,6 @@ trx_commit_for_mysql(
/*=================*/ /*=================*/
/* out: 0 or error number */ /* out: 0 or error number */
trx_t* trx); /* in: trx handle */ trx_t* trx); /* in: trx handle */
/************************************************************************** /**************************************************************************
Does the transaction prepare for MySQL. */ Does the transaction prepare for MySQL. */
@ -166,7 +165,6 @@ trx_prepare_for_mysql(
/*=================*/ /*=================*/
/* out: 0 or error number */ /* out: 0 or error number */
trx_t* trx); /* in: trx handle */ trx_t* trx); /* in: trx handle */
/************************************************************************** /**************************************************************************
This function is used to find number of prepared transactions and This function is used to find number of prepared transactions and
their transaction objects for a recovery. */ their transaction objects for a recovery. */
@ -177,7 +175,6 @@ trx_recover_for_mysql(
/* out: number of prepared transactions */ /* out: number of prepared transactions */
XID* xid_list, /* in/out: prepared transactions */ XID* xid_list, /* in/out: prepared transactions */
ulint len); /* in: number of slots in xid_list */ ulint len); /* in: number of slots in xid_list */
/*********************************************************************** /***********************************************************************
This function is used to commit one X/Open XA distributed transaction This function is used to commit one X/Open XA distributed transaction
which is in the prepared state */ which is in the prepared state */
@ -185,8 +182,7 @@ trx_t *
trx_get_trx_by_xid( trx_get_trx_by_xid(
/*===============*/ /*===============*/
/* out: trx or NULL */ /* out: trx or NULL */
XID* xid); /* in: X/Open XA Transaction Idenfication */ XID* xid); /* in: X/Open XA transaction identification */
/************************************************************************** /**************************************************************************
If required, flushes the log to disk if we called trx_commit_for_mysql() If required, flushes the log to disk if we called trx_commit_for_mysql()
with trx->flush_log_later == TRUE. */ with trx->flush_log_later == TRUE. */

40
innobase/include/trx0undo.h
View File

@ -307,23 +307,6 @@ trx_undo_parse_discard_latest(
byte* end_ptr,/* in: buffer end */ byte* end_ptr,/* in: buffer end */
page_t* page, /* in: page or NULL */ page_t* page, /* in: page or NULL */
mtr_t* mtr); /* in: mtr or NULL */ mtr_t* mtr); /* in: mtr or NULL */
/************************************************************************
Write X/Open XA Transaction Identification (XID) to undo log header */
void
trx_undo_write_xid(
/*===============*/
trx_ulogf_t* log_hdr,/* in: undo log header */
XID* xid); /* in: X/Open XA Transaction Identification */
/************************************************************************
Read X/Open XA Transaction Identification (XID) from undo log header */
void
trx_undo_read_xid(
/*==============*/
trx_ulogf_t* log_hdr,/* in: undo log header */
XID* xid); /* out: X/Open XA Transaction Identification */
/* Types of an undo log segment */ /* Types of an undo log segment */
#define TRX_UNDO_INSERT 1 /* contains undo entries for inserts */ #define TRX_UNDO_INSERT 1 /* contains undo entries for inserts */
@ -419,7 +402,8 @@ struct trx_undo_struct{
#define TRX_UNDO_PAGE_HDR_SIZE (6 + FLST_NODE_SIZE) #define TRX_UNDO_PAGE_HDR_SIZE (6 + FLST_NODE_SIZE)
/* An update undo segment with just one page can be reused if it has /* An update undo segment with just one page can be reused if it has
< this number bytes used */ < this number bytes used; we must leave space at least for one new undo
log header on the page */
#define TRX_UNDO_PAGE_REUSE_LIMIT (3 * UNIV_PAGE_SIZE / 4) #define TRX_UNDO_PAGE_REUSE_LIMIT (3 * UNIV_PAGE_SIZE / 4)
@ -488,17 +472,25 @@ page of an update undo log segment. */
#define TRX_UNDO_HISTORY_NODE 34 /* If the log is put to the history #define TRX_UNDO_HISTORY_NODE 34 /* If the log is put to the history
list, the file list node is here */ list, the file list node is here */
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
#define TRX_UNDO_LOG_OLD_HDR_SIZE (34 + FLST_NODE_SIZE)
/* Note: the writing of the undo log old header is coded by a log record
MLOG_UNDO_HDR_CREATE or MLOG_UNDO_HDR_REUSE. The appending of an XID to the
header is logged separately. In this sense, the XID is not really a member
of the undo log header. TODO: do not append the XID to the log header if XA
is not needed by the user. The XID wastes about 150 bytes of space in every
undo log. In the history list we may have millions of undo logs, which means
quite a large overhead. */
/* X/Open XA Transaction Identification (XID) */ /* X/Open XA Transaction Identification (XID) */
#define TRX_UNDO_XA_FORMAT (34 + FLST_NODE_SIZE) #define TRX_UNDO_XA_FORMAT (TRX_UNDO_LOG_OLD_HDR_SIZE)
#define TRX_UNDO_XA_TRID_LEN (TRX_UNDO_XA_FORMAT + 4) #define TRX_UNDO_XA_TRID_LEN (TRX_UNDO_XA_FORMAT + 4)
#define TRX_UNDO_XA_BQUAL_LEN (TRX_UNDO_XA_TRID_LEN + 4) #define TRX_UNDO_XA_BQUAL_LEN (TRX_UNDO_XA_TRID_LEN + 4)
#define TRX_UNDO_XA_XID (TRX_UNDO_XA_BQUAL_LEN + 4) #define TRX_UNDO_XA_XID (TRX_UNDO_XA_BQUAL_LEN + 4)
#define TRX_UNDO_XA_LEN (TRX_UNDO_XA_XID + XIDDATASIZE) /*--------------------------------------------------------------*/
#define TRX_UNDO_LOG_XA_HDR_SIZE (TRX_UNDO_XA_XID + XIDDATASIZE)
/*-------------------------------------------------------------*/ /* Total size of the header with the XA XID */
#define TRX_UNDO_LOG_HDR_SIZE (TRX_UNDO_XA_LEN)
/*-------------------------------------------------------------*/
#ifndef UNIV_NONINL #ifndef UNIV_NONINL
#include "trx0undo.ic" #include "trx0undo.ic"

2
innobase/trx/trx0roll.c
View File

@ -950,7 +950,7 @@ try_again:
if (progress_pct != trx_roll_progress_printed_pct) { if (progress_pct != trx_roll_progress_printed_pct) {
if (trx_roll_progress_printed_pct == 0) { if (trx_roll_progress_printed_pct == 0) {
fprintf(stderr, fprintf(stderr,
"\nInnoDB: Progress in percents: %lu\n", (ulong) progress_pct); "\nInnoDB: Progress in percents: %lu", (ulong) progress_pct);
} else { } else {
fprintf(stderr, fprintf(stderr,
" %lu", (ulong) progress_pct); " %lu", (ulong) progress_pct);

81
innobase/trx/trx0trx.c
View File

@ -162,7 +162,7 @@ trx_create(
trx->read_view = NULL; trx->read_view = NULL;
/* Set X/Open XA transaction identification to NULL */ /* Set X/Open XA transaction identification to NULL */
memset(&trx->xid,0,sizeof(trx->xid)); memset(&trx->xid, 0, sizeof(trx->xid));
trx->xid.formatID = -1; trx->xid.formatID = -1;
return(trx); return(trx);
@ -436,16 +436,12 @@ trx_lists_init_at_db_start(void)
if (undo->state == TRX_UNDO_PREPARED) { if (undo->state == TRX_UNDO_PREPARED) {
fprintf(stderr, fprintf(stderr,
"InnoDB: Transaction %lu %lu was in the XA prepared state. We change it to\n" "InnoDB: Transaction %lu %lu was in the XA prepared state.\n",
"InnoDB: the 'active' state, so that InnoDB's true-and-tested crash\n" ut_dulint_get_high(trx->id),
"InnoDB: recovery will roll it back. If mysqld refuses to start after\n" ut_dulint_get_low(trx->id));
"InnoDB: this, you may be able to resolve the problem by moving the binlog\n"
"InnoDB: files to a safe place, and deleting all binlog files and the binlog\n"
"InnoDB: .index file from the datadir.\n", ut_dulint_get_high(trx->id),
ut_dulint_get_low(trx->id));
/* trx->conc_state = TRX_PREPARED; */ /* trx->conc_state = TRX_PREPARED; */
trx->conc_state = trx->conc_state =
TRX_ACTIVE; TRX_ACTIVE;
} else { } else {
trx->conc_state = trx->conc_state =
@ -504,13 +500,9 @@ trx_lists_init_at_db_start(void)
if (undo->state == TRX_UNDO_PREPARED) { if (undo->state == TRX_UNDO_PREPARED) {
fprintf(stderr, fprintf(stderr,
"InnoDB: Transaction %lu %lu was in the XA prepared state. We change it to\n" "InnoDB: Transaction %lu %lu was in the XA prepared state.\n",
"InnoDB: the 'active' state, so that InnoDB's true-and-tested crash\n" ut_dulint_get_high(trx->id),
"InnoDB: recovery will roll it back. If mysqld refuses to start after\n" ut_dulint_get_low(trx->id));
"InnoDB: this, you may be able to resolve the problem by moving the binlog\n"
"InnoDB: files to a safe place, and deleting all binlog files and the binlog\n"
"InnoDB: .index file from the datadir.\n", ut_dulint_get_high(trx->id),
ut_dulint_get_low(trx->id));
/* trx->conc_state = TRX_PREPARED; */ /* trx->conc_state = TRX_PREPARED; */
trx->conc_state = trx->conc_state =
@ -786,8 +778,8 @@ trx_commit_off_kernel(
mutex_enter(&kernel_mutex); mutex_enter(&kernel_mutex);
} }
ut_ad(trx->conc_state == TRX_ACTIVE || trx->conc_state == TRX_PREPARED); ut_ad(trx->conc_state == TRX_ACTIVE
|| trx->conc_state == TRX_PREPARED);
#ifdef UNIV_SYNC_DEBUG #ifdef UNIV_SYNC_DEBUG
ut_ad(mutex_own(&kernel_mutex)); ut_ad(mutex_own(&kernel_mutex));
#endif /* UNIV_SYNC_DEBUG */ #endif /* UNIV_SYNC_DEBUG */
@ -1744,10 +1736,10 @@ trx_prepare_off_kernel(
trx_t* trx) /* in: transaction */ trx_t* trx) /* in: transaction */
{ {
page_t* update_hdr_page; page_t* update_hdr_page;
dulint lsn;
trx_rseg_t* rseg; trx_rseg_t* rseg;
trx_undo_t* undo; trx_undo_t* undo;
ibool must_flush_log = FALSE; ibool must_flush_log = FALSE;
dulint lsn;
mtr_t mtr; mtr_t mtr;
#ifdef UNIV_SYNC_DEBUG #ifdef UNIV_SYNC_DEBUG
@ -1765,35 +1757,36 @@ trx_prepare_off_kernel(
must_flush_log = TRUE; must_flush_log = TRUE;
/* Change the undo log segment states from TRX_UNDO_ACTIVE /* Change the undo log segment states from TRX_UNDO_ACTIVE
to some other state: these modifications to the file data to TRX_UNDO_PREPARED: these modifications to the file data
structure define the transaction as prepared in the file structure define the transaction as prepared in the
based world, at the serialization point of the log sequence file-based world, at the serialization point of lsn. */
number lsn obtained below. */
mutex_enter(&(rseg->mutex)); mutex_enter(&(rseg->mutex));
if (trx->insert_undo != NULL) { if (trx->insert_undo != NULL) {
trx_undo_set_state_at_prepare(trx, trx->insert_undo, trx_undo_set_state_at_prepare(trx, trx->insert_undo,
&mtr); &mtr);
} }
undo = trx->update_undo; undo = trx->update_undo;
if (undo) { if (undo) {
/* It is not necessary to obtain trx->undo_mutex here /* It is not necessary to obtain trx->undo_mutex here
because only a single OS thread is allowed to do the because only a single OS thread is allowed to do the
transaction prepare for this transaction. */ transaction prepare for this transaction. */
update_hdr_page = trx_undo_set_state_at_prepare(trx, undo, &mtr); update_hdr_page = trx_undo_set_state_at_prepare(trx,
undo, &mtr);
} }
mutex_exit(&(rseg->mutex)); mutex_exit(&(rseg->mutex));
/*--------------*/ /*--------------*/
mtr_commit(&mtr); mtr_commit(&mtr); /* This mtr commit makes the
transaction prepared in the file-based
world */
/*--------------*/ /*--------------*/
lsn = mtr.end_lsn; lsn = mtr.end_lsn;
mutex_enter(&kernel_mutex); mutex_enter(&kernel_mutex);
} }
@ -1806,13 +1799,6 @@ trx_prepare_off_kernel(
trx->conc_state = TRX_PREPARED; trx->conc_state = TRX_PREPARED;
/*--------------------------------------*/ /*--------------------------------------*/
if (trx->read_view) {
read_view_close(trx->read_view);
mem_heap_empty(trx->read_view_heap);
trx->read_view = NULL;
}
if (must_flush_log) { if (must_flush_log) {
mutex_exit(&kernel_mutex); mutex_exit(&kernel_mutex);
@ -1834,7 +1820,7 @@ Does the transaction prepare for MySQL. */
ulint ulint
trx_prepare_for_mysql( trx_prepare_for_mysql(
/*=================*/ /*====-=============*/
/* out: 0 or error number */ /* out: 0 or error number */
trx_t* trx) /* in: trx handle */ trx_t* trx) /* in: trx handle */
{ {
@ -1881,9 +1867,8 @@ trx_recover_for_mysql(
fprintf(stderr, fprintf(stderr,
" InnoDB: Starting recovery for XA transactions...\n"); " InnoDB: Starting recovery for XA transactions...\n");
/* We should set those transactions which are in the prepared state
/* We should set those transactions which are in to the xid_list */
the prepared state to the xid_list */
mutex_enter(&kernel_mutex); mutex_enter(&kernel_mutex);
@ -1891,14 +1876,7 @@ trx_recover_for_mysql(
while (trx) { while (trx) {
if (trx->conc_state == TRX_PREPARED) { if (trx->conc_state == TRX_PREPARED) {
xid_list[count].formatID = trx->xid.formatID; xid_list[count] = trx->xid;
xid_list[count].gtrid_length = trx->xid.gtrid_length;
xid_list[count].bqual_length = trx->xid.bqual_length;
memcpy(xid_list[count].data,
trx->xid.data,
trx->xid.gtrid_length +
trx->xid.bqual_length);
ut_print_timestamp(stderr); ut_print_timestamp(stderr);
fprintf(stderr, fprintf(stderr,
@ -1935,15 +1913,16 @@ trx_recover_for_mysql(
This function is used to find one X/Open XA distributed transaction This function is used to find one X/Open XA distributed transaction
which is in the prepared state */ which is in the prepared state */
trx_t * trx_t*
trx_get_trx_by_xid( trx_get_trx_by_xid(
/*===============*/ /*===============*/
/* out: trx or NULL */ /* out: trx or NULL */
XID* xid) /* in: X/Open XA Transaction Idenfication */ XID* xid) /* in: X/Open XA transaction identification */
{ {
trx_t* trx; trx_t* trx;
if (xid == NULL) { if (xid == NULL) {
return (NULL); return (NULL);
} }
@ -1972,6 +1951,7 @@ trx_get_trx_by_xid(
if (trx) { if (trx) {
if (trx->conc_state != TRX_PREPARED) { if (trx->conc_state != TRX_PREPARED) {
return(NULL); return(NULL);
} }
@ -1980,4 +1960,3 @@ trx_get_trx_by_xid(
return(NULL); return(NULL);
} }
} }

229
innobase/trx/trx0undo.c
View File

@ -100,9 +100,11 @@ trx_undo_mem_create(
is created */ is created */
XID* xid, /* in: X/Open XA transaction identification*/ XID* xid, /* in: X/Open XA transaction identification*/
ulint page_no,/* in: undo log header page number */ ulint page_no,/* in: undo log header page number */
ulint offset); /* in: undo log header byte offset on page */ ulint offset);/* in: undo log header byte offset on page */
/******************************************************************* /*******************************************************************
Initializes a cached insert undo log header page for new use. */ Initializes a cached insert undo log header page for new use. NOTE that this
function has its own log record type MLOG_UNDO_HDR_REUSE. You must NOT change
the operation of this function! */
static static
ulint ulint
trx_undo_insert_header_reuse( trx_undo_insert_header_reuse(
@ -111,7 +113,6 @@ trx_undo_insert_header_reuse(
page_t* undo_page, /* in: insert undo log segment header page, page_t* undo_page, /* in: insert undo log segment header page,
x-latched */ x-latched */
dulint trx_id, /* in: transaction id */ dulint trx_id, /* in: transaction id */
XID* xid, /* in: X/Open XA transaction identification*/
mtr_t* mtr); /* in: mtr */ mtr_t* mtr); /* in: mtr */
/************************************************************************** /**************************************************************************
If an update undo log can be discarded immediately, this function frees the If an update undo log can be discarded immediately, this function frees the
@ -184,7 +185,8 @@ trx_undo_get_prev_rec(
/* We have to go to the previous undo log page to look for the /* We have to go to the previous undo log page to look for the
previous record */ previous record */
return(trx_undo_get_prev_rec_from_prev_page(rec, page_no, offset, mtr)); return(trx_undo_get_prev_rec_from_prev_page(rec, page_no, offset,
mtr));
} }
/*************************************************************************** /***************************************************************************
@ -476,18 +478,19 @@ trx_undo_header_create_log(
} }
/******************************************************************* /*******************************************************************
Creates a new undo log header in file. */ Creates a new undo log header in file. NOTE that this function has its own
log record type MLOG_UNDO_HDR_CREATE. You must NOT change the operation of
this function! */
static static
ulint ulint
trx_undo_header_create( trx_undo_header_create(
/*===================*/ /*===================*/
/* out: header byte offset on page */ /* out: header byte offset on page */
page_t* undo_page, /* in: undo log segment header page, page_t* undo_page, /* in: undo log segment header page,
x-latched; it is assumed that there is x-latched; it is assumed that there are
TRX_UNDO_LOG_HDR_SIZE bytes free space TRX_UNDO_LOG_XA_HDR_SIZE bytes free space
on it */ on it */
dulint trx_id, /* in: transaction id */ dulint trx_id, /* in: transaction id */
XID* xid, /* in: X/Open XA XID */
mtr_t* mtr) /* in: mtr */ mtr_t* mtr) /* in: mtr */
{ {
trx_upagef_t* page_hdr; trx_upagef_t* page_hdr;
@ -507,9 +510,9 @@ trx_undo_header_create(
log_hdr = undo_page + free; log_hdr = undo_page + free;
new_free = free + TRX_UNDO_LOG_HDR_SIZE; new_free = free + TRX_UNDO_LOG_OLD_HDR_SIZE;
ut_ad(new_free <= UNIV_PAGE_SIZE); ut_a(free + TRX_UNDO_LOG_XA_HDR_SIZE < UNIV_PAGE_SIZE - 100);
mach_write_to_2(page_hdr + TRX_UNDO_PAGE_START, new_free); mach_write_to_2(page_hdr + TRX_UNDO_PAGE_START, new_free);
@ -534,30 +537,104 @@ trx_undo_header_create(
mach_write_to_8(log_hdr + TRX_UNDO_TRX_ID, trx_id); mach_write_to_8(log_hdr + TRX_UNDO_TRX_ID, trx_id);
mach_write_to_2(log_hdr + TRX_UNDO_LOG_START, new_free); mach_write_to_2(log_hdr + TRX_UNDO_LOG_START, new_free);
/* If X/Open XID exits in the log header we store a mach_write_to_1(log_hdr + TRX_UNDO_XID_EXISTS, FALSE);
flag of it in upper byte of dict operation flag. */
if (xid != NULL && xid->formatID != -1) {
mach_write_to_1(log_hdr + TRX_UNDO_XID_EXISTS, TRUE);
} else {
mach_write_to_1(log_hdr + TRX_UNDO_XID_EXISTS, FALSE);
}
mach_write_to_1(log_hdr + TRX_UNDO_DICT_TRANS, FALSE); mach_write_to_1(log_hdr + TRX_UNDO_DICT_TRANS, FALSE);
mach_write_to_2(log_hdr + TRX_UNDO_NEXT_LOG, 0); mach_write_to_2(log_hdr + TRX_UNDO_NEXT_LOG, 0);
mach_write_to_2(log_hdr + TRX_UNDO_PREV_LOG, prev_log); mach_write_to_2(log_hdr + TRX_UNDO_PREV_LOG, prev_log);
/* Write X/Open XA transaction identification if exists */ /* Write the log record about the header creation */
if (xid && xid->formatID != -1) {
trx_undo_write_xid(log_hdr, xid);
}
trx_undo_header_create_log(undo_page, trx_id, mtr); trx_undo_header_create_log(undo_page, trx_id, mtr);
return(free); return(free);
} }
/************************************************************************
Write X/Open XA Transaction Identification (XID) to undo log header */
static
void
trx_undo_write_xid(
/*===============*/
trx_ulogf_t* log_hdr,/* in: undo log header */
XID* xid, /* in: X/Open XA Transaction Identification */
mtr_t* mtr) /* in: mtr */
{
mlog_write_ulint(log_hdr + TRX_UNDO_XA_FORMAT, xid->formatID,
MLOG_4BYTES, mtr);
mlog_write_ulint(log_hdr + TRX_UNDO_XA_TRID_LEN, xid->gtrid_length,
MLOG_4BYTES, mtr);
mlog_write_ulint(log_hdr + TRX_UNDO_XA_BQUAL_LEN, xid->bqual_length,
MLOG_4BYTES, mtr);
mlog_write_string(log_hdr + TRX_UNDO_XA_XID, xid->data,
XIDDATASIZE, mtr);
}
/************************************************************************
Read X/Open XA Transaction Identification (XID) from undo log header */
static
void
trx_undo_read_xid(
/*==============*/
trx_ulogf_t* log_hdr,/* in: undo log header */
XID* xid) /* out: X/Open XA Transaction Identification */
{
ulint i;
xid->formatID = mach_read_from_4(log_hdr + TRX_UNDO_XA_FORMAT);
xid->gtrid_length = mach_read_from_4(log_hdr + TRX_UNDO_XA_TRID_LEN);
xid->bqual_length = mach_read_from_4(log_hdr + TRX_UNDO_XA_BQUAL_LEN);
for (i = 0; i < XIDDATASIZE; i++) {
xid->data[i] = (char)mach_read_from_1(log_hdr +
TRX_UNDO_XA_XID + i);
}
}
/*******************************************************************
Adds the XA XID after an undo log old-style header. */
static
void
trx_undo_header_add_xid(
/*====================*/
page_t* undo_page,/* in: undo log segment header page */
trx_ulogf_t* log_hdr,/* in: undo log header */
XID* xid, /* in: X/Open XA transaction identification */
mtr_t* mtr) /* in: mtr */
{
trx_upagef_t* page_hdr;
ulint free;
ulint new_free;
page_hdr = undo_page + TRX_UNDO_PAGE_HDR;
free = mach_read_from_2(page_hdr + TRX_UNDO_PAGE_FREE);
/* free is now the end offset of the old style undo log header */
ut_a(free == (ulint)(log_hdr - undo_page) + TRX_UNDO_LOG_OLD_HDR_SIZE);
new_free = free + (TRX_UNDO_LOG_XA_HDR_SIZE
- TRX_UNDO_LOG_OLD_HDR_SIZE);
trx_undo_write_xid(log_hdr, xid, mtr);
/* Now that we added the XID after the header, update the free offset
fields on the undo log page and in the undo log header */
mlog_write_ulint(page_hdr + TRX_UNDO_PAGE_START, new_free,
MLOG_2BYTES, mtr);
mlog_write_ulint(page_hdr + TRX_UNDO_PAGE_FREE, new_free,
MLOG_2BYTES, mtr);
mlog_write_ulint(log_hdr + TRX_UNDO_LOG_START, new_free,
MLOG_2BYTES, mtr);
}
/************************************************************************** /**************************************************************************
Writes the mtr log entry of an undo log header reuse. */ Writes the mtr log entry of an undo log header reuse. */
UNIV_INLINE UNIV_INLINE
@ -587,11 +664,6 @@ trx_undo_parse_page_header(
mtr_t* mtr) /* in: mtr or NULL */ mtr_t* mtr) /* in: mtr or NULL */
{ {
dulint trx_id; dulint trx_id;
XID xid;
/* Set X/Open XA transaction identification to NULL */
memset(&xid, 0, sizeof(xid));
xid.formatID = -1;
ptr = mach_dulint_parse_compressed(ptr, end_ptr, &trx_id); ptr = mach_dulint_parse_compressed(ptr, end_ptr, &trx_id);
@ -602,10 +674,10 @@ trx_undo_parse_page_header(
if (page) { if (page) {
if (type == MLOG_UNDO_HDR_CREATE) { if (type == MLOG_UNDO_HDR_CREATE) {
trx_undo_header_create(page, trx_id, &xid, mtr); trx_undo_header_create(page, trx_id, mtr);
} else { } else {
ut_ad(type == MLOG_UNDO_HDR_REUSE); ut_ad(type == MLOG_UNDO_HDR_REUSE);
trx_undo_insert_header_reuse(page, trx_id, &xid, mtr); trx_undo_insert_header_reuse(page, trx_id, mtr);
} }
} }
@ -613,7 +685,9 @@ trx_undo_parse_page_header(
} }
/******************************************************************* /*******************************************************************
Initializes a cached insert undo log header page for new use. */ Initializes a cached insert undo log header page for new use. NOTE that this
function has its own log record type MLOG_UNDO_HDR_REUSE. You must NOT change
the operation of this function! */
static static
ulint ulint
trx_undo_insert_header_reuse( trx_undo_insert_header_reuse(
@ -622,7 +696,6 @@ trx_undo_insert_header_reuse(
page_t* undo_page, /* in: insert undo log segment header page, page_t* undo_page, /* in: insert undo log segment header page,
x-latched */ x-latched */
dulint trx_id, /* in: transaction id */ dulint trx_id, /* in: transaction id */
XID* xid, /* in: X/Open XA transaction identification */
mtr_t* mtr) /* in: mtr */ mtr_t* mtr) /* in: mtr */
{ {
trx_upagef_t* page_hdr; trx_upagef_t* page_hdr;
@ -638,9 +711,11 @@ trx_undo_insert_header_reuse(
free = TRX_UNDO_SEG_HDR + TRX_UNDO_SEG_HDR_SIZE; free = TRX_UNDO_SEG_HDR + TRX_UNDO_SEG_HDR_SIZE;
ut_a(free + TRX_UNDO_LOG_XA_HDR_SIZE < UNIV_PAGE_SIZE - 100);
log_hdr = undo_page + free; log_hdr = undo_page + free;
new_free = free + TRX_UNDO_LOG_HDR_SIZE; new_free = free + TRX_UNDO_LOG_OLD_HDR_SIZE;
/* Insert undo data is not needed after commit: we may free all /* Insert undo data is not needed after commit: we may free all
the space on the page */ the space on the page */
@ -660,18 +735,10 @@ trx_undo_insert_header_reuse(
mach_write_to_8(log_hdr + TRX_UNDO_TRX_ID, trx_id); mach_write_to_8(log_hdr + TRX_UNDO_TRX_ID, trx_id);
mach_write_to_2(log_hdr + TRX_UNDO_LOG_START, new_free); mach_write_to_2(log_hdr + TRX_UNDO_LOG_START, new_free);
/* If X/Open XID exits in the log header we store it mach_write_to_1(log_hdr + TRX_UNDO_XID_EXISTS, FALSE);
to log header. */
if (xid && xid->formatID != -1) {
mach_write_to_1(log_hdr + TRX_UNDO_XID_EXISTS, TRUE);
trx_undo_write_xid(log_hdr, xid);
} else {
mach_write_to_1(log_hdr + TRX_UNDO_XID_EXISTS, FALSE);
}
mach_write_to_1(log_hdr + TRX_UNDO_DICT_TRANS, FALSE); mach_write_to_1(log_hdr + TRX_UNDO_DICT_TRANS, FALSE);
/* Write the log record MLOG_UNDO_HDR_REUSE */
trx_undo_insert_header_reuse_log(undo_page, trx_id, mtr); trx_undo_insert_header_reuse_log(undo_page, trx_id, mtr);
return(free); return(free);
@ -751,52 +818,6 @@ trx_undo_discard_latest_update_undo(
trx_undo_discard_latest_log(undo_page, mtr); trx_undo_discard_latest_log(undo_page, mtr);
} }
/************************************************************************
Write X/Open XA Transaction Identification (XID) to undo log header */
void
trx_undo_write_xid(
/*===============*/
trx_ulogf_t* log_hdr,/* in: undo log header */
XID* xid) /* in: X/Open XA Transaction Identification */
{
ulint i;
mach_write_to_4(log_hdr + TRX_UNDO_XA_FORMAT, xid->formatID);
mach_write_to_4(log_hdr + TRX_UNDO_XA_TRID_LEN, xid->gtrid_length);
mach_write_to_4(log_hdr + TRX_UNDO_XA_BQUAL_LEN, xid->bqual_length);
for(i=0; i < XIDDATASIZE; i++) {
mach_write_to_1(log_hdr + TRX_UNDO_XA_XID + i,
(ulint)(xid->data[i]));
}
}
/************************************************************************
Read X/Open XA Transaction Identification (XID) from undo log header */
void
trx_undo_read_xid(
/*==============*/
trx_ulogf_t* log_hdr,/* in: undo log header */
XID* xid) /* out: X/Open XA Transaction Identification */
{
ulint i;
xid->formatID = mach_read_from_4(log_hdr + TRX_UNDO_XA_FORMAT);
xid->gtrid_length = mach_read_from_4(log_hdr + TRX_UNDO_XA_TRID_LEN);
xid->bqual_length = mach_read_from_4(log_hdr + TRX_UNDO_XA_BQUAL_LEN);
for(i=0; i < XIDDATASIZE; i++) {
xid->data[i] = (char)mach_read_from_1(log_hdr +
TRX_UNDO_XA_XID +i);
}
}
/************************************************************************ /************************************************************************
Tries to add a page to the undo log segment where the undo log is placed. */ Tries to add a page to the undo log segment where the undo log is placed. */
@ -1228,7 +1249,7 @@ trx_undo_mem_create_at_db_start(
xid_exists = mtr_read_ulint(undo_header + TRX_UNDO_XID_EXISTS, xid_exists = mtr_read_ulint(undo_header + TRX_UNDO_XID_EXISTS,
MLOG_1BYTE, mtr); MLOG_1BYTE, mtr);
/* Read X/Open XA transaction identification if exists or /* Read X/Open XA transaction identification if it exists, or
set it to NULL. */ set it to NULL. */
memset(&xid, 0, sizeof(xid)); memset(&xid, 0, sizeof(xid));
@ -1242,7 +1263,6 @@ trx_undo_mem_create_at_db_start(
undo = trx_undo_mem_create(rseg, id, type, trx_id, &xid, undo = trx_undo_mem_create(rseg, id, type, trx_id, &xid,
page_no, offset); page_no, offset);
mutex_exit(&(rseg->mutex)); mutex_exit(&(rseg->mutex));
undo->dict_operation = mtr_read_ulint( undo->dict_operation = mtr_read_ulint(
@ -1510,11 +1530,12 @@ trx_undo_create(
page_no = buf_frame_get_page_no(undo_page); page_no = buf_frame_get_page_no(undo_page);
offset = trx_undo_header_create(undo_page, trx_id, xid, mtr); offset = trx_undo_header_create(undo_page, trx_id, mtr);
undo = trx_undo_mem_create(rseg, id, type, trx_id, xid , trx_undo_header_add_xid(undo_page, undo_page + offset, xid, mtr);
undo = trx_undo_mem_create(rseg, id, type, trx_id, xid,
page_no, offset); page_no, offset);
return(undo); return(undo);
} }
@ -1533,7 +1554,7 @@ trx_undo_reuse_cached(
TRX_UNDO_UPDATE */ TRX_UNDO_UPDATE */
dulint trx_id, /* in: id of the trx for which the undo log dulint trx_id, /* in: id of the trx for which the undo log
is used */ is used */
XID* xid, /* in: X/Open XA transaction identification*/ XID* xid, /* in: X/Open XA transaction identification */
mtr_t* mtr) /* in: mtr */ mtr_t* mtr) /* in: mtr */
{ {
trx_undo_t* undo; trx_undo_t* undo;
@ -1577,14 +1598,17 @@ trx_undo_reuse_cached(
undo_page = trx_undo_page_get(undo->space, undo->hdr_page_no, mtr); undo_page = trx_undo_page_get(undo->space, undo->hdr_page_no, mtr);
if (type == TRX_UNDO_INSERT) { if (type == TRX_UNDO_INSERT) {
offset = trx_undo_insert_header_reuse(undo_page, trx_id, offset = trx_undo_insert_header_reuse(undo_page, trx_id, mtr);
xid, mtr); trx_undo_header_add_xid(undo_page, undo_page + offset, xid,
mtr);
} else { } else {
ut_a(mach_read_from_2(undo_page + TRX_UNDO_PAGE_HDR ut_a(mach_read_from_2(undo_page + TRX_UNDO_PAGE_HDR
+ TRX_UNDO_PAGE_TYPE) + TRX_UNDO_PAGE_TYPE)
== TRX_UNDO_UPDATE); == TRX_UNDO_UPDATE);
offset = trx_undo_header_create(undo_page, trx_id, xid, mtr); offset = trx_undo_header_create(undo_page, trx_id, mtr);
trx_undo_header_add_xid(undo_page, undo_page + offset, xid,
mtr);
} }
trx_undo_mem_init_for_reuse(undo, trx_id, xid, offset); trx_undo_mem_init_for_reuse(undo, trx_id, xid, offset);
@ -1782,7 +1806,8 @@ trx_undo_set_state_at_prepare(
mlog_write_ulint(undo_header + TRX_UNDO_XID_EXISTS, mlog_write_ulint(undo_header + TRX_UNDO_XID_EXISTS,
TRUE, MLOG_1BYTE, mtr); TRUE, MLOG_1BYTE, mtr);
trx_undo_write_xid(undo_header, &undo->xid); trx_undo_write_xid(undo_header, &undo->xid, mtr);
return(undo_page); return(undo_page);
} }