Skip navigation links

Recommended Servers for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Downloads
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Documentation
• Librarian
• Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs

 

 

 

• Get Started with MySQL
• Development with MySQL
• PHP
• Perl
• Python
• Ruby
• Java/JDBC
• C#/.NET

The world's most popular open source database

mysql/src/5.1-dbg/storage/innobase/trx/trx0roll.c File Reference

#include "trx0roll.h"
#include "fsp0fsp.h"
#include "mach0data.h"
#include "trx0rseg.h"
#include "trx0trx.h"
#include "trx0undo.h"
#include "trx0rec.h"
#include "que0que.h"
#include "usr0sess.h"
#include "srv0que.h"
#include "srv0start.h"
#include "row0undo.h"
#include "row0mysql.h"
#include "lock0lock.h"
#include "pars0pars.h"

Include dependency graph for trx0roll.c:

Go to the source code of this file.

Defines
#define	TRX_ROLL_TRUNC_THRESHOLD   1
Functions
int	trx_general_rollback_for_mysql (trx_t *trx, ibool partial, trx_savept_t *savept)
int	trx_rollback_for_mysql (trx_t *trx)
int	trx_rollback_last_sql_stat_for_mysql (trx_t *trx)
void	trx_roll_savepoints_free (trx_t *trx, trx_named_savept_t *savep)
ulint	trx_rollback_to_savepoint_for_mysql (trx_t *trx, const char *savepoint_name, ib_longlong *mysql_binlog_cache_pos)
ulint	trx_savepoint_for_mysql (trx_t *trx, const char *savepoint_name, ib_longlong binlog_cache_pos)
ulint	trx_release_savepoint_for_mysql (trx_t *trx, const char *savepoint_name)
trx_savept_t	trx_savept_take (trx_t *trx)
os_thread_ret_t	trx_rollback_or_clean_all_without_sess (void *arg __attribute__((unused)))
trx_undo_arr_t *	trx_undo_arr_create (void)
void	trx_undo_arr_free (trx_undo_arr_t *arr)
static ibool	trx_undo_arr_store_info (trx_t *trx, dulint undo_no)
static void	trx_undo_arr_remove_info (trx_undo_arr_t *arr, dulint undo_no)
static dulint	trx_undo_arr_get_biggest (trx_undo_arr_t *arr)
void	trx_roll_try_truncate (trx_t *trx)
static trx_undo_rec_t *	trx_roll_pop_top_rec (trx_t *trx, trx_undo_t *undo, mtr_t *mtr)
trx_undo_rec_t *	trx_roll_pop_top_rec_of_trx (trx_t *trx, dulint limit, dulint *roll_ptr, mem_heap_t *heap)
ibool	trx_undo_rec_reserve (trx_t *trx, dulint undo_no)
void	trx_undo_rec_release (trx_t *trx, dulint undo_no)
void	trx_rollback (trx_t *trx, trx_sig_t *sig, que_thr_t **next_thr)
que_t *	trx_roll_graph_build (trx_t *trx)
static void	trx_finish_error_processing (trx_t *trx)
static void	trx_finish_partial_rollback_off_kernel (trx_t *trx, que_thr_t **next_thr)
void	trx_finish_rollback_off_kernel (que_t *graph, trx_t *trx, que_thr_t **next_thr)
roll_node_t *	roll_node_create (mem_heap_t *heap)
que_thr_t *	trx_rollback_step (que_thr_t *thr)
Variables
trx_t *	trx_roll_crash_recv_trx = NULL
ib_longlong	trx_roll_max_undo_no
ulint	trx_roll_progress_printed_pct

---

Define Documentation

#define TRX_ROLL_TRUNC_THRESHOLD   1

Definition at line 31 of file trx0roll.c.

Referenced by trx_roll_pop_top_rec_of_trx().

---

Function Documentation

roll_node_t* roll_node_create

(

mem_heap_t *

heap

)

Definition at line 1263 of file trx0roll.c.

References roll_node_struct::common, FALSE, mem_heap_alloc(), roll_node_struct::partial, QUE_NODE_ROLLBACK, ROLL_NODE_SEND, roll_node_struct::state, and que_common_struct::type.

Referenced by pars_rollback_statement(), trx_general_rollback_for_mysql(), and trx_rollback_or_clean_all_without_sess().

                                           : rollback node struct */
        mem_heap_t*     heap)   /* in: mem heap where created */
{
        roll_node_t*    node;

        node = mem_heap_alloc(heap, sizeof(roll_node_t));
        node->common.type = QUE_NODE_ROLLBACK;
        node->state = ROLL_NODE_SEND;

        node->partial = FALSE;

        return(node);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void trx_finish_error_processing

(

trx_t *

trx

)

[static]

Definition at line 1132 of file trx0roll.c.

References kernel_mutex, NULL, trx_struct::que_state, sig(), trx_struct::signals, TRX_QUE_RUNNING, TRX_SIG_ERROR_OCCURRED, trx_sig_remove(), ut_ad, UT_LIST_GET_FIRST, and UT_LIST_GET_NEXT.

Referenced by trx_finish_rollback_off_kernel().

                             : transaction */
{
        trx_sig_t*      sig;
        trx_sig_t*      next_sig;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&kernel_mutex));
#endif /* UNIV_SYNC_DEBUG */

        sig = UT_LIST_GET_FIRST(trx->signals);

        while (sig != NULL) {
                next_sig = UT_LIST_GET_NEXT(signals, sig);

                if (sig->type == TRX_SIG_ERROR_OCCURRED) {

                        trx_sig_remove(trx, sig);
                }

                sig = next_sig;
        }

        trx->que_state = TRX_QUE_RUNNING;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void trx_finish_partial_rollback_off_kernel	(	trx_t *	trx,
		que_thr_t **	next_thr
	)			[static]

Definition at line 1163 of file trx0roll.c.

References kernel_mutex, trx_struct::que_state, sig(), trx_struct::signals, TRX_QUE_RUNNING, trx_sig_remove(), trx_sig_reply(), ut_ad, and UT_LIST_GET_FIRST.

Referenced by trx_finish_rollback_off_kernel().

                                     : transaction */
        que_thr_t**     next_thr)/* in/out: next query thread to run;
                                if the value which is passed in is a pointer
                                to a NULL pointer, then the calling function
                                can start running a new query thread; if this
                                parameter is NULL, it is ignored */
{
        trx_sig_t*      sig;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&kernel_mutex));
#endif /* UNIV_SYNC_DEBUG */

        sig = UT_LIST_GET_FIRST(trx->signals);

        /* Remove the signal from the signal queue and send reply message
        to it */

        trx_sig_reply(sig, next_thr);
        trx_sig_remove(trx, sig);

        trx->que_state = TRX_QUE_RUNNING;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void trx_finish_rollback_off_kernel	(	que_t *	graph,
		trx_t *	trx,
		que_thr_t **	next_thr
	)

Definition at line 1193 of file trx0roll.c.

References trx_struct::id, kernel_mutex, trx_undo_arr_struct::n_used, NULL, que_graph_free(), trx_struct::que_state, sig(), trx_struct::signals, trx_commit_off_kernel(), trx_finish_error_processing(), trx_finish_partial_rollback_off_kernel(), TRX_QUE_RUNNING, TRX_SIG_ERROR_OCCURRED, trx_sig_remove(), trx_sig_reply(), TRX_SIG_ROLLBACK_TO_SAVEPT, TRX_SIG_TOTAL_ROLLBACK, trx_struct::undo_no_arr, ut_a, ut_ad, ut_dulint_get_low(), UT_LIST_GET_FIRST, and UT_LIST_GET_NEXT.

Referenced by que_thr_dec_refer_count().

                                     : undo graph which can now be freed */
        trx_t*          trx,    /* in: transaction */
        que_thr_t**     next_thr)/* in/out: next query thread to run;
                                if the value which is passed in is
                                a pointer to a NULL pointer, then the
                                calling function can start running
                                a new query thread; if this parameter is
                                NULL, it is ignored */
{
        trx_sig_t*      sig;
        trx_sig_t*      next_sig;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&kernel_mutex));
#endif /* UNIV_SYNC_DEBUG */

        ut_a(trx->undo_no_arr == NULL || trx->undo_no_arr->n_used == 0);

        /* Free the memory reserved by the undo graph */
        que_graph_free(graph);

        sig = UT_LIST_GET_FIRST(trx->signals);

        if (sig->type == TRX_SIG_ROLLBACK_TO_SAVEPT) {

                trx_finish_partial_rollback_off_kernel(trx, next_thr);

                return;

        } else if (sig->type == TRX_SIG_ERROR_OCCURRED) {

                trx_finish_error_processing(trx);

                return;
        }

#ifdef UNIV_DEBUG
        if (lock_print_waits) {
                fprintf(stderr, "Trx %lu rollback finished\n",
                                                (ulong) ut_dulint_get_low(trx->id));
        }
#endif /* UNIV_DEBUG */

        trx_commit_off_kernel(trx);

        /* Remove all TRX_SIG_TOTAL_ROLLBACK signals from the signal queue and
        send reply messages to them */

        trx->que_state = TRX_QUE_RUNNING;

        while (sig != NULL) {
                next_sig = UT_LIST_GET_NEXT(signals, sig);

                if (sig->type == TRX_SIG_TOTAL_ROLLBACK) {

                        trx_sig_reply(sig, next_thr);

                        trx_sig_remove(trx, sig);
                }

                sig = next_sig;
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int trx_general_rollback_for_mysql	(	trx_t *	trx,
		ibool	partial,
		trx_savept_t *	savept
	)

Definition at line 47 of file trx0roll.c.

References DB_FAIL, DB_SUCCESS, trx_struct::error_state, kernel_mutex, mem_heap_create, mem_heap_free, mutex_enter, mutex_exit(), os_thread_sleep(), pars_complete_graph_for_exec(), roll_node_struct::partial, que_fork_start_command(), que_node_get_parent(), que_run_threads(), trx_struct::que_state, roll_node_create(), roll_node_struct::savept, srv_active_wake_master_thread(), TRX_QUE_RUNNING, trx_start_if_not_started(), ut_a, and ut_error.

Referenced by row_create_index_for_mysql(), row_create_table_for_mysql(), row_discard_tablespace_for_mysql(), row_mysql_handle_errors(), row_rename_table_for_mysql(), row_table_add_foreign_constraints(), row_truncate_table_for_mysql(), trx_rollback_for_mysql(), trx_rollback_last_sql_stat_for_mysql(), and trx_rollback_to_savepoint_for_mysql().

                                      : error code or DB_SUCCESS */
        trx_t*          trx,    /* in: transaction handle */
        ibool           partial,/* in: TRUE if partial rollback requested */
        trx_savept_t*   savept) /* in: pointer to savepoint undo number, if
                                partial rollback requested */
{
#ifndef UNIV_HOTBACKUP
        mem_heap_t*     heap;
        que_thr_t*      thr;
        roll_node_t*    roll_node;

        /* Tell Innobase server that there might be work for
        utility threads: */

        srv_active_wake_master_thread();

        trx_start_if_not_started(trx);

        heap = mem_heap_create(512);

        roll_node = roll_node_create(heap);

        roll_node->partial = partial;

        if (partial) {
                roll_node->savept = *savept;
        }

        trx->error_state = DB_SUCCESS;

        thr = pars_complete_graph_for_exec(roll_node, trx, heap);

        ut_a(thr == que_fork_start_command(que_node_get_parent(thr)));
        que_run_threads(thr);

        mutex_enter(&kernel_mutex);

        while (trx->que_state != TRX_QUE_RUNNING) {

                mutex_exit(&kernel_mutex);

                os_thread_sleep(100000);

                mutex_enter(&kernel_mutex);
        }

        mutex_exit(&kernel_mutex);

        mem_heap_free(heap);

        ut_a(trx->error_state == DB_SUCCESS);

        /* Tell Innobase server that there might be work for
        utility threads: */

        srv_active_wake_master_thread();

        return((int) trx->error_state);
#else /* UNIV_HOTBACKUP */
        /* This function depends on MySQL code that is not included in
        InnoDB Hot Backup builds.  Besides, this function should never
        be called in InnoDB Hot Backup. */
        ut_error;
        return(DB_FAIL);
#endif /* UNIV_HOTBACKUP */
}

Here is the call graph for this function:

Here is the caller graph for this function:

ulint trx_release_savepoint_for_mysql	(	trx_t *	trx,
		const char *	savepoint_name
	)

Definition at line 332 of file trx0roll.c.

References DB_NO_SAVEPOINT, DB_SUCCESS, mem_free, trx_named_savept_struct::name, NULL, trx_roll_savepoints_free(), trx_struct::trx_savepoints, UT_LIST_GET_FIRST, UT_LIST_GET_NEXT, UT_LIST_REMOVE, and ut_strcmp().

                                                      : if no savepoint
                                                of the name found then
                                                DB_NO_SAVEPOINT,
                                                otherwise DB_SUCCESS */
        trx_t*          trx,                    /* in: transaction handle */
        const char*     savepoint_name)         /* in: savepoint name */
{
        trx_named_savept_t*     savep;

        savep = UT_LIST_GET_FIRST(trx->trx_savepoints);

        while (savep != NULL) {
                if (0 == ut_strcmp(savep->name, savepoint_name)) {
                        /* Found */
                        break;
                }
                savep = UT_LIST_GET_NEXT(trx_savepoints, savep);
        }

        if (savep == NULL) {

                return(DB_NO_SAVEPOINT);
        }

        /* We can now free all savepoints strictly later than this one */

        trx_roll_savepoints_free(trx, savep);

        /* Now we can free this savepoint too */

        UT_LIST_REMOVE(trx_savepoints, trx->trx_savepoints, savep);

        mem_free(savep->name);
        mem_free(savep);

        return(DB_SUCCESS);
}

Here is the call graph for this function:

que_t* trx_roll_graph_build

(

trx_t *

trx

)

Definition at line 1100 of file trx0roll.c.

References que_thr_struct::child, kernel_mutex, mem_heap_create, NULL, que_fork_create(), QUE_FORK_ROLLBACK, que_thr_create(), row_undo_node_create(), que_fork_struct::trx, and ut_ad.

Referenced by trx_rollback().

                                   : the query graph */
        trx_t*  trx)    /* in: trx handle */
{
        mem_heap_t*     heap;
        que_fork_t*     fork;
        que_thr_t*      thr;
/*      que_thr_t*      thr2; */

#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&kernel_mutex));
#endif /* UNIV_SYNC_DEBUG */

        heap = mem_heap_create(512);
        fork = que_fork_create(NULL, NULL, QUE_FORK_ROLLBACK, heap);
        fork->trx = trx;

        thr = que_thr_create(fork, heap);
/*      thr2 = que_thr_create(fork, heap); */

        thr->child = row_undo_node_create(trx, thr, heap);
/*      thr2->child = row_undo_node_create(trx, thr2, heap); */

        return(fork);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static trx_undo_rec_t* trx_roll_pop_top_rec	(	trx_t *	trx,
		trx_undo_t *	undo,
		mtr_t *	mtr
	)			[static]

Definition at line 800 of file trx0roll.c.

References buf_frame_align(), buf_frame_get_page_no(), trx_undo_struct::empty, trx_undo_struct::hdr_offset, trx_undo_struct::hdr_page_no, NULL, offset, page_t, trx_struct::pages_undone, trx_undo_struct::space, trx_undo_struct::top_offset, trx_undo_struct::top_page_no, trx_undo_struct::top_undo_no, TRUE, trx_undo_get_prev_rec(), trx_undo_page_get_s_latched(), trx_undo_rec_get_undo_no(), trx_struct::undo_mutex, and ut_ad.

Referenced by trx_roll_pop_top_rec_of_trx().

                                      : undo log record, the page s-latched */
        trx_t*          trx,    /* in: transaction */
        trx_undo_t*     undo,   /* in: undo log */
        mtr_t*          mtr)    /* in: mtr */
{
        page_t*         undo_page;
        ulint           offset;
        trx_undo_rec_t* prev_rec;
        page_t*         prev_rec_page;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&(trx->undo_mutex)));
#endif /* UNIV_SYNC_DEBUG */

        undo_page = trx_undo_page_get_s_latched(undo->space,
                                                undo->top_page_no, mtr);
        offset = undo->top_offset;

/*      fprintf(stderr, "Thread %lu undoing trx %lu undo record %lu\n",
                os_thread_get_curr_id(), ut_dulint_get_low(trx->id),
                ut_dulint_get_low(undo->top_undo_no)); */

        prev_rec = trx_undo_get_prev_rec(undo_page + offset,
                                        undo->hdr_page_no, undo->hdr_offset,
                                                                        mtr);
        if (prev_rec == NULL) {

                undo->empty = TRUE;
        } else {
                prev_rec_page = buf_frame_align(prev_rec);

                if (prev_rec_page != undo_page) {

                        trx->pages_undone++;
                }

                undo->top_page_no = buf_frame_get_page_no(prev_rec_page);
                undo->top_offset  = prev_rec - prev_rec_page;
                undo->top_undo_no = trx_undo_rec_get_undo_no(prev_rec);
        }

        return(undo_page + offset);
}

Here is the call graph for this function:

Here is the caller graph for this function:

trx_undo_rec_t* trx_roll_pop_top_rec_of_trx	(	trx_t *	trx,
		dulint	limit,
		dulint *	roll_ptr,
		mem_heap_t *	heap
	)

Definition at line 854 of file trx0roll.c.

References trx_undo_struct::empty, FALSE, trx_struct::insert_undo, mtr_commit(), mtr_start(), trx_rseg_struct::mutex, mutex_enter, mutex_exit(), NULL, trx_struct::pages_undone, trx_undo_struct::rseg, trx_struct::rseg, trx_undo_struct::top_offset, trx_undo_struct::top_page_no, trx_undo_struct::top_undo_no, TRUE, trx_roll_crash_recv_trx, trx_roll_max_undo_no, trx_roll_pop_top_rec(), trx_roll_progress_printed_pct, TRX_ROLL_TRUNC_THRESHOLD, trx_roll_try_truncate(), trx_undo_arr_store_info(), trx_undo_build_roll_ptr(), trx_undo_rec_copy(), trx_undo_rec_get_undo_no(), trx_struct::undo_mutex, trx_struct::undo_no, trx_struct::undo_no_arr, trx_struct::update_undo, ut_ad, ut_conv_dulint_to_longlong(), ut_dulint_add(), and ut_dulint_cmp().

Referenced by row_undo().

                                      : undo log record copied to heap, NULL
                                if none left, or if the undo number of the
                                top record would be less than the limit */
        trx_t*          trx,    /* in: transaction */
        dulint          limit,  /* in: least undo number we need */
        dulint*         roll_ptr,/* out: roll pointer to undo record */
        mem_heap_t*     heap)   /* in: memory heap where copied */
{
        trx_undo_t*     undo;
        trx_undo_t*     ins_undo;
        trx_undo_t*     upd_undo;
        trx_undo_rec_t* undo_rec;
        trx_undo_rec_t* undo_rec_copy;
        dulint          undo_no;
        ibool           is_insert;
        trx_rseg_t*     rseg;
        ulint           progress_pct;
        mtr_t           mtr;

        rseg = trx->rseg;
try_again:
        mutex_enter(&(trx->undo_mutex));

        if (trx->pages_undone >= TRX_ROLL_TRUNC_THRESHOLD) {
                mutex_enter(&(rseg->mutex));

                trx_roll_try_truncate(trx);

                mutex_exit(&(rseg->mutex));
        }

        ins_undo = trx->insert_undo;
        upd_undo = trx->update_undo;

        if (!ins_undo || ins_undo->empty) {
                undo = upd_undo;
        } else if (!upd_undo || upd_undo->empty) {
                undo = ins_undo;
        } else if (ut_dulint_cmp(upd_undo->top_undo_no,
                                 ins_undo->top_undo_no) > 0) {
                undo = upd_undo;
        } else {
                undo = ins_undo;
        }

        if (!undo || undo->empty
                        || (ut_dulint_cmp(limit, undo->top_undo_no) > 0)) {

                if ((trx->undo_no_arr)->n_used == 0) {
                        /* Rollback is ending */

                        mutex_enter(&(rseg->mutex));

                        trx_roll_try_truncate(trx);

                        mutex_exit(&(rseg->mutex));
                }

                mutex_exit(&(trx->undo_mutex));

                return(NULL);
        }

        if (undo == ins_undo) {
                is_insert = TRUE;
        } else {
                is_insert = FALSE;
        }

        *roll_ptr = trx_undo_build_roll_ptr(is_insert, (undo->rseg)->id,
                                        undo->top_page_no, undo->top_offset);
        mtr_start(&mtr);

        undo_rec = trx_roll_pop_top_rec(trx, undo, &mtr);

        undo_no = trx_undo_rec_get_undo_no(undo_rec);

        ut_ad(ut_dulint_cmp(ut_dulint_add(undo_no, 1), trx->undo_no) == 0);

        /* We print rollback progress info if we are in a crash recovery
        and the transaction has at least 1000 row operations to undo. */

        if (trx == trx_roll_crash_recv_trx && trx_roll_max_undo_no > 1000) {

                progress_pct = 100 - (ulint)
                                ((ut_conv_dulint_to_longlong(undo_no) * 100)
                                / trx_roll_max_undo_no);
                if (progress_pct != trx_roll_progress_printed_pct) {
                        if (trx_roll_progress_printed_pct == 0) {
                                fprintf(stderr,
"\nInnoDB: Progress in percents: %lu", (ulong) progress_pct);
                        } else {
                                fprintf(stderr,
                                " %lu", (ulong) progress_pct);
                        }
                        fflush(stderr);
                        trx_roll_progress_printed_pct = progress_pct;
                }
        }

        trx->undo_no = undo_no;

        if (!trx_undo_arr_store_info(trx, undo_no)) {
                /* A query thread is already processing this undo log record */

                mutex_exit(&(trx->undo_mutex));

                mtr_commit(&mtr);

                goto try_again;
        }

        undo_rec_copy = trx_undo_rec_copy(undo_rec, heap);

        mutex_exit(&(trx->undo_mutex));

        mtr_commit(&mtr);

        return(undo_rec_copy);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void trx_roll_savepoints_free	(	trx_t *	trx,
		trx_named_savept_t *	savep
	)

Definition at line 173 of file trx0roll.c.

References mem_free, trx_named_savept_struct::name, NULL, trx_struct::trx_savepoints, UT_LIST_GET_FIRST, UT_LIST_GET_NEXT, and UT_LIST_REMOVE.

Referenced by trx_commit_off_kernel(), trx_release_savepoint_for_mysql(), and trx_rollback_to_savepoint_for_mysql().

                                             : transaction handle */
        trx_named_savept_t*     savep)  /* in: free all savepoints > this one;
                                        if this is NULL, free all savepoints
                                        of trx */
{
        trx_named_savept_t*     next_savep;

        if (savep == NULL) {
                savep = UT_LIST_GET_FIRST(trx->trx_savepoints);
        } else {
                savep = UT_LIST_GET_NEXT(trx_savepoints, savep);
        }

        while (savep != NULL) {
                next_savep = UT_LIST_GET_NEXT(trx_savepoints, savep);

                UT_LIST_REMOVE(trx_savepoints, trx->trx_savepoints, savep);
                mem_free(savep->name);
                mem_free(savep);

                savep = next_savep;
        }
}

Here is the caller graph for this function:

void trx_roll_try_truncate

(

trx_t *

trx

)

Definition at line 758 of file trx0roll.c.

References trx_struct::insert_undo, trx_undo_arr_struct::n_used, trx_struct::pages_undone, trx_struct::rseg, trx_undo_arr_get_biggest(), trx_undo_truncate_end(), trx_struct::undo_mutex, trx_struct::undo_no, trx_struct::undo_no_arr, trx_struct::update_undo, ut_ad, ut_dulint_add(), and ut_dulint_cmp().

Referenced by trx_roll_pop_top_rec_of_trx().

                             : transaction */
{
        trx_undo_arr_t* arr;
        dulint          limit;
        dulint          biggest;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&(trx->undo_mutex)));
        ut_ad(mutex_own(&((trx->rseg)->mutex)));
#endif /* UNIV_SYNC_DEBUG */

        trx->pages_undone = 0;

        arr = trx->undo_no_arr;

        limit = trx->undo_no;

        if (arr->n_used > 0) {
                biggest = trx_undo_arr_get_biggest(arr);

                if (ut_dulint_cmp(biggest, limit) >= 0) {

                        limit = ut_dulint_add(biggest, 1);
                }
        }

        if (trx->insert_undo) {
                trx_undo_truncate_end(trx, trx->insert_undo, limit);
        }

        if (trx->update_undo) {
                trx_undo_truncate_end(trx, trx->update_undo, limit);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void trx_rollback	(	trx_t *	trx,
		trx_sig_t *	sig,
		que_thr_t **	next_thr
	)

Definition at line 1024 of file trx0roll.c.

References trx_struct::graph, kernel_mutex, trx_struct::last_sql_stat_start, trx_savept_struct::least_undo_no, NULL, trx_struct::pages_undone, que_fork_start_command(), trx_struct::que_state, trx_struct::roll_limit, sig(), srv_que_task_enqueue_low(), TRX_QUE_ROLLING_BACK, trx_roll_graph_build(), TRX_SIG_ERROR_OCCURRED, TRX_SIG_ROLLBACK_TO_SAVEPT, TRX_SIG_TOTAL_ROLLBACK, trx_undo_arr_create(), trx_struct::undo_no, trx_struct::undo_no_arr, ut_a, ut_ad, ut_dulint_cmp(), ut_dulint_zero, and ut_error.

Referenced by trx_sig_start_handle().

                                     : transaction */
        trx_sig_t*      sig,    /* in: signal starting the rollback */
        que_thr_t**     next_thr)/* in/out: next query thread to run;
                                if the value which is passed in is
                                a pointer to a NULL pointer, then the
                                calling function can start running
                                a new query thread; if the passed value is
                                NULL, the parameter is ignored */
{
        que_t*          roll_graph;
        que_thr_t*      thr;
/*      que_thr_t*      thr2; */

#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&kernel_mutex));
#endif /* UNIV_SYNC_DEBUG */
        ut_ad((trx->undo_no_arr == NULL) || ((trx->undo_no_arr)->n_used == 0));

        /* Initialize the rollback field in the transaction */

        if (sig->type == TRX_SIG_TOTAL_ROLLBACK) {

                trx->roll_limit = ut_dulint_zero;

        } else if (sig->type == TRX_SIG_ROLLBACK_TO_SAVEPT) {

                trx->roll_limit = (sig->savept).least_undo_no;

        } else if (sig->type == TRX_SIG_ERROR_OCCURRED) {

                trx->roll_limit = trx->last_sql_stat_start.least_undo_no;
        } else {
                ut_error;
        }

        ut_a(ut_dulint_cmp(trx->roll_limit, trx->undo_no) <= 0);

        trx->pages_undone = 0;

        if (trx->undo_no_arr == NULL) {
                trx->undo_no_arr = trx_undo_arr_create();
        }

        /* Build a 'query' graph which will perform the undo operations */

        roll_graph = trx_roll_graph_build(trx);

        trx->graph = roll_graph;
        trx->que_state = TRX_QUE_ROLLING_BACK;

        thr = que_fork_start_command(roll_graph);

        ut_ad(thr);

/*      thr2 = que_fork_start_command(roll_graph);

        ut_ad(thr2); */

        if (next_thr && (*next_thr == NULL)) {
                *next_thr = thr;
/*              srv_que_task_enqueue_low(thr2); */
        } else {
                srv_que_task_enqueue_low(thr);
/*              srv_que_task_enqueue_low(thr2); */
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int trx_rollback_for_mysql

(

trx_t *

trx

)

Definition at line 120 of file trx0roll.c.

References trx_struct::conc_state, DB_SUCCESS, err, FALSE, NULL, trx_struct::op_info, trx_general_rollback_for_mysql(), and TRX_NOT_STARTED.

                              : error code or DB_SUCCESS */
        trx_t*  trx)    /* in: transaction handle */
{
        int     err;

        if (trx->conc_state == TRX_NOT_STARTED) {

                return(DB_SUCCESS);
        }

        trx->op_info = "rollback";

        err = trx_general_rollback_for_mysql(trx, FALSE, NULL);

        trx->op_info = "";

        return(err);
}

Here is the call graph for this function:

int trx_rollback_last_sql_stat_for_mysql

(

trx_t *

trx

)

Definition at line 145 of file trx0roll.c.

References trx_struct::conc_state, DB_SUCCESS, err, trx_struct::last_sql_stat_start, trx_struct::op_info, TRUE, trx_general_rollback_for_mysql(), trx_mark_sql_stat_end(), and TRX_NOT_STARTED.

                              : error code or DB_SUCCESS */
        trx_t*  trx)    /* in: transaction handle */
{
        int     err;

        if (trx->conc_state == TRX_NOT_STARTED) {

                return(DB_SUCCESS);
        }

        trx->op_info = "rollback of SQL statement";

        err = trx_general_rollback_for_mysql(trx, TRUE,
                                                &(trx->last_sql_stat_start));
        /* The following call should not be needed, but we play safe: */
        trx_mark_sql_stat_end(trx);

        trx->op_info = "";

        return(err);
}

Here is the call graph for this function:

os_thread_ret_t trx_rollback_or_clean_all_without_sess

(

void *arg

__attribute__((unused))

)

Definition at line 395 of file trx0roll.c.

References que_thr_struct::child, roll_node_struct::common, trx_struct::conc_state, DB_SUCCESS, trx_struct::dict_operation, dict_table_get_on_id_low(), err, trx_struct::graph, trx_struct::id, kernel_mutex, mem_heap_create, mem_heap_free, mutex_enter, mutex_exit(), trx_struct::mysql_process_no, trx_struct::mysql_thread_id, dict_table_struct::name, NULL, os_proc_get_number(), os_thread_exit(), os_thread_get_curr_id(), os_thread_sleep(), que_common_struct::parent, que_fork_create(), QUE_FORK_RECOVERY, que_fork_start_command(), que_run_threads(), trx_struct::que_state, que_thr_create(), roll_node_create(), row_drop_table_for_mysql(), row_mysql_lock_data_dictionary(), row_mysql_unlock_data_dictionary(), trx_struct::sess, sess_open(), trx_struct::table_id, TRUE, que_fork_struct::trx, trx_cleanup_at_db_startup(), TRX_COMMITTED_IN_MEMORY, trx_dummy_sess, TRX_NOT_STARTED, TRX_PREPARED, TRX_QUE_RUNNING, trx_roll_crash_recv_trx, trx_roll_max_undo_no, trx_roll_progress_printed_pct, trx_sys, trx_struct::undo_no, ut_a, ut_conv_dulint_to_longlong(), ut_dulint_get_high(), ut_dulint_get_low(), UT_LIST_GET_FIRST, UT_LIST_GET_NEXT, ut_print_name(), and ut_print_timestamp().

Referenced by recv_recovery_from_checkpoint_finish().

                              : a dummy parameter */
        void*   arg __attribute__((unused)))
                        /* in: a dummy parameter required by
                        os_thread_create */
{
        mem_heap_t*     heap;
        que_fork_t*     fork;
        que_thr_t*      thr;
        roll_node_t*    roll_node;
        trx_t*          trx;
        dict_table_t*   table;
        ib_longlong     rows_to_undo;
        const char*     unit            = "";
        int             err;

        mutex_enter(&kernel_mutex);

        /* Open a dummy session */

        if (!trx_dummy_sess) {
                trx_dummy_sess = sess_open();
        }

        mutex_exit(&kernel_mutex);

        if (UT_LIST_GET_FIRST(trx_sys->trx_list)) {

                fprintf(stderr,
"InnoDB: Starting in background the rollback of uncommitted transactions\n");
        } else {
                goto leave_function;
        }
loop:
        heap = mem_heap_create(512);

        mutex_enter(&kernel_mutex);

        trx = UT_LIST_GET_FIRST(trx_sys->trx_list);

        while (trx) {
                if ((trx->sess || (trx->conc_state == TRX_NOT_STARTED))) {
                        trx = UT_LIST_GET_NEXT(trx_list, trx);
                } else if (trx->conc_state == TRX_PREPARED) {

                        trx->sess = trx_dummy_sess;
                        trx = UT_LIST_GET_NEXT(trx_list, trx);
                } else {
                        break;
                }
        }

        mutex_exit(&kernel_mutex);

        if (trx == NULL) {
                ut_print_timestamp(stderr);
                fprintf(stderr,
                "  InnoDB: Rollback of non-prepared transactions completed\n");

                mem_heap_free(heap);

                goto leave_function;
        }

        trx->sess = trx_dummy_sess;

        if (trx->conc_state == TRX_COMMITTED_IN_MEMORY) {
                fprintf(stderr, "InnoDB: Cleaning up trx with id %lu %lu\n",
                                        (ulong) ut_dulint_get_high(trx->id),
                                        (ulong) ut_dulint_get_low(trx->id));

                trx_cleanup_at_db_startup(trx);

                mem_heap_free(heap);

                goto loop;
        }

        fork = que_fork_create(NULL, NULL, QUE_FORK_RECOVERY, heap);
        fork->trx = trx;

        thr = que_thr_create(fork, heap);

        roll_node = roll_node_create(heap);

        thr->child = roll_node;
        roll_node->common.parent = thr;

        mutex_enter(&kernel_mutex);

        trx->graph = fork;

        ut_a(thr == que_fork_start_command(fork));

        trx_roll_crash_recv_trx = trx;
        trx_roll_max_undo_no = ut_conv_dulint_to_longlong(trx->undo_no);
        trx_roll_progress_printed_pct = 0;
        rows_to_undo = trx_roll_max_undo_no;

        if (rows_to_undo > 1000000000) {
                rows_to_undo = rows_to_undo / 1000000;
                unit = "M";
        }

        ut_print_timestamp(stderr);
        fprintf(stderr,
"  InnoDB: Rolling back trx with id %lu %lu, %lu%s rows to undo\n",
                                        (ulong) ut_dulint_get_high(trx->id),
                                        (ulong) ut_dulint_get_low(trx->id),
                                        (ulong) rows_to_undo, unit);
        mutex_exit(&kernel_mutex);

        trx->mysql_thread_id = os_thread_get_curr_id();

        trx->mysql_process_no = os_proc_get_number();

        if (trx->dict_operation) {
                row_mysql_lock_data_dictionary(trx);
        }

        que_run_threads(thr);

        mutex_enter(&kernel_mutex);

        while (trx->que_state != TRX_QUE_RUNNING) {

                mutex_exit(&kernel_mutex);

                fprintf(stderr,
                "InnoDB: Waiting for rollback of trx id %lu to end\n",
                                        (ulong) ut_dulint_get_low(trx->id));
                os_thread_sleep(100000);

                mutex_enter(&kernel_mutex);
        }

        mutex_exit(&kernel_mutex);

        if (trx->dict_operation) {
                /* If the transaction was for a dictionary operation, we
                drop the relevant table, if it still exists */

                fprintf(stderr,
"InnoDB: Dropping table with id %lu %lu in recovery if it exists\n",
                        (ulong) ut_dulint_get_high(trx->table_id),
                        (ulong) ut_dulint_get_low(trx->table_id));

                table = dict_table_get_on_id_low(trx->table_id);

                if (table) {
                        fputs("InnoDB: Table found: dropping table ", stderr);
                        ut_print_name(stderr, trx, TRUE, table->name);
                        fputs(" in recovery\n", stderr);

                        err = row_drop_table_for_mysql(table->name, trx, TRUE);

                        ut_a(err == (int) DB_SUCCESS);
                }
        }

        if (trx->dict_operation) {
                row_mysql_unlock_data_dictionary(trx);
        }

        fprintf(stderr, "\nInnoDB: Rolling back of trx id %lu %lu completed\n",
                                        (ulong) ut_dulint_get_high(trx->id),
                                        (ulong) ut_dulint_get_low(trx->id));
        mem_heap_free(heap);

        trx_roll_crash_recv_trx = NULL;

        goto loop;

leave_function:
        /* We count the number of threads in os_thread_exit(). A created
        thread should always use that to exit and not use return() to exit. */

        os_thread_exit(NULL);

        OS_THREAD_DUMMY_RETURN;
}

Here is the call graph for this function:

Here is the caller graph for this function:

que_thr_t* trx_rollback_step

(

que_thr_t *

thr

)

Definition at line 1283 of file trx0roll.c.

References kernel_mutex, mutex_enter, mutex_exit(), NULL, roll_node_struct::partial, que_thr_struct::prev_node, que_node_get_parent(), que_node_get_type(), QUE_NODE_ROLLBACK, QUE_THR_SIG_REPLY_WAIT, ROLL_NODE_SEND, ROLL_NODE_WAIT, que_thr_struct::run_node, roll_node_struct::savept, que_thr_struct::state, roll_node_struct::state, thr_get_trx(), TRX_SIG_ROLLBACK_TO_SAVEPT, TRX_SIG_SELF, trx_sig_send(), TRX_SIG_TOTAL_ROLLBACK, and ut_ad.

Referenced by que_thr_step().

                                      : query thread to run next, or NULL */
        que_thr_t*      thr)    /* in: query thread */
{
        roll_node_t*    node;
        ulint           sig_no;
        trx_savept_t*   savept;

        node = thr->run_node;

        ut_ad(que_node_get_type(node) == QUE_NODE_ROLLBACK);

        if (thr->prev_node == que_node_get_parent(node)) {
                node->state = ROLL_NODE_SEND;
        }

        if (node->state == ROLL_NODE_SEND) {
                mutex_enter(&kernel_mutex);

                node->state = ROLL_NODE_WAIT;

                if (node->partial) {
                        sig_no = TRX_SIG_ROLLBACK_TO_SAVEPT;
                        savept = &(node->savept);
                } else {
                        sig_no = TRX_SIG_TOTAL_ROLLBACK;
                        savept = NULL;
                }

                /* Send a rollback signal to the transaction */

                trx_sig_send(thr_get_trx(thr), sig_no, TRX_SIG_SELF, thr,
                        savept, NULL);

                thr->state = QUE_THR_SIG_REPLY_WAIT;

                mutex_exit(&kernel_mutex);

                return(NULL);
        }

        ut_ad(node->state == ROLL_NODE_WAIT);

        thr->run_node = que_node_get_parent(node);

        return(thr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ulint trx_rollback_to_savepoint_for_mysql	(	trx_t *	trx,
		const char *	savepoint_name,
		ib_longlong *	mysql_binlog_cache_pos
	)

Definition at line 208 of file trx0roll.c.

References trx_struct::conc_state, DB_ERROR, DB_NO_SAVEPOINT, err, FALSE, trx_named_savept_struct::mysql_binlog_cache_pos, trx_named_savept_struct::name, NULL, trx_struct::op_info, trx_named_savept_struct::savept, TRUE, trx_general_rollback_for_mysql(), trx_mark_sql_stat_end(), TRX_NOT_STARTED, trx_roll_savepoints_free(), trx_struct::trx_savepoints, UT_LIST_GET_FIRST, UT_LIST_GET_NEXT, ut_print_name(), ut_print_timestamp(), and ut_strcmp().

                                                      : if no savepoint
                                                of the name found then
                                                DB_NO_SAVEPOINT,
                                                otherwise DB_SUCCESS */
        trx_t*          trx,                    /* in: transaction handle */
        const char*     savepoint_name,         /* in: savepoint name */
        ib_longlong*    mysql_binlog_cache_pos) /* out: the MySQL binlog cache
                                                position corresponding to this
                                                savepoint; MySQL needs this
                                                information to remove the
                                                binlog entries of the queries
                                                executed after the savepoint */
{
        trx_named_savept_t*     savep;
        ulint                   err;

        savep = UT_LIST_GET_FIRST(trx->trx_savepoints);

        while (savep != NULL) {
                if (0 == ut_strcmp(savep->name, savepoint_name)) {
                        /* Found */
                        break;
                }
                savep = UT_LIST_GET_NEXT(trx_savepoints, savep);
        }

        if (savep == NULL) {

                return(DB_NO_SAVEPOINT);
        }

        if (trx->conc_state == TRX_NOT_STARTED) {
                ut_print_timestamp(stderr);
                fputs("  InnoDB: Error: transaction has a savepoint ", stderr);
                ut_print_name(stderr, trx, FALSE, savep->name);
                fputs(" though it is not started\n", stderr);
                return(DB_ERROR);
        }

        /* We can now free all savepoints strictly later than this one */

        trx_roll_savepoints_free(trx, savep);

        *mysql_binlog_cache_pos = savep->mysql_binlog_cache_pos;

        trx->op_info = "rollback to a savepoint";

        err = trx_general_rollback_for_mysql(trx, TRUE, &(savep->savept));

        /* Store the current undo_no of the transaction so that we know where
        to roll back if we have to roll back the next SQL statement: */

        trx_mark_sql_stat_end(trx);

        trx->op_info = "";

        return(err);
}

Here is the call graph for this function:

ulint trx_savepoint_for_mysql	(	trx_t *	trx,
		const char *	savepoint_name,
		ib_longlong	binlog_cache_pos
	)

Definition at line 276 of file trx0roll.c.

References DB_SUCCESS, mem_alloc, mem_free, mem_strdup(), trx_named_savept_struct::mysql_binlog_cache_pos, trx_named_savept_struct::name, NULL, trx_named_savept_struct::savept, trx_struct::trx_savepoints, trx_savept_take(), trx_start_if_not_started(), ut_a, UT_LIST_ADD_LAST, UT_LIST_GET_FIRST, UT_LIST_GET_NEXT, UT_LIST_REMOVE, and ut_strcmp().

                                                      : always DB_SUCCESS */
        trx_t*          trx,                    /* in: transaction handle */
        const char*     savepoint_name,         /* in: savepoint name */
        ib_longlong     binlog_cache_pos)       /* in: MySQL binlog cache
                                                position corresponding to this
                                                connection at the time of the
                                                savepoint */
{
        trx_named_savept_t*     savep;

        ut_a(trx);
        ut_a(savepoint_name);

        trx_start_if_not_started(trx);

        savep = UT_LIST_GET_FIRST(trx->trx_savepoints);

        while (savep != NULL) {
                if (0 == ut_strcmp(savep->name, savepoint_name)) {
                        /* Found */
                        break;
                }
                savep = UT_LIST_GET_NEXT(trx_savepoints, savep);
        }

        if (savep) {
                /* There is a savepoint with the same name: free that */

                UT_LIST_REMOVE(trx_savepoints, trx->trx_savepoints, savep);

                mem_free(savep->name);
                mem_free(savep);
        }

        /* Create a new savepoint and add it as the last in the list */

        savep = mem_alloc(sizeof(trx_named_savept_t));

        savep->name = mem_strdup(savepoint_name);

        savep->savept = trx_savept_take(trx);

        savep->mysql_binlog_cache_pos = binlog_cache_pos;

        UT_LIST_ADD_LAST(trx_savepoints, trx->trx_savepoints, savep);

        return(DB_SUCCESS);
}

Here is the call graph for this function:

trx_savept_t trx_savept_take

(

trx_t *

trx

)

Definition at line 376 of file trx0roll.c.

References trx_savept_struct::least_undo_no, and trx_struct::undo_no.

Referenced by row_insert_for_mysql(), row_update_for_mysql(), and trx_savepoint_for_mysql().

                              : savepoint */
        trx_t*  trx)    /* in: transaction */
{
        trx_savept_t    savept;

        savept.least_undo_no = trx->undo_no;

        return(savept);
}

Here is the caller graph for this function:

trx_undo_arr_t* trx_undo_arr_create

(

void

)

Definition at line 582 of file trx0roll.c.

References FALSE, trx_undo_arr_struct::heap, trx_undo_arr_struct::infos, mem_heap_alloc(), mem_heap_create, trx_undo_arr_struct::n_cells, trx_undo_arr_struct::n_used, and trx_undo_arr_get_nth_info().

Referenced by trx_purge_sys_create(), and trx_rollback().

{
        trx_undo_arr_t* arr;
        mem_heap_t*     heap;
        ulint           i;

        heap = mem_heap_create(1024);

        arr = mem_heap_alloc(heap, sizeof(trx_undo_arr_t));

        arr->infos = mem_heap_alloc(heap, sizeof(trx_undo_inf_t)
                                                * UNIV_MAX_PARALLELISM);
        arr->n_cells = UNIV_MAX_PARALLELISM;
        arr->n_used = 0;

        arr->heap = heap;

        for (i = 0; i < UNIV_MAX_PARALLELISM; i++) {

                (trx_undo_arr_get_nth_info(arr, i))->in_use = FALSE;
        }

        return(arr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void trx_undo_arr_free

(

trx_undo_arr_t *

arr

)

Definition at line 612 of file trx0roll.c.

References trx_undo_arr_struct::heap, mem_heap_free, trx_undo_arr_struct::n_used, and ut_ad.

Referenced by trx_free().

                                     : undo number array */
{
        ut_ad(arr->n_used == 0);

        mem_heap_free(arr->heap);
}

Here is the caller graph for this function:

static dulint trx_undo_arr_get_biggest

(

trx_undo_arr_t *

arr

)

[static]

Definition at line 721 of file trx0roll.c.

References trx_undo_inf_struct::in_use, n, trx_undo_arr_struct::n_used, trx_undo_arr_get_nth_info(), trx_undo_inf_struct::undo_no, ut_dulint_cmp(), and ut_dulint_zero.

Referenced by trx_roll_try_truncate().

                                      : biggest value, ut_dulint_zero if
                                the array is empty */
        trx_undo_arr_t* arr)    /* in: undo number array */
{
        trx_undo_inf_t* cell;
        ulint           n_used;
        dulint          biggest;
        ulint           n;
        ulint           i;

        n = 0;
        n_used = arr->n_used;
        biggest = ut_dulint_zero;

        for (i = 0;; i++) {
                cell = trx_undo_arr_get_nth_info(arr, i);

                if (cell->in_use) {
                        n++;
                        if (ut_dulint_cmp(cell->undo_no, biggest) > 0) {

                                biggest = cell->undo_no;
                        }
                }

                if (n == n_used) {
                        return(biggest);
                }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void trx_undo_arr_remove_info	(	trx_undo_arr_t *	arr,
		dulint	undo_no
	)			[static]

Definition at line 687 of file trx0roll.c.

References FALSE, trx_undo_inf_struct::in_use, n, trx_undo_arr_struct::n_used, trx_undo_arr_get_nth_info(), trx_undo_inf_struct::undo_no, ut_ad, and ut_dulint_cmp().

Referenced by trx_undo_rec_release().

                                     : undo number array */
        dulint          undo_no)/* in: undo number */
{
        trx_undo_inf_t* cell;
        ulint           n_used;
        ulint           n;
        ulint           i;

        n_used = arr->n_used;
        n = 0;

        for (i = 0;; i++) {
                cell = trx_undo_arr_get_nth_info(arr, i);

                if (cell->in_use
                        && 0 == ut_dulint_cmp(cell->undo_no, undo_no)) {

                        cell->in_use = FALSE;

                        ut_ad(arr->n_used > 0);

                        arr->n_used--;

                        return;
                }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ibool trx_undo_arr_store_info	(	trx_t *	trx,
		dulint	undo_no
	)			[static]

Definition at line 625 of file trx0roll.c.

References FALSE, trx_undo_inf_struct::in_use, n, trx_undo_arr_struct::n_used, NULL, TRUE, trx_undo_arr_get_nth_info(), trx_undo_inf_struct::undo_no, trx_struct::undo_no_arr, ut_ad, and ut_dulint_cmp().

Referenced by trx_roll_pop_top_rec_of_trx(), and trx_undo_rec_reserve().

                              : FALSE if the record already existed in the
                        array */
        trx_t*  trx,    /* in: transaction */
        dulint  undo_no)/* in: undo number */
{
        trx_undo_inf_t* cell;
        trx_undo_inf_t* stored_here;
        trx_undo_arr_t* arr;
        ulint           n_used;
        ulint           n;
        ulint           i;

        n = 0;
        arr = trx->undo_no_arr;
        n_used = arr->n_used;
        stored_here = NULL;

        for (i = 0;; i++) {
                cell = trx_undo_arr_get_nth_info(arr, i);

                if (!cell->in_use) {
                        if (!stored_here) {
                                /* Not in use, we may store here */
                                cell->undo_no = undo_no;
                                cell->in_use = TRUE;

                                arr->n_used++;

                                stored_here = cell;
                        }
                } else {
                        n++;

                        if (0 == ut_dulint_cmp(cell->undo_no, undo_no)) {

                                if (stored_here) {
                                        stored_here->in_use = FALSE;
                                        ut_ad(arr->n_used > 0);
                                        arr->n_used--;
                                }

                                ut_ad(arr->n_used == n_used);

                                return(FALSE);
                        }
                }

                if (n == n_used && stored_here) {

                        ut_ad(arr->n_used == 1 + n_used);

                        return(TRUE);
                }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void trx_undo_rec_release	(	trx_t *	trx,
		dulint	undo_no
	)

Definition at line 1004 of file trx0roll.c.

References mutex_enter, mutex_exit(), trx_undo_arr_remove_info(), trx_struct::undo_mutex, and trx_struct::undo_no_arr.

Referenced by row_undo_ins(), row_undo_ins_remove_clust_rec(), row_undo_mod(), and row_undo_mod_clust().

                             : transaction */
        dulint  undo_no)/* in: undo number */
{
        trx_undo_arr_t* arr;

        mutex_enter(&(trx->undo_mutex));

        arr = trx->undo_no_arr;

        trx_undo_arr_remove_info(arr, undo_no);

        mutex_exit(&(trx->undo_mutex));
}

Here is the call graph for this function:

Here is the caller graph for this function:

ibool trx_undo_rec_reserve	(	trx_t *	trx,
		dulint	undo_no
	)

Definition at line 983 of file trx0roll.c.

References mutex_enter, mutex_exit(), trx_undo_arr_store_info(), and trx_struct::undo_mutex.

Referenced by row_undo_mod_clust().

                              : TRUE if succeeded */
        trx_t*  trx,    /* in: transaction */
        dulint  undo_no)/* in: undo number of the record */
{
        ibool   ret;

        mutex_enter(&(trx->undo_mutex));

        ret = trx_undo_arr_store_info(trx, undo_no);

        mutex_exit(&(trx->undo_mutex));

        return(ret);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

trx_t* trx_roll_crash_recv_trx = NULL

Definition at line 34 of file trx0roll.c.

Referenced by trx_roll_pop_top_rec_of_trx(), and trx_rollback_or_clean_all_without_sess().

ib_longlong trx_roll_max_undo_no

Definition at line 38 of file trx0roll.c.

Referenced by trx_roll_pop_top_rec_of_trx(), and trx_rollback_or_clean_all_without_sess().

ulint trx_roll_progress_printed_pct

Definition at line 41 of file trx0roll.c.

Referenced by trx_roll_pop_top_rec_of_trx(), and trx_rollback_or_clean_all_without_sess().

---

• Products
• MySQL Enterprise
• MySQL Cluster
• MySQL Embedded (OEM/ISV)
• MySQL Data Warehouse
• MySQL Backup & Recovery
• MySQL Workbench
• MySQL Connectors
• Online Shop

• Downloads
• MySQL Community Server
• MySQL Enterprise
• MySQL Proxy
• MySQL Cluster
• MySQL Workbench
• GUI Tools
• Connectors
• Archives
• Snapshots
• Mirrors

• Developer Zone
• Documentation
• Librarian
• Developer Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs
• MySQL Meetups
• Guilds
• Lists

• About
• About MySQL
• Contact Us
• Legal
• Privacy Policy
• Job Opportunities
• Site Map

© 1995-2008 MySQL AB, 2008- Sun Microsystems, Inc.