diff options
Diffstat (limited to 'storage/innobase/include/trx0trx.h')
| -rw-r--r-- | storage/innobase/include/trx0trx.h | 67 |
1 files changed, 35 insertions, 32 deletions
diff --git a/storage/innobase/include/trx0trx.h b/storage/innobase/include/trx0trx.h index 9d2a7680900..350615eee64 100644 --- a/storage/innobase/include/trx0trx.h +++ b/storage/innobase/include/trx0trx.h @@ -211,16 +211,13 @@ trx_recover_for_mysql( /*==================*/ XID* xid_list, /*!< in/out: prepared transactions */ uint len); /*!< in: number of slots in xid_list */ -/*******************************************************************//** -This function is used to find one X/Open XA distributed transaction -which is in the prepared state -@return trx or NULL; on match, the trx->xid will be invalidated; -note that the trx may have been committed, unless the caller is -holding lock_sys.mutex */ -trx_t * -trx_get_trx_by_xid( -/*===============*/ - XID* xid); /*!< in: X/Open XA transaction identifier */ +/** Look up an X/Open distributed transaction in XA PREPARE state. +@param[in] xid X/Open XA transaction identifier +@return transaction on match (the trx_t::xid will be invalidated); +note that the trx may have been committed before the caller acquires +trx_t::mutex +@retval NULL if no match */ +trx_t* trx_get_trx_by_xid(const XID* xid); /**********************************************************************//** If required, flushes the log to disk if we called trx_commit_for_mysql() with trx->flush_log_later == TRUE. */ @@ -467,6 +464,9 @@ Check transaction state */ ut_ad(!(t)->read_view.is_open()); \ ut_ad((t)->lock.wait_thr == NULL); \ ut_ad(UT_LIST_GET_LEN((t)->lock.trx_locks) == 0); \ + ut_ad((t)->lock.table_locks.empty()); \ + ut_ad(!(t)->autoinc_locks \ + || ib_vector_is_empty((t)->autoinc_locks)); \ ut_ad(UT_LIST_GET_LEN((t)->lock.evicted_tables) == 0); \ ut_ad((t)->dict_operation == TRX_DICT_OP_NONE); \ } while(0) @@ -708,10 +708,9 @@ Normally, only the thread that is currently associated with a running transaction may access (read and modify) the trx object, and it may do so without holding any mutex. The following are exceptions to this: -* trx_rollback_resurrected() may access resurrected (connectionless) -transactions while the system is already processing new user -transactions. The trx_sys.mutex prevents a race condition between it -and lock_trx_release_locks() [invoked by trx_commit()]. +* trx_rollback_recovered() may access resurrected (connectionless) +transactions (state == TRX_STATE_ACTIVE && is_recovered) +while the system is already processing new user transactions (!is_recovered). * trx_print_low() may access transactions not associated with the current thread. The caller must be holding lock_sys.mutex. @@ -722,7 +721,7 @@ must not be modified without holding trx->mutex. * The locking code (in particular, lock_deadlock_recursive() and lock_rec_convert_impl_to_expl()) will access transactions associated to other connections. The locks of transactions are protected by -lock_sys.mutex and sometimes by trx->mutex. */ +lock_sys.mutex (insertions also by trx->mutex). */ /** Represents an instance of rollback segment along with its state variables.*/ struct trx_undo_ptr_t { @@ -846,28 +845,26 @@ public: ACTIVE->COMMITTED is possible when the transaction is in rw_trx_hash. - Transitions to COMMITTED are protected by both lock_sys.mutex - and trx->mutex. - - NOTE: Some of these state change constraints are an overkill, - currently only required for a consistent view for printing stats. - This unnecessarily adds a huge cost for the general case. */ - + Transitions to COMMITTED are protected by trx_t::mutex. */ trx_state_t state; ReadView read_view; /*!< consistent read view used in the transaction, or NULL if not yet set */ trx_lock_t lock; /*!< Information about the transaction locks and state. Protected by - trx->mutex or lock_sys.mutex - or both */ - bool is_recovered; /*!< 0=normal transaction, - 1=recovered, must be rolled back, - protected by trx_sys.mutex when - trx is in rw_trx_hash */ - + lock_sys.mutex (insertions also + by trx_t::mutex). */ /* These fields are not protected by any mutex. */ + + /** false=normal transaction, true=recovered (must be rolled back) + or disconnected transaction in XA PREPARE STATE. + + This field is accessed by the thread that owns the transaction, + without holding any mutex. + There is only one foreign-thread access in trx_print_low() + and a possible race condition with trx_disconnect_prepared(). */ + bool is_recovered; const char* op_info; /*!< English text describing the current operation, or an empty string */ @@ -1125,9 +1122,15 @@ public: return flush_observer; } - /** Evict a table definition due to the rollback of ALTER TABLE. - @param[in] table_id table identifier */ - void evict_table(table_id_t table_id); + /** Transition to committed state, to release implicit locks. */ + inline void commit_state(); + + /** Release any explicit locks of a committing transaction. */ + inline void release_locks(); + + /** Evict a table definition due to the rollback of ALTER TABLE. + @param[in] table_id table identifier */ + void evict_table(table_id_t table_id); bool is_referenced() |