Skip to content

M
MariaDB
Commit 487fbc2e authored by Marko Mäkelä's avatar Marko Mäkelä
Browse files
Options

MDEV-21452 fixup: Introduce trx_t::mutex_is_owner() 

When we replaced trx_t::mutex with srw_mutex
in commit 38fd7b7d
we lost the SAFE_MUTEX instrumentation.
Let us introduce a replacement and restore the assertions.
parent 455514c8
Hide whitespace changes
Inline Side-by-side
Showing with 156 additions and 116 deletions
storage/innobase/handler/ha_innodb.cc
View file @ 487fbc2e
...@@ -4478,10 +4478,10 @@ static void innobase_kill_query(handlerton*, THD *thd, enum thd_kill_levels) ...@@ -4478,10 +4478,10 @@ static void innobase_kill_query(handlerton*, THD *thd, enum thd_kill_levels)
mysql_mutex_lock(&lock_sys.wait_mutex); mysql_mutex_lock(&lock_sys.wait_mutex);
if (lock_t *lock= trx->lock.wait_lock) if (lock_t *lock= trx->lock.wait_lock)
{ {
trx->mutex.wr_lock(); trx->mutex_lock();
trx->error_state= DB_INTERRUPTED; trx->error_state= DB_INTERRUPTED;
lock_cancel_waiting_and_release(lock); lock_cancel_waiting_and_release(lock);
trx->mutex.wr_unlock(); trx->mutex_unlock();
} }
lock_sys.mutex_unlock(); lock_sys.mutex_unlock();
mysql_mutex_unlock(&lock_sys.wait_mutex); mysql_mutex_unlock(&lock_sys.wait_mutex);
...@@ -18007,6 +18007,7 @@ int wsrep_innobase_kill_one_trx(THD *bf_thd, trx_t *victim_trx, bool signal) ...@@ -18007,6 +18007,7 @@ int wsrep_innobase_kill_one_trx(THD *bf_thd, trx_t *victim_trx, bool signal)
ut_ad(bf_thd); ut_ad(bf_thd);
ut_ad(victim_trx); ut_ad(victim_trx);
lock_sys.mutex_assert_locked(); lock_sys.mutex_assert_locked();
ut_ad(victim_trx->mutex_is_owner());
DBUG_ENTER("wsrep_innobase_kill_one_trx"); DBUG_ENTER("wsrep_innobase_kill_one_trx");
...@@ -18110,11 +18111,11 @@ wsrep_abort_transaction( ...@@ -18110,11 +18111,11 @@ wsrep_abort_transaction(
if (victim_trx) { if (victim_trx) {
lock_sys.mutex_lock(); lock_sys.mutex_lock();
victim_trx->mutex.wr_lock(); victim_trx->mutex_lock();
int rcode= wsrep_innobase_kill_one_trx(bf_thd, int rcode= wsrep_innobase_kill_one_trx(bf_thd,
victim_trx, signal); victim_trx, signal);
lock_sys.mutex_unlock(); lock_sys.mutex_unlock();
victim_trx->mutex.wr_unlock(); victim_trx->mutex_unlock();
DBUG_RETURN(rcode); DBUG_RETURN(rcode);
} else { } else {
wsrep_thd_bf_abort(bf_thd, victim_thd, signal); wsrep_thd_bf_abort(bf_thd, victim_thd, signal);
......
storage/innobase/include/trx0sys.h
View file @ 487fbc2e
...@@ -517,12 +517,12 @@ class rw_trx_hash_t ...@@ -517,12 +517,12 @@ class rw_trx_hash_t
ut_ad(!trx->read_only || !trx->rsegs.m_redo.rseg); ut_ad(!trx->read_only || !trx->rsegs.m_redo.rseg);
ut_ad(!trx_is_autocommit_non_locking(trx)); ut_ad(!trx_is_autocommit_non_locking(trx));
/* trx->state can be anything except TRX_STATE_NOT_STARTED */ /* trx->state can be anything except TRX_STATE_NOT_STARTED */
ut_d(trx->mutex.wr_lock()); ut_d(trx->mutex_lock());
ut_ad(trx_state_eq(trx, TRX_STATE_ACTIVE) || ut_ad(trx_state_eq(trx, TRX_STATE_ACTIVE) ||
trx_state_eq(trx, TRX_STATE_COMMITTED_IN_MEMORY) || trx_state_eq(trx, TRX_STATE_COMMITTED_IN_MEMORY) ||
trx_state_eq(trx, TRX_STATE_PREPARED_RECOVERED) || trx_state_eq(trx, TRX_STATE_PREPARED_RECOVERED) ||
trx_state_eq(trx, TRX_STATE_PREPARED)); trx_state_eq(trx, TRX_STATE_PREPARED));
ut_d(trx->mutex.wr_unlock()); ut_d(trx->mutex_unlock());
} }
......
storage/innobase/include/trx0trx.h
View file @ 487fbc2e
...@@ -667,9 +667,41 @@ struct trx_t : ilist_node<> { ...@@ -667,9 +667,41 @@ struct trx_t : ilist_node<> {
trx_sys_t::deregister_rw(), release_locks(). */ trx_sys_t::deregister_rw(), release_locks(). */
trx_id_t id; trx_id_t id;
private:
/** mutex protecting state and some of lock /** mutex protecting state and some of lock
(some are protected by lock_sys.mutex) */ (some are protected by lock_sys.mutex) */
srw_mutex mutex; srw_mutex mutex;
#ifdef UNIV_DEBUG
/** The owner of mutex (0 if none); protected by mutex */
std::atomic<os_thread_id_t> mutex_owner{0};
#endif /* UNIV_DEBUG */
public:
void mutex_init() { mutex.init(); }
void mutex_destroy() { mutex.destroy(); }
/** Acquire the mutex */
void mutex_lock()
{
ut_ad(!mutex_is_owner());
mutex.wr_lock();
ut_ad(!mutex_owner.exchange(os_thread_get_curr_id(),
std::memory_order_relaxed));
}
/** Release the mutex */
void mutex_unlock()
{
ut_ad(mutex_owner.exchange(0, std::memory_order_relaxed)
== os_thread_get_curr_id());
mutex.wr_unlock();
}
#ifdef UNIV_DEBUG
/** @return whether the current thread holds the mutex */
bool mutex_is_owner() const
{
return mutex_owner.load(std::memory_order_relaxed) ==
os_thread_get_curr_id();
}
#endif /* UNIV_DEBUG */
/** State of the trx from the point of view of concurrency control /** State of the trx from the point of view of concurrency control
and the valid state transitions. and the valid state transitions.
...@@ -1027,6 +1059,7 @@ struct trx_t : ilist_node<> { ...@@ -1027,6 +1059,7 @@ struct trx_t : ilist_node<> {
{ {
ut_ad(state == TRX_STATE_NOT_STARTED); ut_ad(state == TRX_STATE_NOT_STARTED);
ut_ad(!id); ut_ad(!id);
ut_ad(!mutex_is_owner());
ut_ad(!has_logged()); ut_ad(!has_logged());
ut_ad(!is_referenced()); ut_ad(!is_referenced());
ut_ad(!is_wsrep()); ut_ad(!is_wsrep());
......
storage/innobase/lock/lock0lock.cc
View file @ 487fbc2e
...@@ -864,17 +864,12 @@ lock_rec_other_has_expl_req( ...@@ -864,17 +864,12 @@ lock_rec_other_has_expl_req(
#endif /* UNIV_DEBUG */ #endif /* UNIV_DEBUG */
#ifdef WITH_WSREP #ifdef WITH_WSREP
static ATTRIBUTE_COLD
void static void wsrep_kill_victim(const trx_t *trx, const lock_t *lock)
wsrep_kill_victim(
/*==============*/
const trx_t * const trx,
const lock_t *lock)
{ {
lock_sys.mutex_assert_locked(); lock_sys.mutex_assert_locked();
ut_ad(lock->trx->mutex_is_owner());
/* quit for native mysql */ ut_ad(trx->is_wsrep());
if (!trx->is_wsrep()) return;
if (!wsrep_thd_is_BF(trx->mysql_thd, FALSE)) { if (!wsrep_thd_is_BF(trx->mysql_thd, FALSE)) {
return; return;
...@@ -958,12 +953,12 @@ lock_rec_other_has_conflicting( ...@@ -958,12 +953,12 @@ lock_rec_other_has_conflicting(
#ifdef WITH_WSREP #ifdef WITH_WSREP
if (trx->is_wsrep()) { if (trx->is_wsrep()) {
trx_t* lock_trx = lock->trx; trx_t* lock_trx = lock->trx;
lock_trx->mutex.wr_lock(); lock_trx->mutex_lock();
/* Below function will roll back either trx /* Below function will roll back either trx
or lock->trx depending on priority of the or lock->trx depending on priority of the
transaction. */ transaction. */
wsrep_kill_victim(const_cast<trx_t*>(trx), lock); wsrep_kill_victim(trx, lock);
lock_trx->mutex.wr_unlock(); lock_trx->mutex_unlock();
} }
#endif /* WITH_WSREP */ #endif /* WITH_WSREP */
return(lock); return(lock);
...@@ -1104,6 +1099,7 @@ static void lock_set_lock_and_trx_wait(lock_t *lock, trx_t *trx) ...@@ -1104,6 +1099,7 @@ static void lock_set_lock_and_trx_wait(lock_t *lock, trx_t *trx)
ut_ad(!trx->lock.wait_lock || trx->lock.wait_lock != lock); ut_ad(!trx->lock.wait_lock || trx->lock.wait_lock != lock);
ut_ad(!trx->lock.wait_lock || (*trx->lock.wait_lock).trx == trx); ut_ad(!trx->lock.wait_lock || (*trx->lock.wait_lock).trx == trx);
lock_sys.mutex_assert_locked(); lock_sys.mutex_assert_locked();
ut_ad(trx->mutex_is_owner());
trx->lock.wait_lock= lock; trx->lock.wait_lock= lock;
lock->type_mode|= LOCK_WAIT; lock->type_mode|= LOCK_WAIT;
...@@ -1138,6 +1134,7 @@ lock_rec_create_low( ...@@ -1138,6 +1134,7 @@ lock_rec_create_low(
ulint n_bytes; ulint n_bytes;
lock_sys.mutex_assert_locked(); lock_sys.mutex_assert_locked();
ut_ad(holds_trx_mutex == trx->mutex_is_owner());
ut_ad(dict_index_is_clust(index) || !dict_index_is_online_ddl(index)); ut_ad(dict_index_is_clust(index) || !dict_index_is_online_ddl(index));
ut_ad(!(type_mode & LOCK_TABLE)); ut_ad(!(type_mode & LOCK_TABLE));
...@@ -1229,14 +1226,14 @@ lock_rec_create_low( ...@@ -1229,14 +1226,14 @@ lock_rec_create_low(
* if victim was waiting for some other lock * if victim was waiting for some other lock
*/ */
if (holds_trx_mutex) { if (holds_trx_mutex) {
trx->mutex.wr_unlock(); trx->mutex_unlock();
} }
mysql_mutex_lock(&lock_sys.wait_mutex); mysql_mutex_lock(&lock_sys.wait_mutex);
if (holds_trx_mutex) { if (holds_trx_mutex) {
trx->mutex.wr_lock(); trx->mutex_lock();
} }
trx_t *ctrx = c_lock->trx; trx_t *ctrx = c_lock->trx;
ctrx->mutex.wr_lock(); ctrx->mutex_lock();
if (ctrx->lock.wait_thr) { if (ctrx->lock.wait_thr) {
ctrx->lock.was_chosen_as_deadlock_victim = 3; ctrx->lock.was_chosen_as_deadlock_victim = 3;
...@@ -1254,31 +1251,32 @@ lock_rec_create_low( ...@@ -1254,31 +1251,32 @@ lock_rec_create_low(
lock_grant, which wants to grant trx mutex again lock_grant, which wants to grant trx mutex again
*/ */
if (holds_trx_mutex) { if (holds_trx_mutex) {
trx->mutex.wr_unlock(); trx->mutex_unlock();
} }
lock_cancel_waiting_and_release( lock_cancel_waiting_and_release(
ctrx->lock.wait_lock); ctrx->lock.wait_lock);
if (holds_trx_mutex) { if (holds_trx_mutex) {
trx->mutex.wr_lock(); trx->mutex_lock();
} }
ctrx->mutex.wr_unlock(); ctrx->mutex_unlock();
/* have to bail out here to avoid lock_set_lock... */ /* have to bail out here to avoid lock_set_lock... */
mysql_mutex_unlock(&lock_sys.wait_mutex); mysql_mutex_unlock(&lock_sys.wait_mutex);
return(lock); return(lock);
} }
mysql_mutex_unlock(&lock_sys.wait_mutex); mysql_mutex_unlock(&lock_sys.wait_mutex);
ctrx->mutex.wr_unlock(); ctrx->mutex_unlock();
} else } else
#endif /* WITH_WSREP */ #endif /* WITH_WSREP */
HASH_INSERT(lock_t, hash, lock_hash_get(type_mode), HASH_INSERT(lock_t, hash, lock_hash_get(type_mode),
page_id.fold(), lock); page_id.fold(), lock);
if (!holds_trx_mutex) { if (!holds_trx_mutex) {
trx->mutex.wr_lock(); trx->mutex_lock();
} }
ut_ad(trx->mutex_is_owner());
if (type_mode & LOCK_WAIT) { if (type_mode & LOCK_WAIT) {
ut_ad(!trx->lock.wait_lock ut_ad(!trx->lock.wait_lock
|| (*trx->lock.wait_lock).trx == trx); || (*trx->lock.wait_lock).trx == trx);
...@@ -1286,7 +1284,7 @@ lock_rec_create_low( ...@@ -1286,7 +1284,7 @@ lock_rec_create_low(
} }
UT_LIST_ADD_LAST(trx->lock.trx_locks, lock); UT_LIST_ADD_LAST(trx->lock.trx_locks, lock);
if (!holds_trx_mutex) { if (!holds_trx_mutex) {
trx->mutex.wr_unlock(); trx->mutex_unlock();
} }
MONITOR_INC(MONITOR_RECLOCK_CREATED); MONITOR_INC(MONITOR_RECLOCK_CREATED);
MONITOR_INC(MONITOR_NUM_RECLOCK); MONITOR_INC(MONITOR_NUM_RECLOCK);
...@@ -1327,6 +1325,7 @@ lock_rec_enqueue_waiting( ...@@ -1327,6 +1325,7 @@ lock_rec_enqueue_waiting(
ut_ad(dict_index_is_clust(index) || !dict_index_is_online_ddl(index)); ut_ad(dict_index_is_clust(index) || !dict_index_is_online_ddl(index));
trx_t* trx = thr_get_trx(thr); trx_t* trx = thr_get_trx(thr);
ut_ad(trx->mutex_is_owner());
switch (trx_get_dict_operation(trx)) { switch (trx_get_dict_operation(trx)) {
case TRX_DICT_OP_NONE: case TRX_DICT_OP_NONE:
...@@ -1426,6 +1425,7 @@ lock_rec_add_to_queue( ...@@ -1426,6 +1425,7 @@ lock_rec_add_to_queue(
transaction mutex */ transaction mutex */
{ {
lock_sys.mutex_assert_locked(); lock_sys.mutex_assert_locked();
ut_ad(caller_owns_trx_mutex == trx->mutex_is_owner());
ut_ad(index->is_primary() ut_ad(index->is_primary()
|| dict_index_get_online_status(index) != ONLINE_INDEX_CREATION); || dict_index_get_online_status(index) != ONLINE_INDEX_CREATION);
ut_ad(!(type_mode & LOCK_TABLE)); ut_ad(!(type_mode & LOCK_TABLE));
...@@ -1567,7 +1567,7 @@ lock_rec_lock( ...@@ -1567,7 +1567,7 @@ lock_rec_lock(
if (lock_t *lock= lock_sys.get_first(id)) if (lock_t *lock= lock_sys.get_first(id))
{ {
dberr_t err= DB_SUCCESS; dberr_t err= DB_SUCCESS;
trx->mutex.wr_lock(); trx->mutex_lock();
if (lock_rec_get_next_on_page(lock) || if (lock_rec_get_next_on_page(lock) ||
lock->trx != trx || lock->trx != trx ||
lock->type_mode != mode || lock->type_mode != mode ||
...@@ -1613,7 +1613,7 @@ lock_rec_lock( ...@@ -1613,7 +1613,7 @@ lock_rec_lock(
err= DB_SUCCESS_LOCKED_REC; err= DB_SUCCESS_LOCKED_REC;
} }
} }
trx->mutex.wr_unlock(); trx->mutex_unlock();
return err; return err;
} }
else else
...@@ -1721,7 +1721,7 @@ dberr_t lock_wait(que_thr_t *thr) ...@@ -1721,7 +1721,7 @@ dberr_t lock_wait(que_thr_t *thr)
bool had_dict_lock= trx->dict_operation_lock_mode != 0; bool had_dict_lock= trx->dict_operation_lock_mode != 0;
mysql_mutex_lock(&lock_sys.wait_mutex); mysql_mutex_lock(&lock_sys.wait_mutex);
trx->mutex.wr_lock(); trx->mutex_lock();
trx->error_state= DB_SUCCESS; trx->error_state= DB_SUCCESS;
if (!trx->lock.wait_lock) if (!trx->lock.wait_lock)
...@@ -1737,12 +1737,12 @@ dberr_t lock_wait(que_thr_t *thr) ...@@ -1737,12 +1737,12 @@ dberr_t lock_wait(que_thr_t *thr)
} }
mysql_mutex_unlock(&lock_sys.wait_mutex); mysql_mutex_unlock(&lock_sys.wait_mutex);
trx->mutex.wr_unlock(); trx->mutex_unlock();
return trx->error_state; return trx->error_state;
} }
trx->lock.suspend_time= suspend_time; trx->lock.suspend_time= suspend_time;
trx->mutex.wr_unlock(); trx->mutex_unlock();
if (row_lock_wait) if (row_lock_wait)
lock_sys.wait_start(); lock_sys.wait_start();
...@@ -1834,9 +1834,9 @@ dberr_t lock_wait(que_thr_t *thr) ...@@ -1834,9 +1834,9 @@ dberr_t lock_wait(que_thr_t *thr)
mysql_mutex_lock(&lock_sys.wait_mutex); mysql_mutex_lock(&lock_sys.wait_mutex);
if (lock_t *lock= trx->lock.wait_lock) if (lock_t *lock= trx->lock.wait_lock)
{ {
trx->mutex.wr_lock(); trx->mutex_lock();
lock_cancel_waiting_and_release(lock); lock_cancel_waiting_and_release(lock);
trx->mutex.wr_unlock(); trx->mutex_unlock();
} }
} }
mysql_mutex_unlock(&lock_sys.wait_mutex); mysql_mutex_unlock(&lock_sys.wait_mutex);
...@@ -1849,6 +1849,7 @@ dberr_t lock_wait(que_thr_t *thr) ...@@ -1849,6 +1849,7 @@ dberr_t lock_wait(que_thr_t *thr)
static void lock_wait_end(trx_t *trx) static void lock_wait_end(trx_t *trx)
{ {
mysql_mutex_assert_owner(&lock_sys.wait_mutex); mysql_mutex_assert_owner(&lock_sys.wait_mutex);
ut_ad(trx->mutex_is_owner());
ut_ad(trx->state == TRX_STATE_ACTIVE); ut_ad(trx->state == TRX_STATE_ACTIVE);
ut_ad(trx->lock.wait_thr); ut_ad(trx->lock.wait_thr);
...@@ -1868,7 +1869,7 @@ static void lock_grant(lock_t *lock) ...@@ -1868,7 +1869,7 @@ static void lock_grant(lock_t *lock)
mysql_mutex_assert_owner(&lock_sys.wait_mutex); mysql_mutex_assert_owner(&lock_sys.wait_mutex);
lock_reset_lock_and_trx_wait(lock); lock_reset_lock_and_trx_wait(lock);
trx_t *trx= lock->trx; trx_t *trx= lock->trx;
trx->mutex.wr_lock(); trx->mutex_lock();
if (lock->mode() == LOCK_AUTO_INC) if (lock->mode() == LOCK_AUTO_INC)
{ {
dict_table_t *table= lock->un_member.tab_lock.table; dict_table_t *table= lock->un_member.tab_lock.table;
...@@ -1885,7 +1886,7 @@ static void lock_grant(lock_t *lock) ...@@ -1885,7 +1886,7 @@ static void lock_grant(lock_t *lock)
if (trx->lock.wait_thr) if (trx->lock.wait_thr)
lock_wait_end(trx); lock_wait_end(trx);
trx->mutex.wr_unlock(); trx->mutex_unlock();
} }
/*************************************************************//** /*************************************************************//**
...@@ -1911,10 +1912,10 @@ lock_rec_cancel( ...@@ -1911,10 +1912,10 @@ lock_rec_cancel(
/* The following releases the trx from lock wait */ /* The following releases the trx from lock wait */
trx_t *trx = lock->trx; trx_t *trx = lock->trx;
trx->mutex.wr_lock(); trx->mutex_lock();
lock_wait_end(trx); lock_wait_end(trx);
mysql_mutex_unlock(&lock_sys.wait_mutex); mysql_mutex_unlock(&lock_sys.wait_mutex);
trx->mutex.wr_unlock(); trx->mutex_unlock();
} }
/** Remove a record lock request, waiting or granted, from the queue and /** Remove a record lock request, waiting or granted, from the queue and
...@@ -3156,6 +3157,7 @@ lock_table_create( ...@@ -3156,6 +3157,7 @@ lock_table_create(
ut_ad(table && trx); ut_ad(table && trx);
lock_sys.mutex_assert_locked(); lock_sys.mutex_assert_locked();
ut_ad(trx->mutex_is_owner());
check_trx_state(trx); check_trx_state(trx);
...@@ -3210,9 +3212,9 @@ lock_table_create( ...@@ -3210,9 +3212,9 @@ lock_table_create(
ut_list_append(table->locks, lock, TableLockGetNode()); ut_list_append(table->locks, lock, TableLockGetNode());
} }
trx->mutex.wr_unlock(); trx->mutex_unlock();
mysql_mutex_lock(&lock_sys.wait_mutex); mysql_mutex_lock(&lock_sys.wait_mutex);
c_lock->trx->mutex.wr_lock(); c_lock->trx->mutex_lock();
if (c_lock->trx->lock.wait_thr) { if (c_lock->trx->lock.wait_thr) {
c_lock->trx->lock.was_chosen_as_deadlock_victim = TRUE; c_lock->trx->lock.was_chosen_as_deadlock_victim = TRUE;
...@@ -3230,8 +3232,8 @@ lock_table_create( ...@@ -3230,8 +3232,8 @@ lock_table_create(
} }
mysql_mutex_unlock(&lock_sys.wait_mutex); mysql_mutex_unlock(&lock_sys.wait_mutex);
c_lock->trx->mutex.wr_unlock(); c_lock->trx->mutex_unlock();
trx->mutex.wr_lock(); trx->mutex_lock();
} else } else
#endif /* WITH_WSREP */ #endif /* WITH_WSREP */
ut_list_append(table->locks, lock, TableLockGetNode()); ut_list_append(table->locks, lock, TableLockGetNode());
...@@ -3402,12 +3404,11 @@ lock_table_enqueue_waiting( ...@@ -3402,12 +3404,11 @@ lock_table_enqueue_waiting(
#endif #endif
) )
{ {
trx_t* trx;
lock_sys.mutex_assert_locked(); lock_sys.mutex_assert_locked();
ut_ad(!srv_read_only_mode); ut_ad(!srv_read_only_mode);
trx = thr_get_trx(thr); trx_t* trx = thr_get_trx(thr);
ut_ad(trx->mutex_is_owner());
switch (trx_get_dict_operation(trx)) { switch (trx_get_dict_operation(trx)) {
case TRX_DICT_OP_NONE: case TRX_DICT_OP_NONE:
...@@ -3470,21 +3471,23 @@ lock_table_other_has_incompatible( ...@@ -3470,21 +3471,23 @@ lock_table_other_has_incompatible(
lock; lock;
lock = UT_LIST_GET_PREV(un_member.tab_lock.locks, lock)) { lock = UT_LIST_GET_PREV(un_member.tab_lock.locks, lock)) {
if (lock->trx != trx trx_t* lock_trx = lock->trx;
if (lock_trx != trx
&& !lock_mode_compatible(lock->mode(), mode) && !lock_mode_compatible(lock->mode(), mode)
&& (wait || !lock->is_waiting())) { && (wait || !lock->is_waiting())) {
#ifdef WITH_WSREP #ifdef WITH_WSREP
if (lock->trx->is_wsrep()) { if (trx->is_wsrep() && lock_trx->is_wsrep()) {
if (UNIV_UNLIKELY(wsrep_debug)) { if (UNIV_UNLIKELY(wsrep_debug)) {
ib::info() << "WSREP: table lock abort for table:" ib::info() << "WSREP: table lock abort for table:"
<< table->name; << table->name;
ib::info() << " SQL: " ib::info() << " SQL: "
<< wsrep_thd_query(lock->trx->mysql_thd); << wsrep_thd_query(lock->trx->mysql_thd);
} }
lock->trx->mutex.wr_lock(); lock_trx->mutex_lock();
wsrep_kill_victim((trx_t *)trx, (lock_t *)lock); wsrep_kill_victim(trx, lock);
lock->trx->mutex.wr_unlock(); lock_trx->mutex_unlock();
} }
#endif /* WITH_WSREP */ #endif /* WITH_WSREP */
...@@ -3548,7 +3551,7 @@ lock_table( ...@@ -3548,7 +3551,7 @@ lock_table(
wait_for = lock_table_other_has_incompatible( wait_for = lock_table_other_has_incompatible(
trx, LOCK_WAIT, table, mode); trx, LOCK_WAIT, table, mode);
trx->mutex.wr_lock(); trx->mutex_lock();
if (wait_for) { if (wait_for) {
err = lock_table_enqueue_waiting(mode, table, thr err = lock_table_enqueue_waiting(mode, table, thr
...@@ -3562,7 +3565,7 @@ lock_table( ...@@ -3562,7 +3565,7 @@ lock_table(
lock_sys.mutex_unlock(); lock_sys.mutex_unlock();
trx->mutex.wr_unlock(); trx->mutex_unlock();
return(err); return(err);
} }
...@@ -3583,10 +3586,10 @@ void lock_table_resurrect(dict_table_t *table, trx_t *trx, lock_mode mode) ...@@ -3583,10 +3586,10 @@ void lock_table_resurrect(dict_table_t *table, trx_t *trx, lock_mode mode)
LockMutexGuard g; LockMutexGuard g;
ut_ad(!lock_table_other_has_incompatible(trx, LOCK_WAIT, table, mode)); ut_ad(!lock_table_other_has_incompatible(trx, LOCK_WAIT, table, mode));
trx->mutex.wr_lock(); trx->mutex_lock();
lock_table_create(table, mode, trx); lock_table_create(table, mode, trx);
} }
trx->mutex.wr_unlock(); trx->mutex_unlock();
} }
/*********************************************************************//** /*********************************************************************//**
...@@ -3885,6 +3888,7 @@ void lock_release(trx_t* trx) ...@@ -3885,6 +3888,7 @@ void lock_release(trx_t* trx)
ulint count = 0; ulint count = 0;
trx_id_t max_trx_id = trx_sys.get_max_trx_id(); trx_id_t max_trx_id = trx_sys.get_max_trx_id();
ut_ad(!trx->mutex_is_owner());
LockMutexGuard g; LockMutexGuard g;
for (lock_t* lock = UT_LIST_GET_LAST(trx->lock.trx_locks); for (lock_t* lock = UT_LIST_GET_LAST(trx->lock.trx_locks);
...@@ -3938,8 +3942,9 @@ lock_trx_table_locks_remove( ...@@ -3938,8 +3942,9 @@ lock_trx_table_locks_remove(
/* It is safe to read this because we are holding the lock mutex */ /* It is safe to read this because we are holding the lock mutex */
const bool have_mutex = trx->lock.cancel; const bool have_mutex = trx->lock.cancel;
if (!have_mutex) { if (!have_mutex) {
trx->mutex.wr_lock(); trx->mutex_lock();
} }
ut_ad(trx->mutex_is_owner());
for (lock_list::iterator it = trx->lock.table_locks.begin(), for (lock_list::iterator it = trx->lock.table_locks.begin(),
end = trx->lock.table_locks.end(); it != end; ++it) { end = trx->lock.table_locks.end(); it != end; ++it) {
...@@ -3953,7 +3958,7 @@ lock_trx_table_locks_remove( ...@@ -3953,7 +3958,7 @@ lock_trx_table_locks_remove(
*it = NULL; *it = NULL;
if (!have_mutex) { if (!have_mutex) {
trx->mutex.wr_unlock(); trx->mutex_unlock();
} }
return; return;
...@@ -4309,6 +4314,8 @@ lock_trx_table_locks_find( ...@@ -4309,6 +4314,8 @@ lock_trx_table_locks_find(
{ {
bool found = false; bool found = false;
ut_ad(trx->mutex_is_owner());
for (lock_list::const_iterator it = trx->lock.table_locks.begin(), for (lock_list::const_iterator it = trx->lock.table_locks.begin(),
end = trx->lock.table_locks.end(); it != end; ++it) { end = trx->lock.table_locks.end(); it != end; ++it) {
...@@ -4353,7 +4360,7 @@ lock_table_queue_validate( ...@@ -4353,7 +4360,7 @@ lock_table_queue_validate(
/* lock->trx->state cannot change from or to NOT_STARTED /* lock->trx->state cannot change from or to NOT_STARTED
while we are holding the lock_sys.mutex. It may change while we are holding the lock_sys.mutex. It may change
from ACTIVE or PREPARED to PREPARED or COMMITTED. */ from ACTIVE or PREPARED to PREPARED or COMMITTED. */
lock->trx->mutex.wr_lock(); lock->trx->mutex_lock();
check_trx_state(lock->trx); check_trx_state(lock->trx);
if (lock->trx->state == TRX_STATE_COMMITTED_IN_MEMORY) { if (lock->trx->state == TRX_STATE_COMMITTED_IN_MEMORY) {
...@@ -4366,7 +4373,7 @@ lock_table_queue_validate( ...@@ -4366,7 +4373,7 @@ lock_table_queue_validate(
} }
ut_a(lock_trx_table_locks_find(lock->trx, lock)); ut_a(lock_trx_table_locks_find(lock->trx, lock));
lock->trx->mutex.wr_unlock(); lock->trx->mutex_unlock();
} }
return(TRUE); return(TRUE);
...@@ -4416,13 +4423,13 @@ lock_rec_queue_validate( ...@@ -4416,13 +4423,13 @@ lock_rec_queue_validate(
ut_ad(!index || lock->index == index); ut_ad(!index || lock->index == index);
lock->trx->mutex.wr_lock(); lock->trx->mutex_lock();
ut_ad(!trx_is_ac_nl_ro(lock->trx)); ut_ad(!trx_is_ac_nl_ro(lock->trx));
ut_ad(trx_state_eq(lock->trx, ut_ad(trx_state_eq(lock->trx,
TRX_STATE_COMMITTED_IN_MEMORY) TRX_STATE_COMMITTED_IN_MEMORY)
|| !lock->is_waiting() || !lock->is_waiting()
|| lock_rec_has_to_wait_in_queue(lock)); || lock_rec_has_to_wait_in_queue(lock));
lock->trx->mutex.wr_unlock(); lock->trx->mutex_unlock();
} }
func_exit: func_exit:
...@@ -4446,7 +4453,7 @@ lock_rec_queue_validate( ...@@ -4446,7 +4453,7 @@ lock_rec_queue_validate(
/* impl_trx could have been committed before we /* impl_trx could have been committed before we
acquire its mutex, but not thereafter. */ acquire its mutex, but not thereafter. */
impl_trx->mutex.wr_lock(); impl_trx->mutex_lock();
ut_ad(impl_trx->state != TRX_STATE_NOT_STARTED); ut_ad(impl_trx->state != TRX_STATE_NOT_STARTED);
if (impl_trx->state == TRX_STATE_COMMITTED_IN_MEMORY) { if (impl_trx->state == TRX_STATE_COMMITTED_IN_MEMORY) {
} else if (const lock_t* other_lock } else if (const lock_t* other_lock
...@@ -4497,7 +4504,7 @@ lock_rec_queue_validate( ...@@ -4497,7 +4504,7 @@ lock_rec_queue_validate(
} }
} }
impl_trx->mutex.wr_unlock(); impl_trx->mutex_unlock();
} }
for (lock = lock_rec_get_first(&lock_sys.rec_hash, block, heap_no); for (lock = lock_rec_get_first(&lock_sys.rec_hash, block, heap_no);
...@@ -4850,7 +4857,7 @@ lock_rec_insert_check_and_lock( ...@@ -4850,7 +4857,7 @@ lock_rec_insert_check_and_lock(
lock_t* c_lock = lock_t* c_lock =
#endif /* WITH_WSREP */ #endif /* WITH_WSREP */
lock_rec_other_has_conflicting(type_mode, block, heap_no, trx)) { lock_rec_other_has_conflicting(type_mode, block, heap_no, trx)) {
trx->mutex.wr_lock(); trx->mutex_lock();
err = lock_rec_enqueue_waiting( err = lock_rec_enqueue_waiting(
#ifdef WITH_WSREP #ifdef WITH_WSREP
...@@ -4858,7 +4865,7 @@ lock_rec_insert_check_and_lock( ...@@ -4858,7 +4865,7 @@ lock_rec_insert_check_and_lock(
#endif /* WITH_WSREP */ #endif /* WITH_WSREP */
type_mode, block, heap_no, index, thr, NULL); type_mode, block, heap_no, index, thr, NULL);
trx->mutex.wr_unlock(); trx->mutex_unlock();
} else { } else {
err = DB_SUCCESS; err = DB_SUCCESS;
} }
...@@ -4925,7 +4932,7 @@ lock_rec_convert_impl_to_expl_for_trx( ...@@ -4925,7 +4932,7 @@ lock_rec_convert_impl_to_expl_for_trx(
DEBUG_SYNC_C("before_lock_rec_convert_impl_to_expl_for_trx"); DEBUG_SYNC_C("before_lock_rec_convert_impl_to_expl_for_trx");
lock_sys.mutex_lock(); lock_sys.mutex_lock();
trx->mutex.wr_lock(); trx->mutex_lock();
ut_ad(!trx_state_eq(trx, TRX_STATE_NOT_STARTED)); ut_ad(!trx_state_eq(trx, TRX_STATE_NOT_STARTED));
if (!trx_state_eq(trx, TRX_STATE_COMMITTED_IN_MEMORY) if (!trx_state_eq(trx, TRX_STATE_COMMITTED_IN_MEMORY)
...@@ -4936,7 +4943,7 @@ lock_rec_convert_impl_to_expl_for_trx( ...@@ -4936,7 +4943,7 @@ lock_rec_convert_impl_to_expl_for_trx(
} }
lock_sys.mutex_unlock(); lock_sys.mutex_unlock();
trx->mutex.wr_unlock(); trx->mutex_unlock();
trx->release_reference(); trx->release_reference();
DEBUG_SYNC_C("after_lock_rec_convert_impl_to_expl_for_trx"); DEBUG_SYNC_C("after_lock_rec_convert_impl_to_expl_for_trx");
...@@ -4959,7 +4966,7 @@ static my_bool lock_rec_other_trx_holds_expl_callback( ...@@ -4959,7 +4966,7 @@ static my_bool lock_rec_other_trx_holds_expl_callback(
mysql_mutex_lock(&element->mutex); mysql_mutex_lock(&element->mutex);
if (element->trx) if (element->trx)
{ {
element->trx->mutex.wr_lock(); element->trx->mutex_lock();
ut_ad(element->trx->state != TRX_STATE_NOT_STARTED); ut_ad(element->trx->state != TRX_STATE_NOT_STARTED);
lock_t *expl_lock= element->trx->state == TRX_STATE_COMMITTED_IN_MEMORY lock_t *expl_lock= element->trx->state == TRX_STATE_COMMITTED_IN_MEMORY
? NULL : lock_rec_has_expl(LOCK_S | LOCK_REC_NOT_GAP, arg->block, ? NULL : lock_rec_has_expl(LOCK_S | LOCK_REC_NOT_GAP, arg->block,
...@@ -4969,7 +4976,7 @@ static my_bool lock_rec_other_trx_holds_expl_callback( ...@@ -4969,7 +4976,7 @@ static my_bool lock_rec_other_trx_holds_expl_callback(
lock. lock.
*/ */
ut_ad(!expl_lock || expl_lock->trx == arg->impl_trx); ut_ad(!expl_lock || expl_lock->trx == arg->impl_trx);
element->trx->mutex.wr_unlock(); element->trx->mutex_unlock();
} }
mysql_mutex_unlock(&element->mutex); mysql_mutex_unlock(&element->mutex);
return 0; return 0;
...@@ -5520,6 +5527,7 @@ void lock_cancel_waiting_and_release(lock_t *lock) ...@@ -5520,6 +5527,7 @@ void lock_cancel_waiting_and_release(lock_t *lock)
mysql_mutex_assert_owner(&lock_sys.wait_mutex); mysql_mutex_assert_owner(&lock_sys.wait_mutex);
trx_t *trx= lock->trx; trx_t *trx= lock->trx;
ut_ad(trx->state == TRX_STATE_ACTIVE); ut_ad(trx->state == TRX_STATE_ACTIVE);
ut_ad(trx->mutex_is_owner());
trx->lock.cancel= true; trx->lock.cancel= true;
...@@ -5552,6 +5560,7 @@ lock_unlock_table_autoinc( ...@@ -5552,6 +5560,7 @@ lock_unlock_table_autoinc(
trx_t* trx) /*!< in/out: transaction */ trx_t* trx) /*!< in/out: transaction */
{ {
lock_sys.mutex_assert_unlocked(); lock_sys.mutex_assert_unlocked();
ut_ad(!trx->mutex_is_owner());
ut_ad(!trx->lock.wait_lock); ut_ad(!trx->lock.wait_lock);
/* This can be invoked on NOT_STARTED, ACTIVE, PREPARED, /* This can be invoked on NOT_STARTED, ACTIVE, PREPARED,
...@@ -5574,6 +5583,7 @@ static inline dberr_t lock_trx_handle_wait_low(trx_t* trx) ...@@ -5574,6 +5583,7 @@ static inline dberr_t lock_trx_handle_wait_low(trx_t* trx)
{ {
lock_sys.mutex_assert_locked(); lock_sys.mutex_assert_locked();
mysql_mutex_assert_owner(&lock_sys.wait_mutex); mysql_mutex_assert_owner(&lock_sys.wait_mutex);
ut_ad(trx->mutex_is_owner());
if (trx->lock.was_chosen_as_deadlock_victim) if (trx->lock.was_chosen_as_deadlock_victim)
return DB_DEADLOCK; return DB_DEADLOCK;
...@@ -5603,11 +5613,11 @@ lock_trx_handle_wait( ...@@ -5603,11 +5613,11 @@ lock_trx_handle_wait(
{ {
LockMutexGuard g; LockMutexGuard g;
mysql_mutex_lock(&lock_sys.wait_mutex); mysql_mutex_lock(&lock_sys.wait_mutex);
trx->mutex.wr_lock(); trx->mutex_lock();
err= lock_trx_handle_wait_low(trx); err= lock_trx_handle_wait_low(trx);
} }
mysql_mutex_unlock(&lock_sys.wait_mutex); mysql_mutex_unlock(&lock_sys.wait_mutex);
trx->mutex.wr_unlock(); trx->mutex_unlock();
return err; return err;
} }
...@@ -5645,7 +5655,7 @@ static my_bool lock_table_locks_lookup(rw_trx_hash_element_t *element, ...@@ -5645,7 +5655,7 @@ static my_bool lock_table_locks_lookup(rw_trx_hash_element_t *element,
mysql_mutex_lock(&element->mutex); mysql_mutex_lock(&element->mutex);
if (element->trx) if (element->trx)
{ {
element->trx->mutex.wr_lock(); element->trx->mutex_lock();
check_trx_state(element->trx); check_trx_state(element->trx);
if (element->trx->state != TRX_STATE_COMMITTED_IN_MEMORY) if (element->trx->state != TRX_STATE_COMMITTED_IN_MEMORY)
{ {
...@@ -5664,7 +5674,7 @@ static my_bool lock_table_locks_lookup(rw_trx_hash_element_t *element, ...@@ -5664,7 +5674,7 @@ static my_bool lock_table_locks_lookup(rw_trx_hash_element_t *element,
ut_ad(lock->un_member.tab_lock.table != table); ut_ad(lock->un_member.tab_lock.table != table);
} }
} }
element->trx->mutex.wr_unlock(); element->trx->mutex_unlock();
} }
mysql_mutex_unlock(&element->mutex); mysql_mutex_unlock(&element->mutex);
return 0; return 0;
...@@ -6055,9 +6065,7 @@ have been granted its lock by the deadlock checks. ...@@ -6055,9 +6065,7 @@ have been granted its lock by the deadlock checks.
inline trx_t* DeadlockChecker::search() inline trx_t* DeadlockChecker::search()
{ {
lock_sys.mutex_assert_locked(); lock_sys.mutex_assert_locked();
ut_ad(!m_start->mutex_is_owner());
ut_ad(m_start != NULL);
ut_ad(m_wait_lock != NULL);
check_trx_state(m_wait_lock->trx); check_trx_state(m_wait_lock->trx);
ut_ad(m_mark_start <= s_lock_mark_counter); ut_ad(m_mark_start <= s_lock_mark_counter);
...@@ -6200,6 +6208,7 @@ We will attempt to resolve all deadlocks. ...@@ -6200,6 +6208,7 @@ We will attempt to resolve all deadlocks.
@return whether the transaction was chosen as victim */ @return whether the transaction was chosen as victim */
inline bool DeadlockChecker::check_and_resolve(trx_t *trx) inline bool DeadlockChecker::check_and_resolve(trx_t *trx)
{ {
ut_ad(!trx->mutex_is_owner());
ut_ad(trx->state == TRX_STATE_ACTIVE); ut_ad(trx->state == TRX_STATE_ACTIVE);
ut_ad(!srv_read_only_mode); ut_ad(!srv_read_only_mode);
...@@ -6247,13 +6256,13 @@ inline bool DeadlockChecker::check_and_resolve(trx_t *trx) ...@@ -6247,13 +6256,13 @@ inline bool DeadlockChecker::check_and_resolve(trx_t *trx)
else else
{ {
mysql_mutex_lock(&lock_sys.wait_mutex); mysql_mutex_lock(&lock_sys.wait_mutex);
victim_trx->mutex.wr_lock(); victim_trx->mutex_lock();
const auto state= victim_trx->state; const auto state= victim_trx->state;
if (state != TRX_STATE_ACTIVE) if (state != TRX_STATE_ACTIVE)
{ {
ut_ad(state == TRX_STATE_COMMITTED_IN_MEMORY); ut_ad(state == TRX_STATE_COMMITTED_IN_MEMORY);
mysql_mutex_unlock(&lock_sys.wait_mutex); mysql_mutex_unlock(&lock_sys.wait_mutex);
victim_trx->mutex.wr_unlock(); victim_trx->mutex_unlock();
return false; return false;
} }
print("*** WE ROLL BACK TRANSACTION (1)\n"); print("*** WE ROLL BACK TRANSACTION (1)\n");
...@@ -6261,7 +6270,7 @@ inline bool DeadlockChecker::check_and_resolve(trx_t *trx) ...@@ -6261,7 +6270,7 @@ inline bool DeadlockChecker::check_and_resolve(trx_t *trx)
IF_WSREP(.fetch_or(1),= true); IF_WSREP(.fetch_or(1),= true);
lock_cancel_waiting_and_release(victim_trx->lock.wait_lock); lock_cancel_waiting_and_release(victim_trx->lock.wait_lock);
mysql_mutex_unlock(&lock_sys.wait_mutex); mysql_mutex_unlock(&lock_sys.wait_mutex);
victim_trx->mutex.wr_unlock(); victim_trx->mutex_unlock();
} }
lock_sys.deadlocks++; lock_sys.deadlocks++;
break; break;
......
storage/innobase/lock/lock0prdt.cc
View file @ 487fbc2e
...@@ -436,6 +436,7 @@ lock_prdt_add_to_queue( ...@@ -436,6 +436,7 @@ lock_prdt_add_to_queue(
{ {
const page_id_t id{block->page.id()}; const page_id_t id{block->page.id()};
lock_sys.mutex_assert_locked(); lock_sys.mutex_assert_locked();
ut_ad(caller_owns_trx_mutex == trx->mutex_is_owner());
ut_ad(index->is_spatial()); ut_ad(index->is_spatial());
ut_ad(!dict_index_is_online_ddl(index)); ut_ad(!dict_index_is_online_ddl(index));
ut_ad(type_mode & (LOCK_PREDICATE | LOCK_PRDT_PAGE)); ut_ad(type_mode & (LOCK_PREDICATE | LOCK_PRDT_PAGE));
...@@ -555,7 +556,7 @@ lock_prdt_insert_check_and_lock( ...@@ -555,7 +556,7 @@ lock_prdt_insert_check_and_lock(
lock_init_prdt_from_mbr(prdt, mbr, 0, trx->lock.lock_heap); lock_init_prdt_from_mbr(prdt, mbr, 0, trx->lock.lock_heap);
/* Note that we may get DB_SUCCESS also here! */ /* Note that we may get DB_SUCCESS also here! */
trx->mutex.wr_lock(); trx->mutex_lock();
err = lock_rec_enqueue_waiting( err = lock_rec_enqueue_waiting(
#ifdef WITH_WSREP #ifdef WITH_WSREP
...@@ -564,7 +565,7 @@ lock_prdt_insert_check_and_lock( ...@@ -564,7 +565,7 @@ lock_prdt_insert_check_and_lock(
LOCK_X | LOCK_PREDICATE | LOCK_INSERT_INTENTION, LOCK_X | LOCK_PREDICATE | LOCK_INSERT_INTENTION,
block, PRDT_HEAPNO, index, thr, prdt); block, PRDT_HEAPNO, index, thr, prdt);
trx->mutex.wr_unlock(); trx->mutex_unlock();
} else { } else {
err = DB_SUCCESS; err = DB_SUCCESS;
} }
...@@ -789,7 +790,7 @@ lock_prdt_lock( ...@@ -789,7 +790,7 @@ lock_prdt_lock(
|| ((type_mode & LOCK_PREDICATE) || ((type_mode & LOCK_PREDICATE)
&& (!lock_prdt_consistent( && (!lock_prdt_consistent(
lock_get_prdt_from_lock(lock), prdt, 0)))) { lock_get_prdt_from_lock(lock), prdt, 0)))) {
trx->mutex.wr_lock(); trx->mutex_lock();
lock = lock_prdt_has_lock( lock = lock_prdt_has_lock(
mode, type_mode, block, prdt, trx); mode, type_mode, block, prdt, trx);
...@@ -821,7 +822,7 @@ lock_prdt_lock( ...@@ -821,7 +822,7 @@ lock_prdt_lock(
} }
} }
trx->mutex.wr_unlock(); trx->mutex_unlock();
} else { } else {
if (!lock_rec_get_nth_bit(lock, PRDT_HEAPNO)) { if (!lock_rec_get_nth_bit(lock, PRDT_HEAPNO)) {
lock_rec_set_nth_bit(lock, PRDT_HEAPNO); lock_rec_set_nth_bit(lock, PRDT_HEAPNO);
......
storage/innobase/que/que0que.cc
View file @ 487fbc2e
...@@ -177,7 +177,7 @@ que_fork_scheduler_round_robin( ...@@ -177,7 +177,7 @@ que_fork_scheduler_round_robin(
que_fork_t* fork, /*!< in: a query fork */ que_fork_t* fork, /*!< in: a query fork */
que_thr_t* thr) /*!< in: current pos */ que_thr_t* thr) /*!< in: current pos */
{ {
fork->trx->mutex.wr_lock(); fork->trx->mutex_lock();
/* If no current, start first available. */ /* If no current, start first available. */
if (thr == NULL) { if (thr == NULL) {
...@@ -195,7 +195,7 @@ que_fork_scheduler_round_robin( ...@@ -195,7 +195,7 @@ que_fork_scheduler_round_robin(
que_thr_init_command(thr); que_thr_init_command(thr);
} }
fork->trx->mutex.wr_unlock(); fork->trx->mutex_unlock();
return(thr); return(thr);
} }
...@@ -466,14 +466,14 @@ que_thr_node_step( ...@@ -466,14 +466,14 @@ que_thr_node_step(
} }
trx_t *trx= thr->graph->trx; trx_t *trx= thr->graph->trx;
trx->mutex.wr_lock(); trx->mutex_lock();
if (!trx->lock.wait_thr && thr->graph->state == QUE_FORK_ACTIVE) { if (!trx->lock.wait_thr && thr->graph->state == QUE_FORK_ACTIVE) {
thr->state = QUE_THR_COMPLETED; thr->state = QUE_THR_COMPLETED;
thr = NULL; thr = NULL;
} }
trx->mutex.wr_unlock(); trx->mutex_unlock();
return(thr); return(thr);
} }
...@@ -688,18 +688,14 @@ que_run_threads_low( ...@@ -688,18 +688,14 @@ que_run_threads_low(
/*================*/ /*================*/
que_thr_t* thr) /*!< in: query thread */ que_thr_t* thr) /*!< in: query thread */
{ {
trx_t* trx;
que_thr_t* next_thr;
ut_ad(thr->state == QUE_THR_RUNNING); ut_ad(thr->state == QUE_THR_RUNNING);
ut_a(thr_get_trx(thr)->error_state == DB_SUCCESS);
/* cumul_resource counts how much resources the OS thread (NOT the /* cumul_resource counts how much resources the OS thread (NOT the
query thread) has spent in this function */ query thread) has spent in this function */
trx = thr_get_trx(thr); for (trx_t* trx = thr_get_trx(thr);;) {
ut_ad(!trx->mutex_is_owner());
do { ut_a(trx->error_state == DB_SUCCESS);
/* Check that there is enough space in the log to accommodate /* Check that there is enough space in the log to accommodate
possible log entries by this query step; if the operation can possible log entries by this query step; if the operation can
touch more than about 4 pages, checks must be made also within touch more than about 4 pages, checks must be made also within
...@@ -710,17 +706,14 @@ que_run_threads_low( ...@@ -710,17 +706,14 @@ que_run_threads_low(
/* Perform the actual query step: note that the query thread /* Perform the actual query step: note that the query thread
may change if, e.g., a subprocedure call is made */ may change if, e.g., a subprocedure call is made */
/*-------------------------*/ que_thr_t* next_thr = que_thr_step(thr);
next_thr = que_thr_step(thr); ut_ad(trx == thr_get_trx(thr));
/*-------------------------*/ if (!next_thr) {
return;
if (next_thr) {
ut_a(trx->error_state == DB_SUCCESS);
ut_a(next_thr == thr);
} }
ut_ad(trx == thr_get_trx(thr)); ut_a(next_thr == thr);
} while (next_thr != NULL); }
} }
/**********************************************************************//** /**********************************************************************//**
......
storage/innobase/row/row0vers.cc
View file @ 487fbc2e
...@@ -193,10 +193,10 @@ row_vers_impl_x_locked_low( ...@@ -193,10 +193,10 @@ row_vers_impl_x_locked_low(
heap, &prev_version, NULL, heap, &prev_version, NULL,
dict_index_has_virtual(index) ? &vrow : NULL, 0); dict_index_has_virtual(index) ? &vrow : NULL, 0);
ut_d(trx->mutex.wr_lock()); ut_d(trx->mutex_lock());
const bool committed = trx_state_eq( const bool committed = trx_state_eq(
trx, TRX_STATE_COMMITTED_IN_MEMORY); trx, TRX_STATE_COMMITTED_IN_MEMORY);
ut_d(trx->mutex.wr_unlock()); ut_d(trx->mutex_unlock());
/* The oldest visible clustered index version must not be /* The oldest visible clustered index version must not be
delete-marked, because we never start a transaction by delete-marked, because we never start a transaction by
......
storage/innobase/trx/trx0roll.cc
View file @ 487fbc2e
...@@ -155,6 +155,7 @@ inline void trx_t::rollback_low(trx_savept_t *savept) ...@@ -155,6 +155,7 @@ inline void trx_t::rollback_low(trx_savept_t *savept)
@return error code or DB_SUCCESS */ @return error code or DB_SUCCESS */
dberr_t trx_t::rollback(trx_savept_t *savept) dberr_t trx_t::rollback(trx_savept_t *savept)
{ {
ut_ad(!mutex_is_owner());
if (state == TRX_STATE_NOT_STARTED) if (state == TRX_STATE_NOT_STARTED)
{ {
error_state= DB_SUCCESS; error_state= DB_SUCCESS;
...@@ -724,10 +725,10 @@ static my_bool trx_rollback_recovered_callback(rw_trx_hash_element_t *element, ...@@ -724,10 +725,10 @@ static my_bool trx_rollback_recovered_callback(rw_trx_hash_element_t *element,
mysql_mutex_lock(&element->mutex); mysql_mutex_lock(&element->mutex);
if (trx_t *trx= element->trx) if (trx_t *trx= element->trx)
{ {
trx->mutex.wr_lock(); trx->mutex_lock();
if (trx_state_eq(trx, TRX_STATE_ACTIVE) && trx->is_recovered) if (trx_state_eq(trx, TRX_STATE_ACTIVE) && trx->is_recovered)
trx_list->push_back(trx); trx_list->push_back(trx);
trx->mutex.wr_unlock(); trx->mutex_unlock();
} }
mysql_mutex_unlock(&element->mutex); mysql_mutex_unlock(&element->mutex);
return 0; return 0;
...@@ -769,10 +770,10 @@ void trx_rollback_recovered(bool all) ...@@ -769,10 +770,10 @@ void trx_rollback_recovered(bool all)
trx_list.pop_back(); trx_list.pop_back();
ut_ad(trx); ut_ad(trx);
ut_d(trx->mutex.wr_lock()); ut_d(trx->mutex_lock());
ut_ad(trx->is_recovered); ut_ad(trx->is_recovered);
ut_ad(trx_state_eq(trx, TRX_STATE_ACTIVE)); ut_ad(trx_state_eq(trx, TRX_STATE_ACTIVE));
ut_d(trx->mutex.wr_unlock()); ut_d(trx->mutex_unlock());
if (srv_shutdown_state != SRV_SHUTDOWN_NONE && !srv_undo_sources && if (srv_shutdown_state != SRV_SHUTDOWN_NONE && !srv_undo_sources &&
srv_fast_shutdown) srv_fast_shutdown)
...@@ -866,6 +867,7 @@ trx_roll_graph_build( ...@@ -866,6 +867,7 @@ trx_roll_graph_build(
que_fork_t* fork; que_fork_t* fork;
que_thr_t* thr; que_thr_t* thr;
ut_ad(trx->mutex_is_owner());
heap = mem_heap_create(512); heap = mem_heap_create(512);
fork = que_fork_create(heap); fork = que_fork_create(heap);
fork->trx = trx; fork->trx = trx;
...@@ -892,6 +894,7 @@ trx_rollback_start( ...@@ -892,6 +894,7 @@ trx_rollback_start(
{ {
/* Initialize the rollback field in the transaction */ /* Initialize the rollback field in the transaction */
ut_ad(trx->mutex_is_owner());
ut_ad(!trx->roll_limit); ut_ad(!trx->roll_limit);
ut_ad(!trx->in_rollback); ut_ad(!trx->in_rollback);
...@@ -960,13 +963,13 @@ trx_rollback_step( ...@@ -960,13 +963,13 @@ trx_rollback_step(
roll_limit = node->savept ? node->savept->least_undo_no : 0; roll_limit = node->savept ? node->savept->least_undo_no : 0;
trx->mutex.wr_lock(); trx->mutex_lock();
trx_commit_or_rollback_prepare(trx); trx_commit_or_rollback_prepare(trx);
node->undo_thr = trx_rollback_start(trx, roll_limit); node->undo_thr = trx_rollback_start(trx, roll_limit);
trx->mutex.wr_unlock(); trx->mutex_unlock();
} else { } else {
ut_ad(node->state == ROLL_NODE_WAIT); ut_ad(node->state == ROLL_NODE_WAIT);
......
storage/innobase/trx/trx0trx.cc
View file @ 487fbc2e
...@@ -195,7 +195,7 @@ struct TrxFactory { ...@@ -195,7 +195,7 @@ struct TrxFactory {
trx->trx_savepoints, trx->trx_savepoints,
&trx_named_savept_t::trx_savepoints); &trx_named_savept_t::trx_savepoints);
trx->mutex.init(); trx->mutex_init();
} }
/** Release resources held by the transaction object. /** Release resources held by the transaction object.
...@@ -234,7 +234,7 @@ struct TrxFactory { ...@@ -234,7 +234,7 @@ struct TrxFactory {
UT_DELETE(trx->xid); UT_DELETE(trx->xid);
ut_free(trx->detailed_error); ut_free(trx->detailed_error);
trx->mutex.destroy(); trx->mutex_destroy();
trx->mod_tables.~trx_mod_tables_t(); trx->mod_tables.~trx_mod_tables_t();
...@@ -1946,9 +1946,9 @@ trx_prepare( ...@@ -1946,9 +1946,9 @@ trx_prepare(
DBUG_EXECUTE_IF("ib_trx_crash_during_xa_prepare_step", DBUG_SUICIDE();); DBUG_EXECUTE_IF("ib_trx_crash_during_xa_prepare_step", DBUG_SUICIDE(););
ut_a(trx->state == TRX_STATE_ACTIVE); ut_a(trx->state == TRX_STATE_ACTIVE);
trx->mutex.wr_lock(); trx->mutex_lock();
trx->state = TRX_STATE_PREPARED; trx->state = TRX_STATE_PREPARED;
trx->mutex.wr_unlock(); trx->mutex_unlock();
if (lsn) { if (lsn) {
/* Depending on the my.cnf options, we may now write the log /* Depending on the my.cnf options, we may now write the log
...@@ -2090,7 +2090,7 @@ static my_bool trx_get_trx_by_xid_callback(rw_trx_hash_element_t *element, ...@@ -2090,7 +2090,7 @@ static my_bool trx_get_trx_by_xid_callback(rw_trx_hash_element_t *element,
mysql_mutex_lock(&element->mutex); mysql_mutex_lock(&element->mutex);
if (trx_t *trx= element->trx) if (trx_t *trx= element->trx)
{ {
trx->mutex.wr_lock(); trx->mutex_lock();
if (trx->is_recovered && if (trx->is_recovered &&
(trx_state_eq(trx, TRX_STATE_PREPARED) || (trx_state_eq(trx, TRX_STATE_PREPARED) ||
trx_state_eq(trx, TRX_STATE_PREPARED_RECOVERED)) && trx_state_eq(trx, TRX_STATE_PREPARED_RECOVERED)) &&
...@@ -2107,7 +2107,7 @@ static my_bool trx_get_trx_by_xid_callback(rw_trx_hash_element_t *element, ...@@ -2107,7 +2107,7 @@ static my_bool trx_get_trx_by_xid_callback(rw_trx_hash_element_t *element,
arg->trx= trx; arg->trx= trx;
found= 1; found= 1;
} }
trx->mutex.wr_unlock(); trx->mutex_unlock();
} }
mysql_mutex_unlock(&element->mutex); mysql_mutex_unlock(&element->mutex);
return found; return found;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7