diff options
Diffstat (limited to 'storage/innobase/lock/lock0lock.cc')
| -rw-r--r-- | storage/innobase/lock/lock0lock.cc | 7021 |
1 files changed, 3318 insertions, 3703 deletions
diff --git a/storage/innobase/lock/lock0lock.cc b/storage/innobase/lock/lock0lock.cc index 8fedd8a68d6..3c7c3d348af 100644 --- a/storage/innobase/lock/lock0lock.cc +++ b/storage/innobase/lock/lock0lock.cc @@ -29,6 +29,7 @@ Created 5/7/1996 Heikki Tuuri #include "univ.i" #include <mysql/service_thd_error_context.h> +#include <mysql/service_thd_wait.h> #include <sql_class.h> #include "lock0lock.h" @@ -42,6 +43,10 @@ Created 5/7/1996 Heikki Tuuri #include "row0mysql.h" #include "row0vers.h" #include "pars0pars.h" +#include "srv0mon.h" +#include "que0que.h" +#include "scope.h" +#include <debug_sync.h> #include <set> @@ -49,272 +54,283 @@ Created 5/7/1996 Heikki Tuuri #include <mysql/service_wsrep.h> #endif /* WITH_WSREP */ -/** Lock scheduling algorithm */ -ulong innodb_lock_schedule_algorithm; - /** The value of innodb_deadlock_detect */ -my_bool innobase_deadlock_detect; - -/*********************************************************************//** -Checks if a waiting record lock request still has to wait in a queue. -@return lock that is causing the wait */ -static -const lock_t* -lock_rec_has_to_wait_in_queue( -/*==========================*/ - const lock_t* wait_lock); /*!< in: waiting record lock */ - -/** Grant a lock to a waiting lock request and release the waiting transaction -after lock_reset_lock_and_trx_wait() has been called. */ -static void lock_grant_after_reset(lock_t* lock); +my_bool innodb_deadlock_detect; +/** The value of innodb_deadlock_report */ +ulong innodb_deadlock_report; +#ifdef HAVE_REPLICATION extern "C" void thd_rpl_deadlock_check(MYSQL_THD thd, MYSQL_THD other_thd); extern "C" int thd_need_wait_reports(const MYSQL_THD thd); extern "C" int thd_need_ordering_with(const MYSQL_THD thd, const MYSQL_THD other_thd); +#endif -/** Pretty-print a table lock. -@param[in,out] file output stream -@param[in] lock table lock */ -static void lock_table_print(FILE* file, const lock_t* lock); - -/** Pretty-print a record lock. -@param[in,out] file output stream -@param[in] lock record lock -@param[in,out] mtr mini-transaction for accessing the record */ -static void lock_rec_print(FILE* file, const lock_t* lock, mtr_t& mtr); - -/** Deadlock checker. */ -class DeadlockChecker { -public: - /** Check if a joining lock request results in a deadlock. - If a deadlock is found, we will resolve the deadlock by - choosing a victim transaction and rolling it back. - We will attempt to resolve all deadlocks. - - @param[in] lock the lock request - @param[in,out] trx transaction requesting the lock - - @return trx if it was chosen as victim - @retval NULL if another victim was chosen, - or there is no deadlock (any more) */ - static const trx_t* check_and_resolve(const lock_t* lock, trx_t* trx); - -private: - /** Do a shallow copy. Default destructor OK. - @param trx the start transaction (start node) - @param wait_lock lock that a transaction wants - @param mark_start visited node counter - @param report_waiters whether to call thd_rpl_deadlock_check() */ - DeadlockChecker( - const trx_t* trx, - const lock_t* wait_lock, - ib_uint64_t mark_start, - bool report_waiters) - : - m_cost(), - m_start(trx), - m_too_deep(), - m_wait_lock(wait_lock), - m_mark_start(mark_start), - m_n_elems(), - m_report_waiters(report_waiters) - { - } - - /** Check if the search is too deep. */ - bool is_too_deep() const - { - return(m_n_elems > LOCK_MAX_DEPTH_IN_DEADLOCK_CHECK - || m_cost > LOCK_MAX_N_STEPS_IN_DEADLOCK_CHECK); - } - - /** Save current state. - @param lock lock to push on the stack. - @param heap_no the heap number to push on the stack. - @return false if stack is full. */ - bool push(const lock_t* lock, ulint heap_no) - { - ut_ad((lock_get_type_low(lock) & LOCK_REC) - || (lock_get_type_low(lock) & LOCK_TABLE)); - - ut_ad(((lock_get_type_low(lock) & LOCK_TABLE) != 0) - == (heap_no == ULINT_UNDEFINED)); - - /* Ensure that the stack is bounded. */ - if (m_n_elems >= UT_ARR_SIZE(s_states)) { - return(false); - } - - state_t& state = s_states[m_n_elems++]; - - state.m_lock = lock; - state.m_wait_lock = m_wait_lock; - state.m_heap_no =heap_no; - - return(true); - } - - /** Restore state. - @param[out] lock current lock - @param[out] heap_no current heap_no */ - void pop(const lock_t*& lock, ulint& heap_no) - { - ut_a(m_n_elems > 0); - - const state_t& state = s_states[--m_n_elems]; - - lock = state.m_lock; - heap_no = state.m_heap_no; - m_wait_lock = state.m_wait_lock; - } - - /** Check whether the node has been visited. - @param lock lock to check - @return true if the node has been visited */ - bool is_visited(const lock_t* lock) const - { - return(lock->trx->lock.deadlock_mark > m_mark_start); - } - - /** Get the next lock in the queue that is owned by a transaction - whose sub-tree has not already been searched. - Note: "next" here means PREV for table locks. - @param lock Lock in queue - @param heap_no heap_no if lock is a record lock else ULINT_UNDEFINED - @return next lock or NULL if at end of queue */ - const lock_t* get_next_lock(const lock_t* lock, ulint heap_no) const; - - /** Get the first lock to search. The search starts from the current - wait_lock. What we are really interested in is an edge from the - current wait_lock's owning transaction to another transaction that has - a lock ahead in the queue. We skip locks where the owning transaction's - sub-tree has already been searched. - - Note: The record locks are traversed from the oldest lock to the - latest. For table locks we go from latest to oldest. - - For record locks, we first position the iterator on first lock on - the page and then reposition on the actual heap_no. This is required - due to the way the record lock has is implemented. - - @param[out] heap_no if rec lock, else ULINT_UNDEFINED. - - @return first lock or NULL */ - const lock_t* get_first_lock(ulint* heap_no) const; - - /** Notify that a deadlock has been detected and print the conflicting - transaction info. - @param lock lock causing deadlock */ - void notify(const lock_t* lock) const; - - /** Select the victim transaction that should be rolledback. - @return victim transaction */ - const trx_t* select_victim() const; +/** Functor for accessing the embedded node within a table lock. */ +struct TableLockGetNode +{ + ut_list_node<lock_t> &operator()(lock_t &elem) + { return(elem.un_member.tab_lock.locks); } +}; - /** Rollback transaction selected as the victim. */ - void trx_rollback(); +/** Create the hash table. +@param n the lower bound of n_cells */ +void lock_sys_t::hash_table::create(ulint n) +{ + n_cells= ut_find_prime(n); + const size_t size= MY_ALIGN(pad(n_cells) * sizeof *array, + CPU_LEVEL1_DCACHE_LINESIZE); + void *v= aligned_malloc(size, CPU_LEVEL1_DCACHE_LINESIZE); + memset_aligned<CPU_LEVEL1_DCACHE_LINESIZE>(v, 0, size); + array= static_cast<hash_cell_t*>(v); +} - /** Looks iteratively for a deadlock. Note: the joining transaction - may have been granted its lock by the deadlock checks. +/** Resize the hash table. +@param n the lower bound of n_cells */ +void lock_sys_t::hash_table::resize(ulint n) +{ + ut_ad(lock_sys.is_writer()); + ulint new_n_cells= ut_find_prime(n); + const size_t size= MY_ALIGN(pad(new_n_cells) * sizeof *array, + CPU_LEVEL1_DCACHE_LINESIZE); + void *v= aligned_malloc(size, CPU_LEVEL1_DCACHE_LINESIZE); + memset_aligned<CPU_LEVEL1_DCACHE_LINESIZE>(v, 0, size); + hash_cell_t *new_array= static_cast<hash_cell_t*>(v); - @return 0 if no deadlock else the victim transaction.*/ - const trx_t* search(); + for (auto i= pad(n_cells); i--; ) + { + if (lock_t *lock= static_cast<lock_t*>(array[i].node)) + { + /* all hash_latch must vacated */ + ut_ad(i % (ELEMENTS_PER_LATCH + LATCH) >= LATCH); + do + { + ut_ad(!lock->is_table()); + hash_cell_t *c= calc_hash(lock->un_member.rec_lock.page_id.fold(), + new_n_cells) + new_array; + lock_t *next= lock->hash; + lock->hash= nullptr; + if (!c->node) + c->node= lock; + else if (!lock->is_waiting()) + { + lock->hash= static_cast<lock_t*>(c->node); + c->node= lock; + } + else + { + lock_t *next= static_cast<lock_t*>(c->node); + while (next->hash) + next= next->hash; + next->hash= lock; + } + lock= next; + } + while (lock); + } + } - /** Print transaction data to the deadlock file and possibly to stderr. - @param trx transaction - @param max_query_len max query length to print */ - static void print(const trx_t* trx, ulint max_query_len); + aligned_free(array); + array= new_array; + n_cells= new_n_cells; +} - /** rewind(3) the file used for storing the latest detected deadlock - and print a heading message to stderr if printing of all deadlocks to - stderr is enabled. */ - static void start_print(); +#ifdef SUX_LOCK_GENERIC +void lock_sys_t::hash_latch::wait() +{ + pthread_mutex_lock(&lock_sys.hash_mutex); + while (!write_trylock()) + pthread_cond_wait(&lock_sys.hash_cond, &lock_sys.hash_mutex); + pthread_mutex_unlock(&lock_sys.hash_mutex); +} - /** Print lock data to the deadlock file and possibly to stderr. - @param lock record or table type lock */ - static void print(const lock_t* lock); +void lock_sys_t::hash_latch::release() +{ + pthread_mutex_lock(&lock_sys.hash_mutex); + write_unlock(); + pthread_cond_signal(&lock_sys.hash_cond); + pthread_mutex_unlock(&lock_sys.hash_mutex); +} +#endif - /** Print a message to the deadlock file and possibly to stderr. - @param msg message to print */ - static void print(const char* msg); +#ifdef UNIV_DEBUG +/** Assert that a lock shard is exclusively latched by this thread */ +void lock_sys_t::assert_locked(const lock_t &lock) const +{ + ut_ad(this == &lock_sys); + if (is_writer()) + return; + if (lock.is_table()) + assert_locked(*lock.un_member.tab_lock.table); + else + lock_sys.hash_get(lock.type_mode). + assert_locked(lock.un_member.rec_lock.page_id); +} - /** Print info about transaction that was rolled back. - @param trx transaction rolled back - @param lock lock trx wants */ - static void rollback_print(const trx_t* trx, const lock_t* lock); +/** Assert that a table lock shard is exclusively latched by this thread */ +void lock_sys_t::assert_locked(const dict_table_t &table) const +{ + ut_ad(!table.is_temporary()); + if (is_writer()) + return; + ut_ad(readers); + ut_ad(table.lock_mutex_is_owner()); +} -private: - /** DFS state information, used during deadlock checking. */ - struct state_t { - const lock_t* m_lock; /*!< Current lock */ - const lock_t* m_wait_lock; /*!< Waiting for lock */ - ulint m_heap_no; /*!< heap number if rec lock */ - }; +/** Assert that hash cell for page is exclusively latched by this thread */ +void lock_sys_t::hash_table::assert_locked(const page_id_t id) const +{ + if (lock_sys.is_writer()) + return; + ut_ad(lock_sys.readers); + ut_ad(latch(cell_get(id.fold()))->is_locked()); +} - /** Used in deadlock tracking. Protected by lock_sys.mutex. */ - static ib_uint64_t s_lock_mark_counter; +/** Assert that a hash table cell is exclusively latched (by some thread) */ +void lock_sys_t::assert_locked(const hash_cell_t &cell) const +{ + if (is_writer()) + return; + ut_ad(lock_sys.readers); + ut_ad(hash_table::latch(const_cast<hash_cell_t*>(&cell))->is_locked()); +} +#endif - /** Calculation steps thus far. It is the count of the nodes visited. */ - ulint m_cost; +LockGuard::LockGuard(lock_sys_t::hash_table &hash, page_id_t id) +{ + const auto id_fold= id.fold(); + lock_sys.rd_lock(SRW_LOCK_CALL); + cell_= hash.cell_get(id_fold); + hash.latch(cell_)->acquire(); +} - /** Joining transaction that is requesting a lock in an - incompatible mode */ - const trx_t* m_start; +LockMultiGuard::LockMultiGuard(lock_sys_t::hash_table &hash, + const page_id_t id1, const page_id_t id2) +{ + ut_ad(id1.space() == id2.space()); + const auto id1_fold= id1.fold(), id2_fold= id2.fold(); + lock_sys.rd_lock(SRW_LOCK_CALL); + cell1_= hash.cell_get(id1_fold); + cell2_= hash.cell_get(id2_fold); - /** TRUE if search was too deep and was aborted */ - bool m_too_deep; + auto latch1= hash.latch(cell1_), latch2= hash.latch(cell2_); + if (latch1 > latch2) + std::swap(latch1, latch2); + latch1->acquire(); + if (latch1 != latch2) + latch2->acquire(); +} - /** Lock that trx wants */ - const lock_t* m_wait_lock; +LockMultiGuard::~LockMultiGuard() +{ + auto latch1= lock_sys_t::hash_table::latch(cell1_), + latch2= lock_sys_t::hash_table::latch(cell2_); + latch1->release(); + if (latch1 != latch2) + latch2->release(); + /* Must be last, to avoid a race with lock_sys_t::hash_table::resize() */ + lock_sys.rd_unlock(); +} - /** Value of lock_mark_count at the start of the deadlock check. */ - ib_uint64_t m_mark_start; +TRANSACTIONAL_TARGET +TMLockGuard::TMLockGuard(lock_sys_t::hash_table &hash, page_id_t id) +{ + const auto id_fold= id.fold(); +#if !defined NO_ELISION && !defined SUX_LOCK_GENERIC + if (xbegin()) + { + if (lock_sys.latch.is_write_locked()) + xabort(); + cell_= hash.cell_get(id_fold); + if (hash.latch(cell_)->is_locked()) + xabort(); + elided= true; + return; + } + elided= false; +#endif + lock_sys.rd_lock(SRW_LOCK_CALL); + cell_= hash.cell_get(id_fold); + hash.latch(cell_)->acquire(); +} - /** Number of states pushed onto the stack */ - size_t m_n_elems; +/** Pretty-print a table lock. +@param[in,out] file output stream +@param[in] lock table lock */ +static void lock_table_print(FILE* file, const lock_t* lock); - /** This is to avoid malloc/free calls. */ - static state_t s_states[MAX_STACK_SIZE]; +/** Pretty-print a record lock. +@param[in,out] file output stream +@param[in] lock record lock +@param[in,out] mtr mini-transaction for accessing the record */ +static void lock_rec_print(FILE* file, const lock_t* lock, mtr_t& mtr); - /** Set if thd_rpl_deadlock_check() should be called for waits. */ - const bool m_report_waiters; +namespace Deadlock +{ + /** Whether to_check may be nonempty */ + static Atomic_relaxed<bool> to_be_checked; + /** Transactions to check for deadlock. Protected by lock_sys.wait_mutex. */ + static std::set<trx_t*> to_check; + + MY_ATTRIBUTE((nonnull, warn_unused_result)) + /** Check if a lock request results in a deadlock. + Resolve a deadlock by choosing a transaction that will be rolled back. + @param trx transaction requesting a lock + @return whether trx must report DB_DEADLOCK */ + static bool check_and_resolve(trx_t *trx); + + /** Quickly detect a deadlock using Brent's cycle detection algorithm. + @param trx transaction that is waiting for another transaction + @return a transaction that is part of a cycle + @retval nullptr if no cycle was found */ + inline trx_t *find_cycle(trx_t *trx) + { + mysql_mutex_assert_owner(&lock_sys.wait_mutex); + trx_t *tortoise= trx, *hare= trx; + for (unsigned power= 1, l= 1; (hare= hare->lock.wait_trx) != nullptr; l++) + { + if (tortoise == hare) + { + ut_ad(l > 1); + lock_sys.deadlocks++; + /* Note: Normally, trx should be part of any deadlock cycle + that is found. However, if innodb_deadlock_detect=OFF had been + in effect in the past, it is possible that trx will be waiting + for a transaction that participates in a pre-existing deadlock + cycle. In that case, our victim will not be trx. */ + return hare; + } + if (l == power) + { + /* The maximum concurrent number of TRX_STATE_ACTIVE transactions + is TRX_RSEG_N_SLOTS * 128, or innodb_page_size / 16 * 128 + (default: 131,072, maximum: 524,288). + Our maximum possible number of iterations should be twice that. */ + power<<= 1; + l= 0; + tortoise= hare; + } + } + return nullptr; + } }; -/** Counter to mark visited nodes during deadlock search. */ -ib_uint64_t DeadlockChecker::s_lock_mark_counter = 0; - -/** The stack used for deadlock searches. */ -DeadlockChecker::state_t DeadlockChecker::s_states[MAX_STACK_SIZE]; - #ifdef UNIV_DEBUG -/*********************************************************************//** -Validates the lock system. -@return TRUE if ok */ -static -bool -lock_validate(); -/*============*/ +/** Validate the transactional locks. */ +static void lock_validate(); -/*********************************************************************//** -Validates the record lock queues on a page. -@return TRUE if ok */ -static -ibool -lock_rec_validate_page( -/*===================*/ - const buf_block_t* block) /*!< in: buffer block */ - MY_ATTRIBUTE((warn_unused_result)); +/** Validate the record lock queues on a page. +@param block buffer pool block +@param latched whether the tablespace latch may be held +@return true if ok */ +static bool lock_rec_validate_page(const buf_block_t *block, bool latched) + MY_ATTRIBUTE((nonnull, warn_unused_result)); #endif /* UNIV_DEBUG */ /* The lock system */ lock_sys_t lock_sys; -/** We store info on the latest deadlock error to this buffer. InnoDB -Monitor will then fetch it and print */ -static bool lock_deadlock_found = false; - -/** Only created if !srv_read_only_mode */ -static FILE* lock_latest_err_file; +/** Only created if !srv_read_only_mode. Protected by lock_sys.latch. */ +static FILE *lock_latest_err_file; /*********************************************************************//** Reports that a transaction id is insensible, i.e., in the future. */ @@ -365,83 +381,6 @@ lock_check_trx_id_sanity( return true; } -/*********************************************************************//** -Checks that a record is seen in a consistent read. -@return true if sees, or false if an earlier version of the record -should be retrieved */ -bool -lock_clust_rec_cons_read_sees( -/*==========================*/ - const rec_t* rec, /*!< in: user record which should be read or - passed over by a read cursor */ - dict_index_t* index, /*!< in: clustered index */ - const rec_offs* offsets,/*!< in: rec_get_offsets(rec, index) */ - ReadView* view) /*!< in: consistent read view */ -{ - ut_ad(dict_index_is_clust(index)); - ut_ad(page_rec_is_user_rec(rec)); - ut_ad(rec_offs_validate(rec, index, offsets)); - ut_ad(!rec_is_metadata(rec, *index)); - - /* Temp-tables are not shared across connections and multiple - transactions from different connections cannot simultaneously - operate on same temp-table and so read of temp-table is - always consistent read. */ - if (index->table->is_temporary()) { - return(true); - } - - /* NOTE that we call this function while holding the search - system latch. */ - - trx_id_t trx_id = row_get_rec_trx_id(rec, index, offsets); - - return(view->changes_visible(trx_id, index->table->name)); -} - -/*********************************************************************//** -Checks that a non-clustered index record is seen in a consistent read. - -NOTE that a non-clustered index page contains so little information on -its modifications that also in the case false, the present version of -rec may be the right, but we must check this from the clustered index -record. - -@return true if certainly sees, or false if an earlier version of the -clustered index record might be needed */ -bool -lock_sec_rec_cons_read_sees( -/*========================*/ - const rec_t* rec, /*!< in: user record which - should be read or passed over - by a read cursor */ - const dict_index_t* index, /*!< in: index */ - const ReadView* view) /*!< in: consistent read view */ -{ - ut_ad(page_rec_is_user_rec(rec)); - ut_ad(!index->is_primary()); - ut_ad(!rec_is_metadata(rec, *index)); - - /* NOTE that we might call this function while holding the search - system latch. */ - - if (index->table->is_temporary()) { - - /* Temp-tables are not shared across connections and multiple - transactions from different connections cannot simultaneously - operate on same temp-table and so read of temp-table is - always consistent read. */ - - return(true); - } - - trx_id_t max_trx_id = page_get_max_trx_id(page_align(rec)); - - ut_ad(max_trx_id > 0); - - return(view->sees(max_trx_id)); -} - /** Creates the lock system at database start. @@ -450,38 +389,66 @@ lock_sec_rec_cons_read_sees( */ void lock_sys_t::create(ulint n_cells) { - ut_ad(this == &lock_sys); - - m_initialised= true; + ut_ad(this == &lock_sys); + ut_ad(!is_initialised()); - waiting_threads = static_cast<srv_slot_t*> - (ut_zalloc_nokey(srv_max_n_threads * sizeof *waiting_threads)); - last_slot = waiting_threads; + m_initialised= true; - mutex_create(LATCH_ID_LOCK_SYS, &mutex); - - mutex_create(LATCH_ID_LOCK_SYS_WAIT, &wait_mutex); + latch.SRW_LOCK_INIT(lock_latch_key); +#ifdef __aarch64__ + mysql_mutex_init(lock_wait_mutex_key, &wait_mutex, MY_MUTEX_INIT_FAST); +#else + mysql_mutex_init(lock_wait_mutex_key, &wait_mutex, nullptr); +#endif +#ifdef SUX_LOCK_GENERIC + pthread_mutex_init(&hash_mutex, nullptr); + pthread_cond_init(&hash_cond, nullptr); +#endif + rec_hash.create(n_cells); + prdt_hash.create(n_cells); + prdt_page_hash.create(n_cells); - rec_hash.create(n_cells); - prdt_hash.create(n_cells); - prdt_page_hash.create(n_cells); + if (!srv_read_only_mode) + { + lock_latest_err_file= os_file_create_tmpfile(); + ut_a(lock_latest_err_file); + } +} - if (!srv_read_only_mode) { - lock_latest_err_file = os_file_create_tmpfile(); - ut_a(lock_latest_err_file); - } - timeout_timer_active = false; +#ifdef UNIV_PFS_RWLOCK +/** Acquire exclusive lock_sys.latch */ +void lock_sys_t::wr_lock(const char *file, unsigned line) +{ + mysql_mutex_assert_not_owner(&wait_mutex); + latch.wr_lock(file, line); + ut_ad(!writer.exchange(pthread_self(), std::memory_order_relaxed)); +} +/** Release exclusive lock_sys.latch */ +void lock_sys_t::wr_unlock() +{ + ut_ad(writer.exchange(0, std::memory_order_relaxed) == + pthread_self()); + latch.wr_unlock(); } -/** Calculates the fold value of a lock: used in migrating the hash table. -@param[in] lock record lock object -@return folded value */ -static ulint lock_rec_lock_fold(const lock_t *lock) +/** Acquire shared lock_sys.latch */ +void lock_sys_t::rd_lock(const char *file, unsigned line) { - return lock->un_member.rec_lock.page_id.fold(); + mysql_mutex_assert_not_owner(&wait_mutex); + latch.rd_lock(file, line); + ut_ad(!writer.load(std::memory_order_relaxed)); + ut_d(readers.fetch_add(1, std::memory_order_relaxed)); } +/** Release shared lock_sys.latch */ +void lock_sys_t::rd_unlock() +{ + ut_ad(!writer.load(std::memory_order_relaxed)); + ut_ad(readers.fetch_sub(1, std::memory_order_relaxed)); + latch.rd_unlock(); +} +#endif /** Resize the lock hash table. @@ -490,123 +457,48 @@ static ulint lock_rec_lock_fold(const lock_t *lock) */ void lock_sys_t::resize(ulint n_cells) { - ut_ad(this == &lock_sys); - - mutex_enter(&mutex); - - hash_table_t old_hash(rec_hash); - rec_hash.create(n_cells); - HASH_MIGRATE(&old_hash, &rec_hash, lock_t, hash, - lock_rec_lock_fold); - old_hash.free(); - - old_hash = prdt_hash; - prdt_hash.create(n_cells); - HASH_MIGRATE(&old_hash, &prdt_hash, lock_t, hash, - lock_rec_lock_fold); - old_hash.free(); - - old_hash = prdt_page_hash; - prdt_page_hash.create(n_cells); - HASH_MIGRATE(&old_hash, &prdt_page_hash, lock_t, hash, - lock_rec_lock_fold); - old_hash.free(); - mutex_exit(&mutex); + ut_ad(this == &lock_sys); + /* Buffer pool resizing is rarely initiated by the user, and this + would exceed the maximum size of a memory transaction. */ + LockMutexGuard g{SRW_LOCK_CALL}; + rec_hash.resize(n_cells); + prdt_hash.resize(n_cells); + prdt_page_hash.resize(n_cells); } - /** Closes the lock system at database shutdown. */ void lock_sys_t::close() { - ut_ad(this == &lock_sys); - - if (!m_initialised) return; - - if (lock_latest_err_file != NULL) { - my_fclose(lock_latest_err_file, MYF(MY_WME)); - lock_latest_err_file = NULL; - } + ut_ad(this == &lock_sys); - rec_hash.free(); - prdt_hash.free(); - prdt_page_hash.free(); - - mutex_destroy(&mutex); - mutex_destroy(&wait_mutex); - - for (ulint i = srv_max_n_threads; i--; ) { - if (os_event_t& event = waiting_threads[i].event) { - os_event_destroy(event); - } - } + if (!m_initialised) + return; - ut_free(waiting_threads); - m_initialised= false; -} - -/*********************************************************************//** -Gets the size of a lock struct. -@return size in bytes */ -ulint -lock_get_size(void) -/*===============*/ -{ - return((ulint) sizeof(lock_t)); -} - -static inline void lock_grant_have_trx_mutex(lock_t* lock) -{ - lock_reset_lock_and_trx_wait(lock); - lock_grant_after_reset(lock); -} - -/*********************************************************************//** -Gets the gap flag of a record lock. -@return LOCK_GAP or 0 */ -UNIV_INLINE -ulint -lock_rec_get_gap( -/*=============*/ - const lock_t* lock) /*!< in: record lock */ -{ - ut_ad(lock); - ut_ad(lock_get_type_low(lock) == LOCK_REC); - - return(lock->type_mode & LOCK_GAP); -} + if (lock_latest_err_file) + { + my_fclose(lock_latest_err_file, MYF(MY_WME)); + lock_latest_err_file= nullptr; + } -/*********************************************************************//** -Gets the LOCK_REC_NOT_GAP flag of a record lock. -@return LOCK_REC_NOT_GAP or 0 */ -UNIV_INLINE -ulint -lock_rec_get_rec_not_gap( -/*=====================*/ - const lock_t* lock) /*!< in: record lock */ -{ - ut_ad(lock); - ut_ad(lock_get_type_low(lock) == LOCK_REC); + rec_hash.free(); + prdt_hash.free(); + prdt_page_hash.free(); +#ifdef SUX_LOCK_GENERIC + pthread_mutex_destroy(&hash_mutex); + pthread_cond_destroy(&hash_cond); +#endif - return(lock->type_mode & LOCK_REC_NOT_GAP); -} + latch.destroy(); + mysql_mutex_destroy(&wait_mutex); -/*********************************************************************//** -Gets the waiting insert flag of a record lock. -@return LOCK_INSERT_INTENTION or 0 */ -UNIV_INLINE -ulint -lock_rec_get_insert_intention( -/*==========================*/ - const lock_t* lock) /*!< in: record lock */ -{ - ut_ad(lock); - ut_ad(lock_get_type_low(lock) == LOCK_REC); + Deadlock::to_check.clear(); + Deadlock::to_be_checked= false; - return(lock->type_mode & LOCK_INSERT_INTENTION); + m_initialised= false; } -#ifdef UNIV_DEBUG #ifdef WITH_WSREP +# ifdef UNIV_DEBUG /** Check if both conflicting lock transaction and other transaction requesting record lock are brute force (BF). If they are check is this BF-BF wait correct and if not report BF wait and assert. @@ -616,12 +508,12 @@ this BF-BF wait correct and if not report BF wait and assert. */ static void wsrep_assert_no_bf_bf_wait(const lock_t *lock, const trx_t *trx) { - ut_ad(lock_get_type_low(lock) == LOCK_REC); - ut_ad(lock_mutex_own()); + ut_ad(!lock->is_table()); + lock_sys.assert_locked(*lock); trx_t* lock_trx= lock->trx; - /* Note that we are holding lock_sys->mutex, thus we should - not acquire THD::LOCK_thd_data mutex below to avoid mutexing + /* Note that we are holding lock_sys.latch, thus we should + not acquire THD::LOCK_thd_data mutex below to avoid latching order violation. */ if (!trx->is_wsrep() || !lock_trx->is_wsrep()) @@ -632,18 +524,13 @@ static void wsrep_assert_no_bf_bf_wait(const lock_t *lock, const trx_t *trx) ut_ad(trx->state == TRX_STATE_ACTIVE); - trx_mutex_enter(lock_trx); - const trx_state_t trx2_state= lock_trx->state; - trx_mutex_exit(lock_trx); - - /* If transaction is already committed in memory or - prepared we should wait. When transaction is committed in - memory we held trx mutex, but not lock_sys->mutex. Therefore, - we could end here before transaction has time to do - lock_release() that is protected with lock_sys->mutex. */ - switch (trx2_state) { + switch (lock_trx->state) { case TRX_STATE_COMMITTED_IN_MEMORY: + /* The state change is only protected by trx_t::mutex, + which we are not even holding here. */ case TRX_STATE_PREPARED: + /* Wait for lock->trx to complete the commit + (or XA ROLLBACK) and to release the lock. */ return; case TRX_STATE_ACTIVE: break; @@ -679,8 +566,25 @@ static void wsrep_assert_no_bf_bf_wait(const lock_t *lock, const trx_t *trx) /* BF-BF wait is a bug */ ut_error; } +# endif /* UNIV_DEBUG */ + +/** check if lock timeout was for priority thread, +as a side effect trigger lock monitor +@param trx transaction owning the lock +@return false for regular lock timeout */ +ATTRIBUTE_NOINLINE static bool wsrep_is_BF_lock_timeout(const trx_t &trx) +{ + ut_ad(trx.is_wsrep()); + + if (trx.error_state == DB_DEADLOCK || !srv_monitor_timer || + !wsrep_thd_is_BF(trx.mysql_thd, false)) + return false; + + ib::info() << "WSREP: BF lock wait long for trx:" << ib::hex(trx.id) + << " query: " << wsrep_thd_query(trx.mysql_thd); + return true; +} #endif /* WITH_WSREP */ -#endif /* UNIV_DEBUG */ /*********************************************************************//** Checks if a lock request for a new lock has to wait for request lock2. @@ -704,14 +608,15 @@ lock_rec_has_to_wait( index page: we know then that the lock request is really for a 'gap' type lock */ { - ut_ad(trx && lock2); - ut_ad(lock_get_type_low(lock2) == LOCK_REC); - ut_ad(lock_mutex_own()); + ut_ad(trx); + ut_ad(!lock2->is_table()); + ut_d(lock_sys.hash_get(type_mode).assert_locked( + lock2->un_member.rec_lock.page_id)); if (trx == lock2->trx || lock_mode_compatible( static_cast<lock_mode>(LOCK_MODE_MASK & type_mode), - lock_get_mode(lock2))) { + lock2->mode())) { return false; } @@ -729,7 +634,7 @@ lock_rec_has_to_wait( return false; } - if (!(type_mode & LOCK_INSERT_INTENTION) && lock_rec_get_gap(lock2)) { + if (!(type_mode & LOCK_INSERT_INTENTION) && lock2->is_gap()) { /* Record lock (LOCK_ORDINARY or LOCK_REC_NOT_GAP does not need to wait for a gap type lock */ @@ -737,7 +642,7 @@ lock_rec_has_to_wait( return false; } - if ((type_mode & LOCK_GAP) && lock_rec_get_rec_not_gap(lock2)) { + if ((type_mode & LOCK_GAP) && lock2->is_record_not_gap()) { /* Lock on gap does not need to wait for a LOCK_REC_NOT_GAP type lock */ @@ -745,8 +650,7 @@ lock_rec_has_to_wait( return false; } - if (lock_rec_get_insert_intention(lock2)) { - + if (lock2->is_insert_intention()) { /* No lock request needs to wait for an insert intention lock to be removed. This is ok since our rules allow conflicting locks on gaps. This eliminates @@ -761,7 +665,8 @@ lock_rec_has_to_wait( return false; } - if ((type_mode & LOCK_GAP || lock_rec_get_gap(lock2)) +#ifdef HAVE_REPLICATION + if ((type_mode & LOCK_GAP || lock2->is_gap()) && !thd_need_ordering_with(trx->mysql_thd, lock2->trx->mysql_thd)) { /* If the upper server layer has already decided on the commit order between the transaction requesting the @@ -785,6 +690,7 @@ lock_rec_has_to_wait( return false; } +#endif /* HAVE_REPLICATION */ #ifdef WITH_WSREP /* New lock request from a transaction is using unique key @@ -792,21 +698,18 @@ lock_rec_has_to_wait( (brute force). If conflicting transaction is also wsrep high priority transaction we should avoid lock conflict because ordering of these transactions is already decided and - conflicting transaction will be later replayed. Note - that thread holding conflicting lock can't be - committed or rolled back while we hold - lock_sys->mutex. */ + conflicting transaction will be later replayed. */ if (trx->is_wsrep_UK_scan() && wsrep_thd_is_BF(lock2->trx->mysql_thd, false)) { return false; } - /* If BF-BF conflict, we have to look at write set order */ - if (trx->is_wsrep() - && (type_mode & LOCK_MODE_MASK) == LOCK_X - && (lock2->type_mode & LOCK_MODE_MASK) == LOCK_X - && wsrep_thd_order_before(trx->mysql_thd, - lock2->trx->mysql_thd)) { + /* if BF-BF conflict, we have to look at write set order */ + if (trx->is_wsrep() && + (type_mode & LOCK_MODE_MASK) == LOCK_X && + (lock2->type_mode & LOCK_MODE_MASK) == LOCK_X && + wsrep_thd_order_before(trx->mysql_thd, + lock2->trx->mysql_thd)) { return false; } @@ -835,16 +738,15 @@ lock_has_to_wait( ut_ad(lock1 && lock2); if (lock1->trx == lock2->trx - || lock_mode_compatible(lock_get_mode(lock1), - lock_get_mode(lock2))) { + || lock_mode_compatible(lock1->mode(), lock2->mode())) { return false; } - if (lock_get_type_low(lock1) != LOCK_REC) { + if (lock1->is_table()) { return true; } - ut_ad(lock_get_type_low(lock2) == LOCK_REC); + ut_ad(!lock2->is_table()); if (lock1->type_mode & (LOCK_PREDICATE | LOCK_PRDT_PAGE)) { return lock_prdt_has_to_wait(lock1->trx, lock1->type_mode, @@ -892,7 +794,7 @@ lock_rec_bitmap_reset( { ulint n_bytes; - ut_ad(lock_get_type_low(lock) == LOCK_REC); + ut_ad(!lock->is_table()); /* Reset to zero the bitmap which resides immediately after the lock struct */ @@ -916,7 +818,7 @@ lock_rec_copy( { ulint size; - ut_ad(lock_get_type_low(lock) == LOCK_REC); + ut_ad(!lock->is_table()); size = sizeof(lock_t) + lock_rec_get_n_bits(lock) / 8; @@ -932,22 +834,16 @@ lock_rec_get_prev( const lock_t* in_lock,/*!< in: record lock */ ulint heap_no)/*!< in: heap number of the record */ { - lock_t* lock; - lock_t* found_lock = NULL; + ut_ad(!in_lock->is_table()); + const page_id_t id{in_lock->un_member.rec_lock.page_id}; + hash_cell_t *cell= lock_sys.hash_get(in_lock->type_mode).cell_get(id.fold()); - ut_ad(lock_mutex_own()); - ut_ad(lock_get_type_low(in_lock) == LOCK_REC); + for (lock_t *lock= lock_sys_t::get_first(*cell, id); lock != in_lock; + lock= lock_rec_get_next_on_page(lock)) + if (lock_rec_get_nth_bit(lock, heap_no)) + return lock; - for (lock = lock_sys.get_first(*lock_hash_get(in_lock->type_mode), - in_lock->un_member.rec_lock.page_id); - lock != in_lock; - lock = lock_rec_get_next_on_page(lock)) { - if (lock_rec_get_nth_bit(lock, heap_no)) { - found_lock = lock; - } - } - - return found_lock; + return nullptr; } /*============= FUNCTIONS FOR ANALYZING RECORD LOCK QUEUE ================*/ @@ -965,41 +861,27 @@ lock_rec_has_expl( LOCK_REC_NOT_GAP, for a supremum record we regard this always a gap type request */ - const buf_block_t* block, /*!< in: buffer block containing - the record */ + const hash_cell_t& cell, /*!< in: lock hash table cell */ + const page_id_t id, /*!< in: page identifier */ ulint heap_no,/*!< in: heap number of the record */ const trx_t* trx) /*!< in: transaction */ { - lock_t* lock; - - ut_ad(lock_mutex_own()); - ut_ad((precise_mode & LOCK_MODE_MASK) == LOCK_S - || (precise_mode & LOCK_MODE_MASK) == LOCK_X); - ut_ad(!(precise_mode & LOCK_INSERT_INTENTION)); - - for (lock = lock_rec_get_first(&lock_sys.rec_hash, block, heap_no); - lock != NULL; - lock = lock_rec_get_next(heap_no, lock)) { + ut_ad((precise_mode & LOCK_MODE_MASK) == LOCK_S + || (precise_mode & LOCK_MODE_MASK) == LOCK_X); + ut_ad(!(precise_mode & LOCK_INSERT_INTENTION)); - if (lock->trx == trx - && !lock_rec_get_insert_intention(lock) - && lock_mode_stronger_or_eq( - lock_get_mode(lock), - static_cast<lock_mode>( - precise_mode & LOCK_MODE_MASK)) - && !lock_get_wait(lock) - && (!lock_rec_get_rec_not_gap(lock) - || (precise_mode & LOCK_REC_NOT_GAP) - || heap_no == PAGE_HEAP_NO_SUPREMUM) - && (!lock_rec_get_gap(lock) - || (precise_mode & LOCK_GAP) - || heap_no == PAGE_HEAP_NO_SUPREMUM)) { + for (lock_t *lock= lock_sys_t::get_first(cell, id, heap_no); lock; + lock= lock_rec_get_next(heap_no, lock)) + if (lock->trx == trx && + !(lock->type_mode & (LOCK_WAIT | LOCK_INSERT_INTENTION)) && + (!((LOCK_REC_NOT_GAP | LOCK_GAP) & lock->type_mode) || + heap_no == PAGE_HEAP_NO_SUPREMUM || + ((LOCK_REC_NOT_GAP | LOCK_GAP) & precise_mode & lock->type_mode)) && + lock_mode_stronger_or_eq(lock->mode(), static_cast<lock_mode> + (precise_mode & LOCK_MODE_MASK))) + return lock; - return(lock); - } - } - - return(NULL); + return nullptr; } #ifdef UNIV_DEBUG @@ -1011,8 +893,8 @@ lock_t* lock_rec_other_has_expl_req( /*========================*/ lock_mode mode, /*!< in: LOCK_S or LOCK_X */ - const buf_block_t* block, /*!< in: buffer block containing - the record */ + const hash_cell_t& cell, /*!< in: lock hash table cell */ + const page_id_t id, /*!< in: page identifier */ bool wait, /*!< in: whether also waiting locks are taken into account */ ulint heap_no,/*!< in: heap number of the record */ @@ -1020,8 +902,6 @@ lock_rec_other_has_expl_req( requests by all transactions are taken into account */ { - - ut_ad(lock_mutex_own()); ut_ad(mode == LOCK_X || mode == LOCK_S); /* Only GAP lock can be on SUPREMUM, and we are not looking for @@ -1030,15 +910,12 @@ lock_rec_other_has_expl_req( return(NULL); } - for (lock_t* lock = lock_rec_get_first(&lock_sys.rec_hash, - block, heap_no); - lock != NULL; - lock = lock_rec_get_next(heap_no, lock)) { - + for (lock_t* lock = lock_sys_t::get_first(cell, id, heap_no); + lock; lock = lock_rec_get_next(heap_no, lock)) { if (lock->trx != trx - && !lock_rec_get_gap(lock) - && (wait || !lock_get_wait(lock)) - && lock_mode_stronger_or_eq(lock_get_mode(lock), mode)) { + && !lock->is_gap() + && (!lock->is_waiting() || wait) + && lock_mode_stronger_or_eq(lock->mode(), mode)) { return(lock); } @@ -1049,74 +926,113 @@ lock_rec_other_has_expl_req( #endif /* UNIV_DEBUG */ #ifdef WITH_WSREP -static void wsrep_kill_victim(const trx_t * const trx, const lock_t *lock) +void lock_wait_wsrep_kill(trx_t *bf_trx, ulong thd_id, trx_id_t trx_id); + +/** Kill the holders of conflicting locks. +@param trx brute-force applier transaction running in the current thread */ +ATTRIBUTE_COLD ATTRIBUTE_NOINLINE +static void lock_wait_wsrep(trx_t *trx) { - ut_ad(lock_mutex_own()); - ut_ad(trx->is_wsrep()); - trx_t* lock_trx = lock->trx; - ut_ad(trx_mutex_own(lock_trx)); - ut_ad(lock_trx != trx); + DBUG_ASSERT(wsrep_on(trx->mysql_thd)); + if (!wsrep_thd_is_BF(trx->mysql_thd, false)) + return; - if (!wsrep_thd_is_BF(trx->mysql_thd, FALSE)) - return; + std::set<trx_t*> victims; - if (lock_trx->state == TRX_STATE_COMMITTED_IN_MEMORY - || lock_trx->lock.was_chosen_as_deadlock_victim) - return; - - if (!wsrep_thd_is_BF(lock_trx->mysql_thd, FALSE) - || wsrep_thd_order_before(trx->mysql_thd, lock_trx->mysql_thd)) { - if (lock_trx->lock.que_state == TRX_QUE_LOCK_WAIT) { - if (UNIV_UNLIKELY(wsrep_debug)) - WSREP_INFO("BF victim waiting"); - /* cannot release lock, until our lock - is in the queue*/ - } else { - wsrep_innobase_kill_one_trx(trx->mysql_thd, - lock_trx, true); - } - } + lock_sys.wr_lock(SRW_LOCK_CALL); + mysql_mutex_lock(&lock_sys.wait_mutex); + + const lock_t *wait_lock= trx->lock.wait_lock; + if (!wait_lock) + { +func_exit: + lock_sys.wr_unlock(); + mysql_mutex_unlock(&lock_sys.wait_mutex); + return; + } + + if (wait_lock->is_table()) + { + dict_table_t *table= wait_lock->un_member.tab_lock.table; + for (lock_t *lock= UT_LIST_GET_FIRST(table->locks); lock; + lock= UT_LIST_GET_NEXT(un_member.tab_lock.locks, lock)) + /* if victim has also BF status, but has earlier seqno, we have to wait */ + if (lock->trx != trx && + !(wsrep_thd_is_BF(lock->trx->mysql_thd, false) && + wsrep_thd_order_before(lock->trx->mysql_thd, trx->mysql_thd))) + { + victims.emplace(lock->trx); + } + } + else + { + const page_id_t id{wait_lock->un_member.rec_lock.page_id}; + hash_cell_t &cell= *(wait_lock->type_mode & LOCK_PREDICATE + ? lock_sys.prdt_hash : lock_sys.rec_hash).cell_get + (id.fold()); + if (lock_t *lock= lock_sys_t::get_first(cell, id)) + { + const ulint heap_no= lock_rec_find_set_bit(wait_lock); + if (!lock_rec_get_nth_bit(lock, heap_no)) + lock= lock_rec_get_next(heap_no, lock); + do + /* if victim has also BF status, but has earlier seqno, we have to wait */ + if (lock->trx != trx && + !(wsrep_thd_is_BF(lock->trx->mysql_thd, false) && + wsrep_thd_order_before(lock->trx->mysql_thd, trx->mysql_thd))) + { + victims.emplace(lock->trx); + } + while ((lock= lock_rec_get_next(heap_no, lock))); + } + } + + if (victims.empty()) + goto func_exit; + + std::vector<std::pair<ulong,trx_id_t>> victim_id; + for (trx_t *v : victims) + victim_id.emplace_back(std::pair<ulong,trx_id_t> + {thd_get_thread_id(v->mysql_thd), v->id}); + + DBUG_EXECUTE_IF("sync.before_wsrep_thd_abort", + { + const char act[]= + "now SIGNAL sync.before_wsrep_thd_abort_reached " + "WAIT_FOR signal.before_wsrep_thd_abort"; + DBUG_ASSERT(!debug_sync_set_action(trx->mysql_thd, + STRING_WITH_LEN(act))); + };); + + lock_sys.wr_unlock(); + mysql_mutex_unlock(&lock_sys.wait_mutex); + + for (const auto &v : victim_id) + lock_wait_wsrep_kill(trx, v.first, v.second); } #endif /* WITH_WSREP */ /*********************************************************************//** Checks if some other transaction has a conflicting explicit lock request in the queue, so that we have to wait. -@return lock or NULL */ -static -lock_t* -lock_rec_other_has_conflicting( -/*===========================*/ - unsigned mode, /*!< in: LOCK_S or LOCK_X, - possibly ORed to LOCK_GAP or - LOC_REC_NOT_GAP, - LOCK_INSERT_INTENTION */ - const buf_block_t* block, /*!< in: buffer block containing - the record */ - ulint heap_no,/*!< in: heap number of the record */ - const trx_t* trx) /*!< in: our transaction */ +@param[in] mode LOCK_S or LOCK_X, possibly ORed to LOCK_GAP or LOC_REC_NOT_GAP, +LOCK_INSERT_INTENTION +@param[in] cell lock hash table cell +@param[in] id page identifier +@param[in] heap_no heap number of the record +@param[in] trx our transaction +@return conflicting lock and the flag which indicated if conflicting locks +which wait for the current transaction were ignored */ +static lock_t *lock_rec_other_has_conflicting(unsigned mode, + const hash_cell_t &cell, + const page_id_t id, + ulint heap_no, const trx_t *trx) { - lock_t* lock; - - ut_ad(lock_mutex_own()); - bool is_supremum = (heap_no == PAGE_HEAP_NO_SUPREMUM); - for (lock = lock_rec_get_first(&lock_sys.rec_hash, block, heap_no); - lock != NULL; - lock = lock_rec_get_next(heap_no, lock)) { - + for (lock_t* lock = lock_sys_t::get_first(cell, id, heap_no); + lock; lock = lock_rec_get_next(heap_no, lock)) { if (lock_rec_has_to_wait(trx, mode, lock, is_supremum)) { -#ifdef WITH_WSREP - if (trx->is_wsrep()) { - trx_mutex_enter(lock->trx); - /* Below function will roll back either trx - or lock->trx depending on priority of the - transaction. */ - wsrep_kill_victim(const_cast<trx_t*>(trx), lock); - trx_mutex_exit(lock->trx); - } -#endif /* WITH_WSREP */ return(lock); } } @@ -1140,59 +1056,30 @@ lock_sec_rec_some_has_impl( dict_index_t* index, /*!< in: secondary index */ const rec_offs* offsets)/*!< in: rec_get_offsets(rec, index) */ { - trx_t* trx; - trx_id_t max_trx_id; - const page_t* page = page_align(rec); - - ut_ad(!lock_mutex_own()); - ut_ad(!dict_index_is_clust(index)); - ut_ad(page_rec_is_user_rec(rec)); - ut_ad(rec_offs_validate(rec, index, offsets)); - ut_ad(!rec_is_metadata(rec, *index)); - - max_trx_id = page_get_max_trx_id(page); - - /* Some transaction may have an implicit x-lock on the record only - if the max trx id for the page >= min trx id for the trx list, or - database recovery is running. */ - - if (max_trx_id < trx_sys.get_min_trx_id()) { - - trx = 0; - - } else if (!lock_check_trx_id_sanity(max_trx_id, rec, index, offsets)) { - - /* The page is corrupt: try to avoid a crash by returning 0 */ - trx = 0; - - /* In this case it is possible that some transaction has an implicit - x-lock. We have to look in the clustered index. */ - - } else { - trx = row_vers_impl_x_locked(caller_trx, rec, index, offsets); - } + lock_sys.assert_unlocked(); + ut_ad(!dict_index_is_clust(index)); + ut_ad(page_rec_is_user_rec(rec)); + ut_ad(rec_offs_validate(rec, index, offsets)); + ut_ad(!rec_is_metadata(rec, *index)); - return(trx); -} + const trx_id_t max_trx_id= page_get_max_trx_id(page_align(rec)); -/*********************************************************************//** -Return approximate number or record locks (bits set in the bitmap) for -this transaction. Since delete-marked records may be removed, the -record count will not be precise. -The caller must be holding lock_sys.mutex. */ -ulint -lock_number_of_rows_locked( -/*=======================*/ - const trx_lock_t* trx_lock) /*!< in: transaction locks */ -{ - ut_ad(lock_mutex_own()); + /* Note: It is possible to have caller_trx->id == 0 in a locking read + if caller_trx has not modified any persistent tables. */ + if (!trx_sys.find_same_or_older(caller_trx, max_trx_id) || + !lock_check_trx_id_sanity(max_trx_id, rec, index, offsets)) + return nullptr; - return(trx_lock->n_rec_locks); + /* We checked above that some active (or XA PREPARE) transaction exists + that is older than PAGE_MAX_TRX_ID. That is, some transaction may be + holding an implicit lock on the record. We have to look up the + clustered index record to find if it is (or was) the case. */ + return row_vers_impl_x_locked(caller_trx, rec, index, offsets); } /*********************************************************************//** Return the number of table locks for a transaction. -The caller must be holding lock_sys.mutex. */ +The caller must be holding lock_sys.latch. */ ulint lock_number_of_tables_locked( /*=========================*/ @@ -1201,13 +1088,13 @@ lock_number_of_tables_locked( const lock_t* lock; ulint n_tables = 0; - ut_ad(lock_mutex_own()); + lock_sys.assert_locked(); for (lock = UT_LIST_GET_FIRST(trx_lock->trx_locks); lock != NULL; lock = UT_LIST_GET_NEXT(trx_locks, lock)) { - if (lock_get_type_low(lock) == LOCK_TABLE) { + if (lock->is_table()) { n_tables++; } } @@ -1217,35 +1104,21 @@ lock_number_of_tables_locked( /*============== RECORD LOCK CREATION AND QUEUE MANAGEMENT =============*/ -#ifdef WITH_WSREP -ATTRIBUTE_COLD -static -void -wsrep_print_wait_locks( -/*===================*/ - lock_t* c_lock) /* conflicting lock to print */ +/** Reset the wait status of a lock. +@param[in,out] lock lock that was possibly being waited for */ +static void lock_reset_lock_and_trx_wait(lock_t *lock) { - if (c_lock->trx->lock.wait_lock != c_lock) { - mtr_t mtr; - ib::info() << "WSREP: c_lock != wait lock"; - ib::info() << " SQL: " - << wsrep_thd_query(c_lock->trx->mysql_thd); - - if (lock_get_type_low(c_lock) & LOCK_TABLE) { - lock_table_print(stderr, c_lock); - } else { - lock_rec_print(stderr, c_lock, mtr); - } - - if (lock_get_type_low(c_lock->trx->lock.wait_lock) & LOCK_TABLE) { - lock_table_print(stderr, c_lock->trx->lock.wait_lock); - } else { - lock_rec_print(stderr, c_lock->trx->lock.wait_lock, - mtr); - } - } + lock_sys.assert_locked(*lock); + mysql_mutex_assert_owner(&lock_sys.wait_mutex); + trx_t *trx= lock->trx; + ut_ad(lock->is_waiting()); + ut_ad(!trx->lock.wait_lock || trx->lock.wait_lock == lock); + if (trx_t *wait_trx= trx->lock.wait_trx) + Deadlock::to_check.erase(wait_trx); + trx->lock.wait_lock= nullptr; + trx->lock.wait_trx= nullptr; + lock->type_mode&= ~LOCK_WAIT; } -#endif /* WITH_WSREP */ #ifdef UNIV_DEBUG /** Check transaction state */ @@ -1262,8 +1135,8 @@ static void check_trx_state(const trx_t *trx) /** Create a new record lock and inserts it to the lock queue, without checking for deadlocks or conflicts. -@param[in] type_mode lock mode and wait flag; type will be replaced - with LOCK_REC +@param[in] c_lock conflicting lock +@param[in] type_mode lock mode and wait flag @param[in] page_id index page number @param[in] page R-tree index page, or NULL @param[in] heap_no record heap number in the index page @@ -1273,10 +1146,7 @@ without checking for deadlocks or conflicts. @return created lock */ lock_t* lock_rec_create_low( -#ifdef WITH_WSREP - lock_t* c_lock, /*!< conflicting lock */ - que_thr_t* thr, /*!< thread owning trx */ -#endif + lock_t* c_lock, unsigned type_mode, const page_id_t page_id, const page_t* page, @@ -1286,21 +1156,14 @@ lock_rec_create_low( bool holds_trx_mutex) { lock_t* lock; - ulint n_bits; ulint n_bytes; - ut_ad(lock_mutex_own()); - ut_ad(holds_trx_mutex == trx_mutex_own(trx)); + ut_d(lock_sys.hash_get(type_mode).assert_locked(page_id)); + ut_ad(xtest() || holds_trx_mutex == trx->mutex_is_owner()); ut_ad(dict_index_is_clust(index) || !dict_index_is_online_ddl(index)); - -#ifdef UNIV_DEBUG - /* Non-locking autocommit read-only transactions should not set - any locks. See comment in trx_set_rw_mode explaining why this - conditional check is required in debug code. */ - if (holds_trx_mutex) { - check_trx_state(trx); - } -#endif /* UNIV_DEBUG */ + ut_ad(!(type_mode & LOCK_TABLE)); + ut_ad(trx->state != TRX_STATE_NOT_STARTED); + ut_ad(!trx->is_autocommit_non_locking()); /* If rec is the supremum record, then we reset the gap and LOCK_REC_NOT_GAP bits, as all locks on the supremum are @@ -1312,9 +1175,7 @@ lock_rec_create_low( } if (UNIV_LIKELY(!(type_mode & (LOCK_PREDICATE | LOCK_PRDT_PAGE)))) { - /* Make lock bitmap bigger by a safety margin */ - n_bits = page_dir_get_n_heap(page) + LOCK_PAGE_BITMAP_MARGIN; - n_bytes = 1 + n_bits / 8; + n_bytes = (page_dir_get_n_heap(page) + 7) / 8; } else { ut_ad(heap_no == PRDT_HEAPNO); @@ -1335,6 +1196,12 @@ lock_rec_create_low( } } + if (!holds_trx_mutex) { + trx->mutex_lock(); + } + ut_ad(trx->mutex_is_owner()); + ut_ad(trx->state != TRX_STATE_NOT_STARTED); + if (trx->lock.rec_cached >= UT_ARR_SIZE(trx->lock.rec_pool) || sizeof *lock + n_bytes > sizeof *trx->lock.rec_pool) { lock = static_cast<lock_t*>( @@ -1345,7 +1212,7 @@ lock_rec_create_low( } lock->trx = trx; - lock->type_mode = (type_mode & unsigned(~LOCK_TYPE_MASK)) | LOCK_REC; + lock->type_mode = type_mode; lock->index = index; lock->un_member.rec_lock.page_id = page_id; @@ -1358,89 +1225,26 @@ lock_rec_create_low( lock_rec_bitmap_reset(lock); lock_rec_set_nth_bit(lock, heap_no); index->table->n_rec_locks++; - ut_ad(index->table->get_ref_count() > 0 || !index->table->can_be_evicted); - -#ifdef WITH_WSREP - if (c_lock && trx->is_wsrep() - && wsrep_thd_is_BF(trx->mysql_thd, FALSE)) { - lock_t *hash = (lock_t *)c_lock->hash; - lock_t *prev = NULL; - - while (hash && wsrep_thd_is_BF(hash->trx->mysql_thd, FALSE) - && wsrep_thd_order_before(hash->trx->mysql_thd, - trx->mysql_thd)) { - prev = hash; - hash = (lock_t *)hash->hash; - } - lock->hash = hash; - if (prev) { - prev->hash = lock; - } else { - c_lock->hash = lock; - } - /* - * delayed conflict resolution '...kill_one_trx' was not called, - * if victim was waiting for some other lock - */ - trx_mutex_enter(c_lock->trx); - if (c_lock->trx->lock.que_state == TRX_QUE_LOCK_WAIT) { - - c_lock->trx->lock.was_chosen_as_deadlock_victim = TRUE; - - if (UNIV_UNLIKELY(wsrep_debug)) { - wsrep_print_wait_locks(c_lock); - } - - trx->lock.que_state = TRX_QUE_LOCK_WAIT; - lock_set_lock_and_trx_wait(lock, trx); - UT_LIST_ADD_LAST(trx->lock.trx_locks, lock); + ut_ad(index->table->get_ref_count() || !index->table->can_be_evicted); - trx->lock.wait_thr = thr; - thr->state = QUE_THR_LOCK_WAIT; + const auto lock_hash = &lock_sys.hash_get(type_mode); + lock_hash->cell_get(page_id.fold())->append(*lock, &lock_t::hash); - /* have to release trx mutex for the duration of - victim lock release. This will eventually call - lock_grant, which wants to grant trx mutex again - */ - if (holds_trx_mutex) { - trx_mutex_exit(trx); - } - lock_cancel_waiting_and_release( - c_lock->trx->lock.wait_lock); - - if (holds_trx_mutex) { - trx_mutex_enter(trx); - } - - trx_mutex_exit(c_lock->trx); - - /* have to bail out here to avoid lock_set_lock... */ - return(lock); - } - trx_mutex_exit(c_lock->trx); - } else -#endif /* WITH_WSREP */ - if (!(type_mode & (LOCK_WAIT | LOCK_PREDICATE | LOCK_PRDT_PAGE)) - && innodb_lock_schedule_algorithm - == INNODB_LOCK_SCHEDULE_ALGORITHM_VATS - && !thd_is_replication_slave_thread(trx->mysql_thd)) { - HASH_PREPEND(lock_t, hash, &lock_sys.rec_hash, - page_id.fold(), lock); - } else { - HASH_INSERT(lock_t, hash, lock_hash_get(type_mode), - page_id.fold(), lock); - } - - if (!holds_trx_mutex) { - trx_mutex_enter(trx); - } - ut_ad(trx_mutex_own(trx)); if (type_mode & LOCK_WAIT) { - lock_set_lock_and_trx_wait(lock, trx); + if (trx->lock.wait_trx) { + ut_ad(!c_lock || trx->lock.wait_trx == c_lock->trx); + ut_ad(trx->lock.wait_lock); + ut_ad((*trx->lock.wait_lock).trx == trx); + } else { + ut_ad(c_lock); + trx->lock.wait_trx = c_lock->trx; + ut_ad(!trx->lock.wait_lock); + } + trx->lock.wait_lock = lock; } UT_LIST_ADD_LAST(trx->lock.trx_locks, lock); if (!holds_trx_mutex) { - trx_mutex_exit(trx); + trx->mutex_unlock(); } MONITOR_INC(MONITOR_RECLOCK_CREATED); MONITOR_INC(MONITOR_NUM_RECLOCK); @@ -1448,139 +1252,6 @@ lock_rec_create_low( return lock; } -/*********************************************************************//** -Check if lock1 has higher priority than lock2. -NULL has lowest priority. -If neither of them is wait lock, the first one has higher priority. -If only one of them is a wait lock, it has lower priority. -If either is a high priority transaction, the lock has higher priority. -Otherwise, the one with an older transaction has higher priority. -@returns true if lock1 has higher priority, false otherwise. */ -static bool has_higher_priority(lock_t *lock1, lock_t *lock2) -{ - if (lock1 == NULL) { - return false; - } else if (lock2 == NULL) { - return true; - } - // Granted locks has higher priority. - if (!lock_get_wait(lock1)) { - return true; - } else if (!lock_get_wait(lock2)) { - return false; - } - return lock1->trx->start_time_micro <= lock2->trx->start_time_micro; -} - -/*********************************************************************//** -Insert a lock to the hash list according to the mode (whether it is a wait -lock) and the age of the transaction the it is associated with. -If the lock is not a wait lock, insert it to the head of the hash list. -Otherwise, insert it to the middle of the wait locks according to the age of -the transaciton. */ -static -dberr_t -lock_rec_insert_by_trx_age( - lock_t *in_lock) /*!< in: lock to be insert */{ - lock_t* node; - lock_t* next; - hash_table_t* hash; - hash_cell_t* cell; - - ut_ad(!in_lock->trx->is_wsrep()); - const page_id_t page_id(in_lock->un_member.rec_lock.page_id); - hash = lock_hash_get(in_lock->type_mode); - cell = &hash->array[hash->calc_hash(page_id.fold())]; - - node = (lock_t *) cell->node; - // If in_lock is not a wait lock, we insert it to the head of the list. - if (node == NULL || !lock_get_wait(in_lock) || has_higher_priority(in_lock, node)) { - cell->node = in_lock; - in_lock->hash = node; - if (lock_get_wait(in_lock)) { - lock_grant_have_trx_mutex(in_lock); - return DB_SUCCESS_LOCKED_REC; - } - return DB_SUCCESS; - } - while (node != NULL && has_higher_priority((lock_t *) node->hash, - in_lock)) { - node = (lock_t *) node->hash; - } - next = (lock_t *) node->hash; - node->hash = in_lock; - in_lock->hash = next; - - if (lock_get_wait(in_lock) && !lock_rec_has_to_wait_in_queue(in_lock)) { - lock_grant_have_trx_mutex(in_lock); - if (cell->node != in_lock) { - // Move it to the front of the queue - node->hash = in_lock->hash; - next = (lock_t *) cell->node; - cell->node = in_lock; - in_lock->hash = next; - } - return DB_SUCCESS_LOCKED_REC; - } - - return DB_SUCCESS; -} - -#ifdef UNIV_DEBUG -static -bool -lock_queue_validate( - const lock_t *in_lock) /*!< in: lock whose hash list is to be validated */ -{ - hash_table_t* hash; - hash_cell_t* cell; - lock_t* next; - bool wait_lock __attribute__((unused))= false; - - if (in_lock == NULL) { - return true; - } - - const page_id_t page_id(in_lock->un_member.rec_lock.page_id); - hash = lock_hash_get(in_lock->type_mode); - cell = &hash->array[hash->calc_hash(page_id.fold())]; - next = (lock_t *) cell->node; - while (next != NULL) { - // If this is a granted lock, check that there's no wait lock before it. - if (!lock_get_wait(next)) { - ut_ad(!wait_lock); - } else { - wait_lock = true; - } - next = next->hash; - } - return true; -} -#endif /* UNIV_DEBUG */ - -static -void -lock_rec_insert_to_head( - lock_t *in_lock, /*!< in: lock to be insert */ - ulint rec_fold) /*!< in: rec_fold of the page */ -{ - hash_table_t* hash; - hash_cell_t* cell; - lock_t* node; - - if (in_lock == NULL) { - return; - } - - hash = lock_hash_get(in_lock->type_mode); - cell = &hash->array[hash->calc_hash(rec_fold)]; - node = (lock_t *) cell->node; - if (node != in_lock) { - cell->node = in_lock; - in_lock->hash = node; - } -} - /** Enqueue a waiting request for a lock which cannot be granted immediately. Check for deadlocks. @param[in] type_mode the requested lock mode (LOCK_S or LOCK_X) @@ -1590,49 +1261,40 @@ Check for deadlocks. waiting lock request is set when performing an insert of an index record -@param[in] block leaf page in the index +@param[in] id page identifier +@param[in] page leaf page in the index @param[in] heap_no record heap number in the block @param[in] index index tree @param[in,out] thr query thread @param[in] prdt minimum bounding box (spatial index) @retval DB_LOCK_WAIT if the waiting lock was enqueued -@retval DB_DEADLOCK if this transaction was chosen as the victim -@retval DB_SUCCESS_LOCKED_REC if the other transaction was chosen as a victim - (or it happened to commit) */ +@retval DB_DEADLOCK if this transaction was chosen as the victim */ dberr_t lock_rec_enqueue_waiting( -#ifdef WITH_WSREP - lock_t* c_lock, /*!< conflicting lock */ -#endif + lock_t* c_lock, unsigned type_mode, - const buf_block_t* block, + const page_id_t id, + const page_t* page, ulint heap_no, dict_index_t* index, que_thr_t* thr, lock_prdt_t* prdt) { - ut_ad(lock_mutex_own()); + ut_d(lock_sys.hash_get(type_mode).assert_locked(id)); ut_ad(!srv_read_only_mode); ut_ad(dict_index_is_clust(index) || !dict_index_is_online_ddl(index)); trx_t* trx = thr_get_trx(thr); - - ut_ad(trx_mutex_own(trx)); - ut_a(!que_thr_stop(thr)); - - switch (trx_get_dict_operation(trx)) { - case TRX_DICT_OP_NONE: - break; - case TRX_DICT_OP_TABLE: - case TRX_DICT_OP_INDEX: - ib::error() << "A record lock wait happens in a dictionary" - " operation. index " - << index->name - << " of table " - << index->table->name - << ". " << BUG_REPORT_MSG; - ut_ad(0); - } + ut_ad(xtest() || trx->mutex_is_owner()); + ut_ad(!trx->dict_operation_lock_mode); + /* Apart from Galera, only transactions that have waiting lock can be + chosen as deadlock victim. Only one lock can be waited for at a time, + and a transaction is associated with a single thread. That is why there + must not be waiting lock requests if the transaction is deadlock victim + and it is not WSREP. Galera transaction abort can be invoked from MDL + acquisition code when the transaction does not have waiting record + lock, that's why we check only deadlock victim bit here. */ + ut_ad(!(trx->lock.was_chosen_as_deadlock_victim & 1)); if (trx->mysql_thd && thd_lock_wait_timeout(trx->mysql_thd) == 0) { trx->error_state = DB_LOCK_WAIT_TIMEOUT; @@ -1641,43 +1303,15 @@ lock_rec_enqueue_waiting( /* Enqueue the lock request that will wait to be granted, note that we already own the trx mutex. */ - lock_t* lock = lock_rec_create( -#ifdef WITH_WSREP - c_lock, thr, -#endif - type_mode | LOCK_WAIT, block, heap_no, index, trx, TRUE); + lock_t* lock = lock_rec_create_low( + c_lock, + type_mode | LOCK_WAIT, id, page, heap_no, index, trx, true); if (prdt && type_mode & LOCK_PREDICATE) { lock_prdt_set_prdt(lock, prdt); } - if (ut_d(const trx_t* victim =) - DeadlockChecker::check_and_resolve(lock, trx)) { - ut_ad(victim == trx); - lock_reset_lock_and_trx_wait(lock); - lock_rec_reset_nth_bit(lock, heap_no); - return DB_DEADLOCK; - } - - if (!trx->lock.wait_lock) { - /* If there was a deadlock but we chose another - transaction as a victim, it is possible that we - already have the lock now granted! */ -#ifdef WITH_WSREP - if (UNIV_UNLIKELY(wsrep_debug)) { - ib::info() << "WSREP: BF thread got lock granted early, ID " << ib::hex(trx->id) - << " query: " << wsrep_thd_query(trx->mysql_thd); - } -#endif - return DB_SUCCESS_LOCKED_REC; - } - - trx->lock.que_state = TRX_QUE_LOCK_WAIT; - - trx->lock.was_chosen_as_deadlock_victim = false; - trx->lock.wait_started = time(NULL); - - ut_a(que_thr_stop(thr)); + trx->lock.wait_thr = thr; DBUG_LOG("ib_lock", "trx " << ib::hex(trx->id) << " waits for lock in index " << index->name @@ -1685,18 +1319,6 @@ lock_rec_enqueue_waiting( MONITOR_INC(MONITOR_LOCKREC_WAIT); - if (innodb_lock_schedule_algorithm - == INNODB_LOCK_SCHEDULE_ALGORITHM_VATS - && !prdt - && !thd_is_replication_slave_thread(lock->trx->mysql_thd)) { - HASH_DELETE(lock_t, hash, &lock_sys.rec_hash, - lock_rec_lock_fold(lock), lock); - dberr_t res = lock_rec_insert_by_trx_age(lock); - if (res != DB_SUCCESS) { - return res; - } - } - return DB_LOCK_WAIT; } @@ -1713,7 +1335,7 @@ lock_rec_find_similar_on_page( lock_t* lock, /*!< in: lock_sys.get_first() */ const trx_t* trx) /*!< in: transaction */ { - ut_ad(lock_mutex_own()); + lock_sys.rec_hash.assert_locked(lock->un_member.rec_lock.page_id); for (/* No op */; lock != NULL; @@ -1737,28 +1359,26 @@ on the record, and the request to be added is not a waiting request, we can reuse a suitable record lock object already existing on the same page, just setting the appropriate bit in its bitmap. This is a low-level function which does NOT check for deadlocks or lock compatibility! -@return lock where the bit was set */ -static -void -lock_rec_add_to_queue( -/*==================*/ - unsigned type_mode,/*!< in: lock mode, wait, gap - etc. flags; type is ignored - and replaced by LOCK_REC */ - const buf_block_t* block, /*!< in: buffer block containing - the record */ - ulint heap_no,/*!< in: heap number of the record */ - dict_index_t* index, /*!< in: index of record */ - trx_t* trx, /*!< in/out: transaction */ - bool caller_owns_trx_mutex) - /*!< in: TRUE if caller owns the - transaction mutex */ -{ -#ifdef UNIV_DEBUG - ut_ad(lock_mutex_own()); - ut_ad(caller_owns_trx_mutex == trx_mutex_own(trx)); - ut_ad(dict_index_is_clust(index) +@param[in] type_mode lock mode, wait, gap etc. flags +@param[in,out] cell first hash table cell +@param[in] id page identifier +@param[in] page buffer block containing the record +@param[in] heap_no heap number of the record +@param[in] index index of record +@param[in,out] trx transaction +@param[in] caller_owns_trx_mutex TRUE if caller owns the transaction mutex */ +TRANSACTIONAL_TARGET +static void lock_rec_add_to_queue(unsigned type_mode, hash_cell_t &cell, + const page_id_t id, const page_t *page, + ulint heap_no, dict_index_t *index, + trx_t *trx, bool caller_owns_trx_mutex) +{ + ut_d(lock_sys.hash_get(type_mode).assert_locked(id)); + ut_ad(xtest() || caller_owns_trx_mutex == trx->mutex_is_owner()); + ut_ad(index->is_primary() || dict_index_get_online_status(index) != ONLINE_INDEX_CREATION); + ut_ad(!(type_mode & LOCK_TABLE)); +#ifdef UNIV_DEBUG switch (type_mode & LOCK_MODE_MASK) { case LOCK_X: case LOCK_S: @@ -1773,7 +1393,7 @@ lock_rec_add_to_queue( : LOCK_S; const lock_t* other_lock = lock_rec_other_has_expl_req( - mode, block, false, heap_no, trx); + mode, cell, id, false, heap_no, trx); #ifdef WITH_WSREP if (UNIV_LIKELY_NULL(other_lock) && trx->is_wsrep()) { /* Only BF transaction may be granted lock @@ -1791,8 +1411,6 @@ lock_rec_add_to_queue( } #endif /* UNIV_DEBUG */ - type_mode |= LOCK_REC; - /* If rec is the supremum record, then we can reset the gap bit, as all locks on the supremum are automatically of the gap type, and we try to avoid unnecessary memory consumption of a new record lock @@ -1807,45 +1425,48 @@ lock_rec_add_to_queue( type_mode &= ~(LOCK_GAP | LOCK_REC_NOT_GAP); } - lock_t* lock; - lock_t* first_lock; - - /* Look for a waiting lock request on the same record or on a gap */ - - for (first_lock = lock = lock_sys.get_first(*lock_hash_get(type_mode), - block->page.id()); - lock != NULL; - lock = lock_rec_get_next_on_page(lock)) { - - if (lock_get_wait(lock) - && lock_rec_get_nth_bit(lock, heap_no)) { - - break; + if (type_mode & LOCK_WAIT) { + goto create; + } else if (lock_t *first_lock = lock_sys_t::get_first(cell, id)) { + for (lock_t* lock = first_lock;;) { + if (lock->is_waiting() + && lock_rec_get_nth_bit(lock, heap_no)) { + goto create; + } + if (!(lock = lock_rec_get_next_on_page(lock))) { + break; + } } - } - - if (lock == NULL && !(type_mode & LOCK_WAIT)) { /* Look for a similar record lock on the same page: if one is found and there are no waiting lock requests, we can just set the bit */ + if (lock_t* lock = lock_rec_find_similar_on_page( + type_mode, heap_no, first_lock, trx)) { + trx_t* lock_trx = lock->trx; + if (caller_owns_trx_mutex) { + trx->mutex_unlock(); + } + { + TMTrxGuard tg{*lock_trx}; + lock_rec_set_nth_bit(lock, heap_no); + } - lock = lock_rec_find_similar_on_page( - type_mode, heap_no, first_lock, trx); - - if (lock != NULL) { - - lock_rec_set_nth_bit(lock, heap_no); - + if (caller_owns_trx_mutex) { + trx->mutex_lock(); + } return; } } - lock_rec_create( -#ifdef WITH_WSREP - NULL, NULL, -#endif - type_mode, block, heap_no, index, trx, caller_owns_trx_mutex); +create: + /* Note: We will not pass any conflicting lock to lock_rec_create(), + because we should be moving an existing waiting lock request. */ + ut_ad(!(type_mode & LOCK_WAIT) || trx->lock.wait_trx); + + lock_rec_create_low(nullptr, + type_mode, id, page, heap_no, index, trx, + caller_owns_trx_mutex); } /*********************************************************************//** @@ -1873,58 +1494,67 @@ lock_rec_lock( que_thr_t* thr) /*!< in: query thread */ { trx_t *trx= thr_get_trx(thr); - dberr_t err= DB_SUCCESS; - + /* There must not be lock requests for reads or updates if transaction was + chosen as deadlock victim. Apart from Galera, only transactions that have + waiting lock may be chosen as deadlock victims. Only one lock can be waited + for at a time, and a transaction is associated with a single thread. Galera + transaction abort can be invoked from MDL acquisition code when the + transaction does not have waiting lock, that's why we check only deadlock + victim bit here. */ + ut_ad(!(trx->lock.was_chosen_as_deadlock_victim & 1)); ut_ad(!srv_read_only_mode); - ut_ad((LOCK_MODE_MASK & mode) == LOCK_S || - (LOCK_MODE_MASK & mode) == LOCK_X); - ut_ad((mode & LOCK_TYPE_MASK) == LOCK_GAP || - (mode & LOCK_TYPE_MASK) == LOCK_REC_NOT_GAP || - (mode & LOCK_TYPE_MASK) == 0); + ut_ad(((LOCK_MODE_MASK | LOCK_TABLE) & mode) == LOCK_S || + ((LOCK_MODE_MASK | LOCK_TABLE) & mode) == LOCK_X); + ut_ad(~mode & (LOCK_GAP | LOCK_REC_NOT_GAP)); ut_ad(dict_index_is_clust(index) || !dict_index_is_online_ddl(index)); DBUG_EXECUTE_IF("innodb_report_deadlock", return DB_DEADLOCK;); - lock_mutex_enter(); ut_ad((LOCK_MODE_MASK & mode) != LOCK_S || lock_table_has(trx, index->table, LOCK_IS)); ut_ad((LOCK_MODE_MASK & mode) != LOCK_X || lock_table_has(trx, index->table, LOCK_IX)); if (lock_table_has(trx, index->table, - static_cast<lock_mode>(LOCK_MODE_MASK & mode))); - else if (lock_t *lock= lock_sys.get_first(block->page.id())) + static_cast<lock_mode>(LOCK_MODE_MASK & mode))) + return DB_SUCCESS; + + /* During CREATE TABLE, we will write to newly created FTS_*_CONFIG + on which no lock has been created yet. */ + ut_ad(!trx->dict_operation_lock_mode || + (strstr(index->table->name.m_name, "/FTS_") && + strstr(index->table->name.m_name, "_CONFIG") + sizeof("_CONFIG") == + index->table->name.m_name + strlen(index->table->name.m_name) + 1)); + MONITOR_ATOMIC_INC(MONITOR_NUM_RECLOCK_REQ); + const page_id_t id{block->page.id()}; + LockGuard g{lock_sys.rec_hash, id}; + + if (lock_t *lock= lock_sys_t::get_first(g.cell(), id)) { - trx_mutex_enter(trx); + dberr_t err= DB_SUCCESS; + trx->mutex_lock(); if (lock_rec_get_next_on_page(lock) || lock->trx != trx || - lock->type_mode != (ulint(mode) | LOCK_REC) || + lock->type_mode != mode || lock_rec_get_n_bits(lock) <= heap_no) { /* Do nothing if the trx already has a strong enough lock on rec */ - if (!lock_rec_has_expl(mode, block, heap_no, trx)) + if (!lock_rec_has_expl(mode, g.cell(), id, heap_no, trx)) { - if ( -#ifdef WITH_WSREP - lock_t *c_lock= -#endif - lock_rec_other_has_conflicting(mode, block, heap_no, trx)) - { + if (lock_t *c_lock= lock_rec_other_has_conflicting(mode, g.cell(), id, + heap_no, trx)) /* If another transaction has a non-gap conflicting request in the queue, as this transaction does not have a lock strong enough already granted on the - record, we have to wait. */ - err = lock_rec_enqueue_waiting( -#ifdef WITH_WSREP - c_lock, -#endif /* WITH_WSREP */ - mode, block, heap_no, index, thr, NULL); - } + record, we have to wait. + */ + err= lock_rec_enqueue_waiting(c_lock, mode, id, block->page.frame, + heap_no, index, thr, nullptr); else if (!impl) { /* Set the requested lock on the record. */ - lock_rec_add_to_queue(LOCK_REC | mode, block, heap_no, index, trx, - true); + lock_rec_add_to_queue(mode, g.cell(), id, block->page.frame, heap_no, + index, trx, true); err= DB_SUCCESS_LOCKED_REC; } } @@ -1941,26 +1571,16 @@ lock_rec_lock( err= DB_SUCCESS_LOCKED_REC; } } - trx_mutex_exit(trx); + trx->mutex_unlock(); + return err; } - else - { - /* - Simplified and faster path for the most common cases - Note that we don't own the trx mutex. - */ - if (!impl) - lock_rec_create( -#ifdef WITH_WSREP - NULL, NULL, -#endif - mode, block, heap_no, index, trx, false); - err= DB_SUCCESS_LOCKED_REC; - } - lock_mutex_exit(); - MONITOR_ATOMIC_INC(MONITOR_NUM_RECLOCK_REQ); - return err; + /* Simplified and faster path for the most common cases */ + if (!impl) + lock_rec_create_low(nullptr, mode, id, block->page.frame, heap_no, index, + trx, false); + + return DB_SUCCESS_LOCKED_REC; } /*********************************************************************//** @@ -1968,27 +1588,23 @@ Checks if a waiting record lock request still has to wait in a queue. @return lock that is causing the wait */ static const lock_t* -lock_rec_has_to_wait_in_queue( -/*==========================*/ - const lock_t* wait_lock) /*!< in: waiting record lock */ +lock_rec_has_to_wait_in_queue(const hash_cell_t &cell, const lock_t *wait_lock) { const lock_t* lock; ulint heap_no; ulint bit_mask; ulint bit_offset; - ut_ad(wait_lock); - ut_ad(lock_mutex_own()); - ut_ad(lock_get_wait(wait_lock)); - ut_ad(lock_get_type_low(wait_lock) == LOCK_REC); + ut_ad(wait_lock->is_waiting()); + ut_ad(!wait_lock->is_table()); heap_no = lock_rec_find_set_bit(wait_lock); bit_offset = heap_no / 8; bit_mask = static_cast<ulint>(1) << (heap_no % 8); - for (lock = lock_sys.get_first(*lock_hash_get(wait_lock->type_mode), - wait_lock->un_member.rec_lock.page_id); + for (lock = lock_sys_t::get_first( + cell, wait_lock->un_member.rec_lock.page_id); lock != wait_lock; lock = lock_rec_get_next_on_page_const(lock)) { const byte* p = (const byte*) &lock[1]; @@ -1997,9 +1613,9 @@ lock_rec_has_to_wait_in_queue( && (p[bit_offset] & bit_mask) && lock_has_to_wait(wait_lock, lock)) { #ifdef WITH_WSREP - if (lock->trx->is_wsrep() - && wsrep_thd_order_before(wait_lock->trx->mysql_thd, - lock->trx->mysql_thd)) { + if (lock->trx->is_wsrep() && + wsrep_thd_order_before(wait_lock->trx->mysql_thd, + lock->trx->mysql_thd)) { /* don't wait for another BF lock */ continue; } @@ -2011,249 +1627,498 @@ lock_rec_has_to_wait_in_queue( return(NULL); } -/** Grant a lock to a waiting lock request and release the waiting transaction -after lock_reset_lock_and_trx_wait() has been called. */ -static void lock_grant_after_reset(lock_t* lock) +/** Note that a record lock wait started */ +inline void lock_sys_t::wait_start() { - ut_ad(lock_mutex_own()); - ut_ad(trx_mutex_own(lock->trx)); - - if (lock_get_mode(lock) == LOCK_AUTO_INC) { - dict_table_t* table = lock->un_member.tab_lock.table; - - if (table->autoinc_trx == lock->trx) { - ib::error() << "Transaction already had an" - << " AUTO-INC lock!"; - } else { - table->autoinc_trx = lock->trx; + mysql_mutex_assert_owner(&wait_mutex); + wait_count+= WAIT_COUNT_STEP + 1; + /* The maximum number of concurrently waiting transactions is one less + than the maximum number of concurrent transactions. */ + static_assert(WAIT_COUNT_STEP == UNIV_PAGE_SIZE_MAX / 16 * TRX_SYS_N_RSEGS, + "compatibility"); +} - ib_vector_push(lock->trx->autoinc_locks, &lock); - } - } +/** Note that a record lock wait resumed */ +inline +void lock_sys_t::wait_resume(THD *thd, my_hrtime_t start, my_hrtime_t now) +{ + mysql_mutex_assert_owner(&wait_mutex); + ut_ad(get_wait_pending()); + ut_ad(get_wait_cumulative()); + wait_count--; + if (now.val >= start.val) + { + const uint32_t diff_time= + static_cast<uint32_t>((now.val - start.val) / 1000); + wait_time+= diff_time; - DBUG_PRINT("ib_lock", ("wait for trx " TRX_ID_FMT " ends", - trx_get_id_for_print(lock->trx))); + if (diff_time > wait_time_max) + wait_time_max= diff_time; - /* If we are resolving a deadlock by choosing another transaction - as a victim, then our original transaction may not be in the - TRX_QUE_LOCK_WAIT state, and there is no need to end the lock wait - for it */ + thd_storage_lock_wait(thd, diff_time); + } +} - if (lock->trx->lock.que_state == TRX_QUE_LOCK_WAIT) { - que_thr_t* thr; +#ifdef HAVE_REPLICATION +ATTRIBUTE_NOINLINE MY_ATTRIBUTE((nonnull)) +/** Report lock waits to parallel replication. Sets +trx->error_state= DB_DEADLOCK if trx->lock.was_chosen_as_deadlock_victim was +set when lock_sys.wait_mutex was unlocked. +@param trx transaction that may be waiting for a lock +@param wait_lock lock that is being waited for */ +static void lock_wait_rpl_report(trx_t *trx) +{ + mysql_mutex_assert_owner(&lock_sys.wait_mutex); + ut_ad(trx->state == TRX_STATE_ACTIVE); + THD *const thd= trx->mysql_thd; + ut_ad(thd); + const lock_t *wait_lock= trx->lock.wait_lock; + if (!wait_lock) + return; + ut_ad(!(wait_lock->type_mode & LOCK_AUTO_INC)); + /* This would likely be too large to attempt to use a memory transaction, + even for wait_lock->is_table(). */ + const bool nowait= lock_sys.wr_lock_try(); + if (!nowait) + { + mysql_mutex_unlock(&lock_sys.wait_mutex); + lock_sys.wr_lock(SRW_LOCK_CALL); + mysql_mutex_lock(&lock_sys.wait_mutex); + wait_lock= trx->lock.wait_lock; + if (!wait_lock) + { +func_exit: + lock_sys.wr_unlock(); + /* trx->lock.was_chosen_as_deadlock_victim can be set when + lock_sys.wait_mutex was unlocked, let's check it. */ + if (!nowait && trx->lock.was_chosen_as_deadlock_victim) + trx->error_state= DB_DEADLOCK; + return; + } + ut_ad(wait_lock->is_waiting()); + } + else if (!wait_lock->is_waiting()) + goto func_exit; + ut_ad(!(wait_lock->type_mode & LOCK_AUTO_INC)); - thr = que_thr_end_lock_wait(lock->trx); + if (wait_lock->is_table()) + { + dict_table_t *table= wait_lock->un_member.tab_lock.table; + for (lock_t *lock= UT_LIST_GET_FIRST(table->locks); lock; + lock= UT_LIST_GET_NEXT(un_member.tab_lock.locks, lock)) + if (!(lock->type_mode & LOCK_AUTO_INC) && lock->trx != trx) + thd_rpl_deadlock_check(thd, lock->trx->mysql_thd); + } + else + { + const page_id_t id{wait_lock->un_member.rec_lock.page_id}; + hash_cell_t &cell= *(wait_lock->type_mode & LOCK_PREDICATE + ? lock_sys.prdt_hash : lock_sys.rec_hash).cell_get + (id.fold()); + if (lock_t *lock= lock_sys_t::get_first(cell, id)) + { + const ulint heap_no= lock_rec_find_set_bit(wait_lock); + if (!lock_rec_get_nth_bit(lock, heap_no)) + lock= lock_rec_get_next(heap_no, lock); + do + if (lock->trx->mysql_thd != thd) + thd_rpl_deadlock_check(thd, lock->trx->mysql_thd); + while ((lock= lock_rec_get_next(heap_no, lock))); + } + } - if (thr != NULL) { - lock_wait_release_thread_if_suspended(thr); - } - } + goto func_exit; } +#endif /* HAVE_REPLICATION */ -/** Grant a lock to a waiting lock request and release the waiting transaction. */ -static void lock_grant(lock_t* lock) +/** Wait for a lock to be released. +@retval DB_DEADLOCK if this transaction was chosen as the deadlock victim +@retval DB_INTERRUPTED if the execution was interrupted by the user +@retval DB_LOCK_WAIT_TIMEOUT if the lock wait timed out +@retval DB_SUCCESS if the lock was granted */ +dberr_t lock_wait(que_thr_t *thr) { - lock_reset_lock_and_trx_wait(lock); - trx_mutex_enter(lock->trx); - lock_grant_after_reset(lock); - trx_mutex_exit(lock->trx); -} + trx_t *trx= thr_get_trx(thr); -/*************************************************************//** -Cancels a waiting record lock request and releases the waiting transaction -that requested it. NOTE: does NOT check if waiting lock requests behind this -one can now be granted! */ -static -void -lock_rec_cancel( -/*============*/ - lock_t* lock) /*!< in: waiting record lock request */ -{ - que_thr_t* thr; + if (trx->mysql_thd) + DEBUG_SYNC_C("lock_wait_start"); + + /* Create the sync point for any quit from the function. */ + ut_d(SCOPE_EXIT([trx]() { + if (trx->mysql_thd) + DEBUG_SYNC_C("lock_wait_end"); + })); + + /* InnoDB system transactions may use the global value of + innodb_lock_wait_timeout, because trx->mysql_thd == NULL. */ + const ulong innodb_lock_wait_timeout= trx_lock_wait_timeout_get(trx); + const my_hrtime_t suspend_time= my_hrtime_coarse(); + ut_ad(!trx->dict_operation_lock_mode); + + /* The wait_lock can be cleared by another thread in lock_grant(), + lock_rec_cancel(), or lock_cancel_waiting_and_release(). But, a wait + can only be initiated by the current thread which owns the transaction. + + Even if trx->lock.wait_lock were changed, the object that it used to + point to it will remain valid memory (remain allocated from + trx->lock.lock_heap). If trx->lock.wait_lock was set to nullptr, the + original object could be transformed to a granted lock. On a page + split or merge, we would change trx->lock.wait_lock to point to + another waiting lock request object, and the old object would be + logically discarded. + + In any case, it is safe to read the memory that wait_lock points to, + even though we are not holding any mutex. We are only reading + wait_lock->type_mode & (LOCK_TABLE | LOCK_AUTO_INC), which will be + unaffected by any page split or merge operation. (Furthermore, + table lock objects will never be cloned or moved.) */ + const lock_t *const wait_lock= trx->lock.wait_lock; + + if (!wait_lock) + { + /* The lock has already been released or this transaction + was chosen as a deadlock victim: no need to wait */ + trx->error_state= + trx->lock.was_chosen_as_deadlock_victim ? DB_DEADLOCK : DB_SUCCESS; + return trx->error_state; + } - ut_ad(lock_mutex_own()); - ut_ad(lock_get_type_low(lock) == LOCK_REC); + trx->lock.suspend_time= suspend_time; - /* Reset the bit (there can be only one set bit) in the lock bitmap */ - lock_rec_reset_nth_bit(lock, lock_rec_find_set_bit(lock)); + ut_ad(!trx->dict_operation_lock_mode); - /* Reset the wait flag and the back pointer to lock in trx */ + IF_WSREP(if (trx->is_wsrep()) lock_wait_wsrep(trx),); - lock_reset_lock_and_trx_wait(lock); + const auto type_mode= wait_lock->type_mode; +#ifdef HAVE_REPLICATION + /* Even though lock_wait_rpl_report() has nothing to do with + deadlock detection, it was always disabled by innodb_deadlock_detect=OFF. + We will keep it in that way, because unfortunately + thd_need_wait_reports() will hold even if parallel (or any) replication + is not being used. We want to be allow the user to skip + lock_wait_rpl_report(). */ + const bool rpl= !(type_mode & LOCK_AUTO_INC) && trx->mysql_thd && + innodb_deadlock_detect && thd_need_wait_reports(trx->mysql_thd); +#endif + const bool row_lock_wait= thr->lock_state == QUE_THR_LOCK_ROW; + timespec abstime; + set_timespec_time_nsec(abstime, suspend_time.val * 1000); + abstime.MY_tv_sec+= innodb_lock_wait_timeout; + /* Dictionary transactions must wait be immune to lock wait timeouts + for locks on data dictionary tables. Here we check only for + SYS_TABLES, SYS_COLUMNS, SYS_INDEXES, SYS_FIELDS. Locks on further + tables SYS_FOREIGN, SYS_FOREIGN_COLS, SYS_VIRTUAL will only be + acquired while holding an exclusive lock on one of the 4 tables. */ + const bool no_timeout= innodb_lock_wait_timeout >= 100000000 || + ((type_mode & LOCK_TABLE) && + wait_lock->un_member.tab_lock.table->id <= DICT_FIELDS_ID); + thd_wait_begin(trx->mysql_thd, (type_mode & LOCK_TABLE) + ? THD_WAIT_TABLE_LOCK : THD_WAIT_ROW_LOCK); + + int err= 0; + mysql_mutex_lock(&lock_sys.wait_mutex); + if (trx->lock.wait_lock) + { + if (Deadlock::check_and_resolve(trx)) + { + ut_ad(!trx->lock.wait_lock); + trx->error_state= DB_DEADLOCK; + goto end_wait; + } + } + else + { + /* trx->lock.was_chosen_as_deadlock_victim can be changed before + lock_sys.wait_mutex is acquired, so let's check it once more. */ + trx->error_state= + trx->lock.was_chosen_as_deadlock_victim ? DB_DEADLOCK : DB_SUCCESS; + goto end_wait; + } + if (row_lock_wait) + lock_sys.wait_start(); - /* The following function releases the trx from lock wait */ +#ifdef HAVE_REPLICATION + if (rpl) + lock_wait_rpl_report(trx); +#endif - trx_mutex_enter(lock->trx); + if (trx->error_state != DB_SUCCESS) + goto check_trx_error; - thr = que_thr_end_lock_wait(lock->trx); + while (trx->lock.wait_lock) + { + DEBUG_SYNC_C("lock_wait_before_suspend"); - if (thr != NULL) { - lock_wait_release_thread_if_suspended(thr); - } + if (no_timeout) + my_cond_wait(&trx->lock.cond, &lock_sys.wait_mutex.m_mutex); + else + err= my_cond_timedwait(&trx->lock.cond, &lock_sys.wait_mutex.m_mutex, + &abstime); +check_trx_error: + switch (trx->error_state) { + case DB_DEADLOCK: + case DB_INTERRUPTED: + break; + default: + ut_ad(trx->error_state != DB_LOCK_WAIT_TIMEOUT); + /* Dictionary transactions must ignore KILL, because they could + be executed as part of a multi-transaction DDL operation, + such as rollback_inplace_alter_table() or ha_innobase::delete_table(). */ + if (!trx->dict_operation && trx_is_interrupted(trx)) + /* innobase_kill_query() can only set trx->error_state=DB_INTERRUPTED + for any transaction that is attached to a connection. */ + trx->error_state= DB_INTERRUPTED; + else if (!err) + continue; +#ifdef WITH_WSREP + else if (trx->is_wsrep() && wsrep_is_BF_lock_timeout(*trx)); +#endif + else + { + trx->error_state= DB_LOCK_WAIT_TIMEOUT; + lock_sys.timeouts++; + } + } + break; + } + + if (row_lock_wait) + lock_sys.wait_resume(trx->mysql_thd, suspend_time, my_hrtime_coarse()); + + /* Cache trx->lock.wait_lock to avoid unnecessary atomic variable load */ + if (lock_t *lock= trx->lock.wait_lock) + { + lock_sys_t::cancel<false>(trx, lock); + lock_sys.deadlock_check(); + } + +end_wait: + mysql_mutex_unlock(&lock_sys.wait_mutex); + thd_wait_end(trx->mysql_thd); + + return trx->error_state; +} + + +/** Resume a lock wait */ +template <bool from_deadlock= false> +void lock_wait_end(trx_t *trx) +{ + mysql_mutex_assert_owner(&lock_sys.wait_mutex); + ut_ad(trx->mutex_is_owner()); + ut_d(const auto state= trx->state); + ut_ad(state == TRX_STATE_COMMITTED_IN_MEMORY || state == TRX_STATE_ACTIVE || + state == TRX_STATE_PREPARED); + /* lock_wait() checks trx->lock.was_chosen_as_deadlock_victim flag before + requesting lock_sys.wait_mutex, and if the flag is set, it returns error, + what causes transaction rollback, which can reset trx->lock.wait_thr before + deadlock resolution starts cancelling victim's waiting lock. That's why we + don't check trx->lock.wait_thr here if the function was called from deadlock + resolution function. */ + ut_ad(from_deadlock || trx->lock.wait_thr); - trx_mutex_exit(lock->trx); + if (trx->lock.was_chosen_as_deadlock_victim) + { + ut_ad(from_deadlock || state == TRX_STATE_ACTIVE); + trx->error_state= DB_DEADLOCK; + } + + trx->lock.wait_thr= nullptr; + pthread_cond_signal(&trx->lock.cond); } -static void lock_grant_and_move_on_page(ulint rec_fold, const page_id_t id) +/** Grant a waiting lock request and release the waiting transaction. */ +static void lock_grant(lock_t *lock) { - lock_t* lock; - lock_t* previous = static_cast<lock_t*>( - lock_sys.rec_hash.array[lock_sys.rec_hash.calc_hash(rec_fold)]. - node); - if (previous == NULL) { - return; - } - if (previous->un_member.rec_lock.page_id == id) { - lock = previous; - } - else { - while (previous->hash && - (previous->hash->un_member.rec_lock.page_id != id)) { - previous = previous->hash; - } - lock = previous->hash; - } + lock_reset_lock_and_trx_wait(lock); + trx_t *trx= lock->trx; + trx->mutex_lock(); + if (lock->mode() == LOCK_AUTO_INC) + { + dict_table_t *table= lock->un_member.tab_lock.table; + ut_ad(!table->autoinc_trx); + table->autoinc_trx= trx; + ib_vector_push(trx->autoinc_locks, &lock); + } - ut_ad(previous->hash == lock || previous == lock); - /* Grant locks if there are no conflicting locks ahead. - Move granted locks to the head of the list. */ - while (lock) { - /* If the lock is a wait lock on this page, and it does not need to wait. */ - ut_ad(!lock->trx->is_wsrep()); - if (lock_get_wait(lock) - && lock->un_member.rec_lock.page_id == id - && !lock_rec_has_to_wait_in_queue(lock)) { - lock_grant(lock); + DBUG_PRINT("ib_lock", ("wait for trx " TRX_ID_FMT " ends", trx->id)); - if (previous != NULL) { - /* Move the lock to the head of the list. */ - HASH_GET_NEXT(hash, previous) = HASH_GET_NEXT(hash, lock); - lock_rec_insert_to_head(lock, rec_fold); - } else { - /* Already at the head of the list. */ - previous = lock; - } - /* Move on to the next lock. */ - lock = static_cast<lock_t *>(HASH_GET_NEXT(hash, previous)); - } else { - previous = lock; - lock = static_cast<lock_t *>(HASH_GET_NEXT(hash, lock)); - } - } + /* If we are resolving a deadlock by choosing another transaction as + a victim, then our original transaction may not be waiting anymore */ + + if (trx->lock.wait_thr) + lock_wait_end(trx); + + trx->mutex_unlock(); +} + +/*************************************************************//** +Cancels a waiting record lock request and releases the waiting transaction +that requested it. NOTE: does NOT check if waiting lock requests behind this +one can now be granted! */ +static void lock_rec_cancel(lock_t *lock) +{ + trx_t *trx= lock->trx; + mysql_mutex_lock(&lock_sys.wait_mutex); + trx->mutex_lock(); + + ut_d(lock_sys.hash_get(lock->type_mode). + assert_locked(lock->un_member.rec_lock.page_id)); + /* Reset the bit (there can be only one set bit) in the lock bitmap */ + lock_rec_reset_nth_bit(lock, lock_rec_find_set_bit(lock)); + + /* Reset the wait flag and the back pointer to lock in trx */ + lock_reset_lock_and_trx_wait(lock); + + /* The following releases the trx from lock wait */ + lock_wait_end(trx); + mysql_mutex_unlock(&lock_sys.wait_mutex); + trx->mutex_unlock(); } /** Remove a record lock request, waiting or granted, from the queue and grant locks to other transactions in the queue if they now are entitled to a lock. NOTE: all record locks contained in in_lock are removed. -@param[in,out] in_lock record lock */ -static void lock_rec_dequeue_from_page(lock_t* in_lock) +@param[in,out] in_lock record lock +@param[in] owns_wait_mutex whether lock_sys.wait_mutex is held */ +static void lock_rec_dequeue_from_page(lock_t *in_lock, bool owns_wait_mutex) { - hash_table_t* lock_hash; - - ut_ad(lock_mutex_own()); - ut_ad(lock_get_type_low(in_lock) == LOCK_REC); - /* We may or may not be holding in_lock->trx->mutex here. */ +#ifdef SAFE_MUTEX + ut_ad(owns_wait_mutex == mysql_mutex_is_owner(&lock_sys.wait_mutex)); +#endif /* SAFE_MUTEX */ + ut_ad(!in_lock->is_table()); - const page_id_t page_id(in_lock->un_member.rec_lock.page_id); + const page_id_t page_id{in_lock->un_member.rec_lock.page_id}; + auto& lock_hash = lock_sys.hash_get(in_lock->type_mode); + ut_ad(lock_sys.is_writer() || in_lock->trx->mutex_is_owner()); + ut_d(auto old_n_locks=) in_lock->index->table->n_rec_locks--; - - lock_hash = lock_hash_get(in_lock->type_mode); + ut_ad(old_n_locks); const ulint rec_fold = page_id.fold(); + hash_cell_t &cell = *lock_hash.cell_get(rec_fold); + lock_sys.assert_locked(cell); - HASH_DELETE(lock_t, hash, lock_hash, rec_fold, in_lock); + HASH_DELETE(lock_t, hash, &lock_hash, rec_fold, in_lock); + ut_ad(lock_sys.is_writer() || in_lock->trx->mutex_is_owner()); UT_LIST_REMOVE(in_lock->trx->lock.trx_locks, in_lock); MONITOR_INC(MONITOR_RECLOCK_REMOVED); MONITOR_DEC(MONITOR_NUM_RECLOCK); - if (innodb_lock_schedule_algorithm - == INNODB_LOCK_SCHEDULE_ALGORITHM_FCFS - || lock_hash != &lock_sys.rec_hash - || thd_is_replication_slave_thread(in_lock->trx->mysql_thd)) { - /* Check if waiting locks in the queue can now be granted: - grant locks if there are no conflicting locks ahead. Stop at - the first X lock that is waiting or has been granted. */ + bool acquired = false; - for (lock_t* lock = lock_sys.get_first(*lock_hash, page_id); - lock != NULL; - lock = lock_rec_get_next_on_page(lock)) { + /* Check if waiting locks in the queue can now be granted: + grant locks if there are no conflicting locks ahead. Stop at + the first X lock that is waiting or has been granted. */ - if (!lock_get_wait(lock)) { - continue; - } - const lock_t* c = lock_rec_has_to_wait_in_queue(lock); - if (!c) { - /* Grant the lock */ - ut_ad(lock->trx != in_lock->trx); - lock_grant(lock); + for (lock_t* lock = lock_sys_t::get_first(cell, page_id); + lock != NULL; + lock = lock_rec_get_next_on_page(lock)) { + + if (!lock->is_waiting()) { + continue; + } + + if (!owns_wait_mutex) { + mysql_mutex_lock(&lock_sys.wait_mutex); + acquired = owns_wait_mutex = true; + } + + ut_ad(lock->trx->lock.wait_trx); + ut_ad(lock->trx->lock.wait_lock); + + if (const lock_t* c = lock_rec_has_to_wait_in_queue( + cell, lock)) { + trx_t* c_trx = c->trx; + lock->trx->lock.wait_trx = c_trx; + if (c_trx->lock.wait_trx + && innodb_deadlock_detect + && Deadlock::to_check.emplace(c_trx).second) { + Deadlock::to_be_checked = true; } + } else { + /* Grant the lock */ + ut_ad(lock->trx != in_lock->trx); + lock_grant(lock); } - } else { - lock_grant_and_move_on_page(rec_fold, page_id); + } + + if (acquired) { + mysql_mutex_unlock(&lock_sys.wait_mutex); } } -/*************************************************************//** -Removes a record lock request, waiting or granted, from the queue. */ -void -lock_rec_discard( -/*=============*/ - lock_t* in_lock) /*!< in: record lock object: all - record locks which are contained - in this lock object are removed */ +/** Remove a record lock request, waiting or granted, on a discarded page +@param hash hash table +@param in_lock lock object */ +TRANSACTIONAL_TARGET +void lock_rec_discard(lock_sys_t::hash_table &lock_hash, lock_t *in_lock) { - trx_lock_t* trx_lock; - - ut_ad(lock_mutex_own()); - ut_ad(lock_get_type_low(in_lock) == LOCK_REC); - - trx_lock = &in_lock->trx->lock; - - in_lock->index->table->n_rec_locks--; - - HASH_DELETE(lock_t, hash, lock_hash_get(in_lock->type_mode), - in_lock->un_member.rec_lock.page_id.fold(), in_lock); + ut_ad(!in_lock->is_table()); + lock_hash.assert_locked(in_lock->un_member.rec_lock.page_id); - UT_LIST_REMOVE(trx_lock->trx_locks, in_lock); - - MONITOR_INC(MONITOR_RECLOCK_REMOVED); - MONITOR_DEC(MONITOR_NUM_RECLOCK); + HASH_DELETE(lock_t, hash, &lock_hash, + in_lock->un_member.rec_lock.page_id.fold(), in_lock); + ut_d(uint32_t old_locks); + { + trx_t *trx= in_lock->trx; + TMTrxGuard tg{*trx}; + ut_d(old_locks=) + in_lock->index->table->n_rec_locks--; + UT_LIST_REMOVE(trx->lock.trx_locks, in_lock); + } + ut_ad(old_locks); + MONITOR_INC(MONITOR_RECLOCK_REMOVED); + MONITOR_DEC(MONITOR_NUM_RECLOCK); } /*************************************************************//** Removes record lock objects set on an index page which is discarded. This function does not move locks, or check for waiting locks, therefore the lock bitmaps must already be reset when this function is called. */ -static void lock_rec_free_all_from_discard_page_low(const page_id_t id, - hash_table_t *lock_hash) +static void +lock_rec_free_all_from_discard_page(page_id_t id, const hash_cell_t &cell, + lock_sys_t::hash_table &lock_hash) { - lock_t *lock= lock_sys.get_first(*lock_hash, id); - - while (lock) + for (lock_t *lock= lock_sys_t::get_first(cell, id); lock; ) { - ut_ad(lock_rec_find_set_bit(lock) == ULINT_UNDEFINED); - ut_ad(!lock_get_wait(lock)); + ut_ad(&lock_hash != &lock_sys.rec_hash || + lock_rec_find_set_bit(lock) == ULINT_UNDEFINED); + ut_ad(!lock->is_waiting()); lock_t *next_lock= lock_rec_get_next_on_page(lock); - lock_rec_discard(lock); + lock_rec_discard(lock_hash, lock); lock= next_lock; } } -/*************************************************************//** -Removes record lock objects set on an index page which is discarded. This -function does not move locks, or check for waiting locks, therefore the -lock bitmaps must already be reset when this function is called. */ -void -lock_rec_free_all_from_discard_page( -/*================================*/ - const buf_block_t* block) /*!< in: page to be discarded */ +/** Discard locks for an index when purging DELETE FROM SYS_INDEXES +after an aborted CREATE INDEX operation. +@param index a stale index on which ADD INDEX operation was aborted */ +ATTRIBUTE_COLD void lock_discard_for_index(const dict_index_t &index) { - const page_id_t page_id(block->page.id()); - lock_rec_free_all_from_discard_page_low(page_id, &lock_sys.rec_hash); - lock_rec_free_all_from_discard_page_low(page_id, &lock_sys.prdt_hash); - lock_rec_free_all_from_discard_page_low(page_id, &lock_sys.prdt_page_hash); + ut_ad(!index.is_committed()); + /* This is very rarely executed code, and the size of the hash array + would exceed the maximum size of a memory transaction. */ + LockMutexGuard g{SRW_LOCK_CALL}; + const ulint n= lock_sys.rec_hash.pad(lock_sys.rec_hash.n_cells); + for (ulint i= 0; i < n; i++) + { + for (lock_t *lock= static_cast<lock_t*>(lock_sys.rec_hash.array[i].node); + lock; ) + { + ut_ad(!lock->is_table()); + if (lock->index == &index) + { + ut_ad(!lock->is_waiting()); + lock_rec_discard(lock_sys.rec_hash, lock); + lock= static_cast<lock_t*>(lock_sys.rec_hash.array[i].node); + } + else + lock= lock->hash; + } + } } /*============= RECORD LOCK MOVING AND INHERITING ===================*/ @@ -2261,58 +2126,35 @@ lock_rec_free_all_from_discard_page( /*************************************************************//** Resets the lock bits for a single record. Releases transactions waiting for lock requests here. */ +TRANSACTIONAL_TARGET static void -lock_rec_reset_and_release_wait_low( -/*================================*/ - hash_table_t* hash, /*!< in: hash table */ - const buf_block_t* block, /*!< in: buffer block containing - the record */ - ulint heap_no)/*!< in: heap number of record */ -{ - lock_t* lock; - - ut_ad(lock_mutex_own()); - - for (lock = lock_rec_get_first(hash, block, heap_no); - lock != NULL; - lock = lock_rec_get_next(heap_no, lock)) { - - if (lock_get_wait(lock)) { - lock_rec_cancel(lock); - } else { - lock_rec_reset_nth_bit(lock, heap_no); - } - } -} - -/*************************************************************//** -Resets the lock bits for a single record. Releases transactions waiting for -lock requests here. */ -static -void -lock_rec_reset_and_release_wait( -/*============================*/ - const buf_block_t* block, /*!< in: buffer block containing - the record */ - ulint heap_no)/*!< in: heap number of record */ +lock_rec_reset_and_release_wait(const hash_cell_t &cell, const page_id_t id, + ulint heap_no) { - lock_rec_reset_and_release_wait_low( - &lock_sys.rec_hash, block, heap_no); - - lock_rec_reset_and_release_wait_low( - &lock_sys.prdt_hash, block, PAGE_HEAP_NO_INFIMUM); - lock_rec_reset_and_release_wait_low( - &lock_sys.prdt_page_hash, block, PAGE_HEAP_NO_INFIMUM); + for (lock_t *lock= lock_sys.get_first(cell, id, heap_no); lock; + lock= lock_rec_get_next(heap_no, lock)) + { + if (lock->is_waiting()) + lock_rec_cancel(lock); + else + { + TMTrxGuard tg{*lock->trx}; + lock_rec_reset_nth_bit(lock, heap_no); + } + } } /** Makes a record to inherit the locks (except LOCK_INSERT_INTENTION type) of another record as gap type locks, but does not reset the lock bits of the other record. Also waiting lock requests on rec are inherited as GRANTED gap locks. -@param heir_block block containing the record which inherits -@param block block containing the record from which inherited; does NOT reset - the locks on this record +@param heir_cell heir hash table cell +@param heir page containing the record which inherits +@param donor_cell donor hash table cell +@param donor page containing the record from which inherited; does NOT + reset the locks on this record +@param heir_page heir page frame @param heir_heap_no heap_no of the inheriting record @param heap_no heap_no of the donating record @tparam from_split true if the function is invoked from @@ -2320,11 +2162,12 @@ GRANTED gap locks. locks are not inherited to supremum if transaction isolation level less or equal to READ COMMITTED */ template <bool from_split= false> -static void lock_rec_inherit_to_gap(const buf_block_t *heir_block, - const buf_block_t *block, - ulint heir_heap_no, ulint heap_no) +static void +lock_rec_inherit_to_gap(hash_cell_t &heir_cell, const page_id_t heir, + const hash_cell_t &donor_cell, const page_id_t donor, + const page_t *heir_page, ulint heir_heap_no, + ulint heap_no) { - ut_ad(lock_mutex_own()); ut_ad(!from_split || heir_heap_no == PAGE_HEAP_NO_SUPREMUM); /* At READ UNCOMMITTED or READ COMMITTED isolation level, @@ -2333,13 +2176,13 @@ static void lock_rec_inherit_to_gap(const buf_block_t *heir_block, DO want S-locks/X-locks(taken for replace) set by a consistency constraint to be inherited also then. */ - for (lock_t *lock= lock_rec_get_first(&lock_sys.rec_hash, block, heap_no); - lock != NULL; lock= lock_rec_get_next(heap_no, lock)) + for (lock_t *lock= lock_sys_t::get_first(donor_cell, donor, heap_no); lock; + lock= lock_rec_get_next(heap_no, lock)) { - + trx_t *lock_trx= lock->trx; if (!lock->trx->is_not_inheriting_locks() && - !lock_rec_get_insert_intention(lock) && - (lock->trx->isolation_level > TRX_ISO_READ_COMMITTED || + !lock->is_insert_intention() && + (lock_trx->isolation_level > TRX_ISO_READ_COMMITTED || /* When we are in a page split (not purge), then we don't set a lock on supremum if the donor lock type is LOCK_REC_NOT_GAP. That is, do not create bogus gap locks for non-gap locks for READ UNCOMMITTED and @@ -2347,11 +2190,11 @@ static void lock_rec_inherit_to_gap(const buf_block_t *heir_block, LOCK_GAP require a gap before the record to be locked, that is why setting lock on supremmum is necessary. */ ((!from_split || !lock->is_record_not_gap()) && - (lock_get_mode(lock) != (lock->trx->duplicates ? LOCK_S : LOCK_X))))) + lock->mode() != (lock_trx->duplicates ? LOCK_S : LOCK_X)))) { - lock_rec_add_to_queue(LOCK_REC | LOCK_GAP | lock_get_mode(lock), - heir_block, heir_heap_no, lock->index, lock->trx, - FALSE); + lock_rec_add_to_queue(LOCK_GAP | lock->mode(), heir_cell, heir, + heir_page, heir_heap_no, lock->index, lock_trx, + false); } } } @@ -2372,40 +2215,33 @@ lock_rec_inherit_to_gap_if_gap_lock( does NOT reset the locks on this record */ { - lock_t* lock; - - lock_mutex_enter(); - - for (lock = lock_rec_get_first(&lock_sys.rec_hash, block, heap_no); - lock != NULL; - lock = lock_rec_get_next(heap_no, lock)) { - - if (!lock->trx->is_not_inheriting_locks() - && !lock_rec_get_insert_intention(lock) - && (heap_no == PAGE_HEAP_NO_SUPREMUM - || !lock_rec_get_rec_not_gap(lock))) { - - lock_rec_add_to_queue( - LOCK_REC | LOCK_GAP | lock_get_mode(lock), - block, heir_heap_no, lock->index, - lock->trx, FALSE); - } - } + const page_id_t id{block->page.id()}; + LockGuard g{lock_sys.rec_hash, id}; - lock_mutex_exit(); + for (lock_t *lock= lock_sys_t::get_first(g.cell(), id, heap_no); lock; + lock= lock_rec_get_next(heap_no, lock)) + if (!lock->trx->is_not_inheriting_locks() && + !lock->is_insert_intention() && (heap_no == PAGE_HEAP_NO_SUPREMUM || + !lock->is_record_not_gap()) && + !lock_table_has(lock->trx, lock->index->table, LOCK_X)) + lock_rec_add_to_queue(LOCK_GAP | lock->mode(), + g.cell(), id, block->page.frame, + heir_heap_no, lock->index, lock->trx, false); } /*************************************************************//** Moves the locks of a record to another record and resets the lock bits of the donating record. */ +TRANSACTIONAL_TARGET static void -lock_rec_move_low( -/*==============*/ - hash_table_t* lock_hash, /*!< in: hash table to use */ - const buf_block_t* receiver, /*!< in: buffer block containing +lock_rec_move( + hash_cell_t& receiver_cell, /*!< in: hash table cell */ + const buf_block_t& receiver, /*!< in: buffer block containing the receiving record */ - const buf_block_t* donator, /*!< in: buffer block containing + const page_id_t receiver_id, /*!< in: page identifier */ + const hash_cell_t& donator_cell, /*!< in: hash table cell */ + const page_id_t donator_id, /*!< in: page identifier of the donating record */ ulint receiver_heap_no,/*!< in: heap_no of the record which gets the locks; there @@ -2414,39 +2250,35 @@ lock_rec_move_low( ulint donator_heap_no)/*!< in: heap_no of the record which gives the locks */ { - lock_t* lock; + ut_ad(!lock_sys_t::get_first(receiver_cell, + receiver_id, receiver_heap_no)); - ut_ad(lock_mutex_own()); - - /* If the lock is predicate lock, it resides on INFIMUM record */ - ut_ad(lock_rec_get_first( - lock_hash, receiver, receiver_heap_no) == NULL - || lock_hash == &lock_sys.prdt_hash - || lock_hash == &lock_sys.prdt_page_hash); - - for (lock = lock_rec_get_first(lock_hash, - donator, donator_heap_no); + for (lock_t *lock = lock_sys_t::get_first(donator_cell, donator_id, + donator_heap_no); lock != NULL; lock = lock_rec_get_next(donator_heap_no, lock)) { - const auto type_mode = lock->type_mode; - - lock_rec_reset_nth_bit(lock, donator_heap_no); - if (type_mode & LOCK_WAIT) { - lock_reset_lock_and_trx_wait(lock); + ut_ad(lock->trx->lock.wait_lock == lock); + lock->type_mode &= ~LOCK_WAIT; } + trx_t* lock_trx = lock->trx; + lock_trx->mutex_lock(); + lock_rec_reset_nth_bit(lock, donator_heap_no); + /* Note that we FIRST reset the bit, and then set the lock: - the function works also if donator == receiver */ + the function works also if donator_id == receiver_id */ - lock_rec_add_to_queue( - type_mode, receiver, receiver_heap_no, - lock->index, lock->trx, FALSE); + lock_rec_add_to_queue(type_mode, receiver_cell, + receiver_id, receiver.page.frame, + receiver_heap_no, + lock->index, lock_trx, true); + lock_trx->mutex_unlock(); } - ut_ad(!lock_rec_get_first(&lock_sys.rec_hash, - donator, donator_heap_no)); + ut_ad(!lock_sys_t::get_first(donator_cell, donator_id, + donator_heap_no)); } /** Move all the granted locks to the front of the given lock list. @@ -2483,32 +2315,11 @@ lock_move_granted_locks_to_front( } /*************************************************************//** -Moves the locks of a record to another record and resets the lock bits of -the donating record. */ -UNIV_INLINE -void -lock_rec_move( -/*==========*/ - const buf_block_t* receiver, /*!< in: buffer block containing - the receiving record */ - const buf_block_t* donator, /*!< in: buffer block containing - the donating record */ - ulint receiver_heap_no,/*!< in: heap_no of the record - which gets the locks; there - must be no lock requests - on it! */ - ulint donator_heap_no)/*!< in: heap_no of the record - which gives the locks */ -{ - lock_rec_move_low(&lock_sys.rec_hash, receiver, donator, - receiver_heap_no, donator_heap_no); -} - -/*************************************************************//** Updates the lock table when we have reorganized a page. NOTE: we copy also the locks set on the infimum of the page; the infimum may carry locks if an update of a record is occurring on the page, and its locks were temporarily stored on the infimum. */ +TRANSACTIONAL_TARGET void lock_move_reorganize_page( /*======================*/ @@ -2517,125 +2328,149 @@ lock_move_reorganize_page( const buf_block_t* oblock) /*!< in: copy of the old, not reorganized page */ { - lock_t* lock; - UT_LIST_BASE_NODE_T(lock_t) old_locks; - mem_heap_t* heap = NULL; - ulint comp; + mem_heap_t *heap; - lock_mutex_enter(); + { + UT_LIST_BASE_NODE_T(lock_t) old_locks; + UT_LIST_INIT(old_locks, &lock_t::trx_locks); - /* FIXME: This needs to deal with predicate lock too */ - lock = lock_sys.get_first(block->page.id()); + const page_id_t id{block->page.id()}; + const auto id_fold= id.fold(); + { + TMLockGuard g{lock_sys.rec_hash, id}; + if (!lock_sys_t::get_first(g.cell(), id)) + return; + } - if (lock == NULL) { - lock_mutex_exit(); + /* We will modify arbitrary trx->lock.trx_locks. + Do not bother with a memory transaction; we are going + to allocate memory and copy a lot of data. */ + LockMutexGuard g{SRW_LOCK_CALL}; + hash_cell_t &cell= *lock_sys.rec_hash.cell_get(id_fold); - return; - } + /* Note: Predicate locks for SPATIAL INDEX are not affected by + page reorganize, because they do not refer to individual record + heap numbers. */ + lock_t *lock= lock_sys_t::get_first(cell, id); - heap = mem_heap_create(256); + if (!lock) + return; - /* Copy first all the locks on the page to heap and reset the - bitmaps in the original locks; chain the copies of the locks - using the trx_locks field in them. */ + heap= mem_heap_create(256); - UT_LIST_INIT(old_locks, &lock_t::trx_locks); + /* Copy first all the locks on the page to heap and reset the + bitmaps in the original locks; chain the copies of the locks + using the trx_locks field in them. */ - do { - /* Make a copy of the lock */ - lock_t* old_lock = lock_rec_copy(lock, heap); + do + { + /* Make a copy of the lock */ + lock_t *old_lock= lock_rec_copy(lock, heap); - UT_LIST_ADD_LAST(old_locks, old_lock); + UT_LIST_ADD_LAST(old_locks, old_lock); - /* Reset bitmap of lock */ - lock_rec_bitmap_reset(lock); + /* Reset bitmap of lock */ + lock_rec_bitmap_reset(lock); - if (lock_get_wait(lock)) { + if (lock->is_waiting()) + { + ut_ad(lock->trx->lock.wait_lock == lock); + lock->type_mode&= ~LOCK_WAIT; + } - lock_reset_lock_and_trx_wait(lock); - } + lock= lock_rec_get_next_on_page(lock); + } + while (lock); - lock = lock_rec_get_next_on_page(lock); - } while (lock != NULL); + const ulint comp= page_is_comp(block->page.frame); + ut_ad(comp == page_is_comp(oblock->page.frame)); - comp = page_is_comp(block->frame); - ut_ad(comp == page_is_comp(oblock->frame)); + lock_move_granted_locks_to_front(old_locks); - lock_move_granted_locks_to_front(old_locks); + DBUG_EXECUTE_IF("do_lock_reverse_page_reorganize", + ut_list_reverse(old_locks);); - DBUG_EXECUTE_IF("do_lock_reverse_page_reorganize", - ut_list_reverse(old_locks);); + for (lock= UT_LIST_GET_FIRST(old_locks); lock; + lock= UT_LIST_GET_NEXT(trx_locks, lock)) + { + /* NOTE: we copy also the locks set on the infimum and + supremum of the page; the infimum may carry locks if an + update of a record is occurring on the page, and its locks + were temporarily stored on the infimum */ + const rec_t *rec1= page_get_infimum_rec(block->page.frame); + const rec_t *rec2= page_get_infimum_rec(oblock->page.frame); + + /* Set locks according to old locks */ + for (;;) + { + ulint old_heap_no; + ulint new_heap_no; + ut_d(const rec_t* const orec= rec1); + ut_ad(page_rec_is_metadata(rec1) == page_rec_is_metadata(rec2)); - for (lock = UT_LIST_GET_FIRST(old_locks); lock; - lock = UT_LIST_GET_NEXT(trx_locks, lock)) { + if (comp) + { + old_heap_no= rec_get_heap_no_new(rec2); + new_heap_no= rec_get_heap_no_new(rec1); - /* NOTE: we copy also the locks set on the infimum and - supremum of the page; the infimum may carry locks if an - update of a record is occurring on the page, and its locks - were temporarily stored on the infimum */ - const rec_t* rec1 = page_get_infimum_rec( - buf_block_get_frame(block)); - const rec_t* rec2 = page_get_infimum_rec( - buf_block_get_frame(oblock)); - - /* Set locks according to old locks */ - for (;;) { - ulint old_heap_no; - ulint new_heap_no; - ut_d(const rec_t* const orec = rec1); - ut_ad(page_rec_is_metadata(rec1) - == page_rec_is_metadata(rec2)); - - if (comp) { - old_heap_no = rec_get_heap_no_new(rec2); - new_heap_no = rec_get_heap_no_new(rec1); - - rec1 = page_rec_get_next_low(rec1, TRUE); - rec2 = page_rec_get_next_low(rec2, TRUE); - } else { - old_heap_no = rec_get_heap_no_old(rec2); - new_heap_no = rec_get_heap_no_old(rec1); - ut_ad(!memcmp(rec1, rec2, - rec_get_data_size_old(rec2))); - - rec1 = page_rec_get_next_low(rec1, FALSE); - rec2 = page_rec_get_next_low(rec2, FALSE); - } + rec1= page_rec_get_next_low(rec1, TRUE); + rec2= page_rec_get_next_low(rec2, TRUE); + } + else + { + old_heap_no= rec_get_heap_no_old(rec2); + new_heap_no= rec_get_heap_no_old(rec1); + ut_ad(!memcmp(rec1, rec2, rec_get_data_size_old(rec2))); - /* Clear the bit in old_lock. */ - if (old_heap_no < lock->un_member.rec_lock.n_bits - && lock_rec_reset_nth_bit(lock, old_heap_no)) { - ut_ad(!page_rec_is_metadata(orec)); + rec1= page_rec_get_next_low(rec1, FALSE); + rec2= page_rec_get_next_low(rec2, FALSE); + } - /* NOTE that the old lock bitmap could be too - small for the new heap number! */ + trx_t *lock_trx= lock->trx; + lock_trx->mutex_lock(); - lock_rec_add_to_queue( - lock->type_mode, block, new_heap_no, - lock->index, lock->trx, FALSE); - } + /* Clear the bit in old_lock. */ + if (old_heap_no < lock->un_member.rec_lock.n_bits && + lock_rec_reset_nth_bit(lock, old_heap_no)) + { + ut_ad(!page_rec_is_metadata(orec)); - if (new_heap_no == PAGE_HEAP_NO_SUPREMUM) { - ut_ad(old_heap_no == PAGE_HEAP_NO_SUPREMUM); - break; - } - } + /* NOTE that the old lock bitmap could be too + small for the new heap number! */ + lock_rec_add_to_queue(lock->type_mode, cell, id, block->page.frame, + new_heap_no, lock->index, lock_trx, true); + } - ut_ad(lock_rec_find_set_bit(lock) == ULINT_UNDEFINED); - } + lock_trx->mutex_unlock(); + + if (!rec1 || !rec2) + { + ut_ad(!rec1 == !rec2); + ut_ad(new_heap_no == PAGE_HEAP_NO_SUPREMUM); + ut_ad(old_heap_no == PAGE_HEAP_NO_SUPREMUM); + break; + } + } - lock_mutex_exit(); + ut_ad(lock_rec_find_set_bit(lock) == ULINT_UNDEFINED); + } + } - mem_heap_free(heap); + mem_heap_free(heap); #ifdef UNIV_DEBUG_LOCK_VALIDATE - ut_ad(lock_rec_validate_page(block)); + if (fil_space_t *space= fil_space_t::get(id.space())) + { + ut_ad(lock_rec_validate_page(block, space->is_latched())); + space->release(); + } #endif } /*************************************************************//** Moves the explicit locks on user records to another page if a record list end is moved to another page. */ +TRANSACTIONAL_TARGET void lock_move_rec_list_end( /*===================*/ @@ -2644,111 +2479,133 @@ lock_move_rec_list_end( const rec_t* rec) /*!< in: record on page: this is the first record moved */ { - lock_t* lock; - const ulint comp = page_rec_is_comp(rec); - - ut_ad(buf_block_get_frame(block) == page_align(rec)); - ut_ad(comp == page_is_comp(buf_block_get_frame(new_block))); + const ulint comp= page_rec_is_comp(rec); - lock_mutex_enter(); + ut_ad(block->page.frame == page_align(rec)); + ut_ad(comp == page_is_comp(new_block->page.frame)); - /* Note: when we move locks from record to record, waiting locks - and possible granted gap type locks behind them are enqueued in - the original order, because new elements are inserted to a hash - table to the end of the hash chain, and lock_rec_add_to_queue - does not reuse locks if there are waiters in the queue. */ - - for (lock = lock_sys.get_first(block->page.id()); - lock; - lock = lock_rec_get_next_on_page(lock)) { - const rec_t* rec1 = rec; - const rec_t* rec2; - const auto type_mode = lock->type_mode; - - if (comp) { - if (page_offset(rec1) == PAGE_NEW_INFIMUM) { - rec1 = page_rec_get_next_low(rec1, TRUE); - } - - rec2 = page_rec_get_next_low( - buf_block_get_frame(new_block) - + PAGE_NEW_INFIMUM, TRUE); - } else { - if (page_offset(rec1) == PAGE_OLD_INFIMUM) { - rec1 = page_rec_get_next_low(rec1, FALSE); - } - - rec2 = page_rec_get_next_low( - buf_block_get_frame(new_block) - + PAGE_OLD_INFIMUM, FALSE); - } - - /* Copy lock requests on user records to new page and - reset the lock bits on the old */ - - for (;;) { - ut_ad(page_rec_is_metadata(rec1) - == page_rec_is_metadata(rec2)); - ut_d(const rec_t* const orec = rec1); - - ulint rec1_heap_no; - ulint rec2_heap_no; - - if (comp) { - rec1_heap_no = rec_get_heap_no_new(rec1); + const page_id_t id{block->page.id()}; + const page_id_t new_id{new_block->page.id()}; + { + /* This would likely be too large for a memory transaction. */ + LockMultiGuard g{lock_sys.rec_hash, id, new_id}; + + /* Note: when we move locks from record to record, waiting locks + and possible granted gap type locks behind them are enqueued in + the original order, because new elements are inserted to a hash + table to the end of the hash chain, and lock_rec_add_to_queue + does not reuse locks if there are waiters in the queue. */ + for (lock_t *lock= lock_sys_t::get_first(g.cell1(), id); lock; + lock= lock_rec_get_next_on_page(lock)) + { + const rec_t *rec1= rec; + const rec_t *rec2; + const auto type_mode= lock->type_mode; - if (rec1_heap_no == PAGE_HEAP_NO_SUPREMUM) { - break; - } + if (comp) + { + if (page_offset(rec1) == PAGE_NEW_INFIMUM) + rec1= page_rec_get_next_low(rec1, TRUE); + rec2= page_rec_get_next_low(new_block->page.frame + PAGE_NEW_INFIMUM, + TRUE); + } + else + { + if (page_offset(rec1) == PAGE_OLD_INFIMUM) + rec1= page_rec_get_next_low(rec1, FALSE); + rec2= page_rec_get_next_low(new_block->page.frame + PAGE_OLD_INFIMUM, + FALSE); + } - rec2_heap_no = rec_get_heap_no_new(rec2); - rec1 = page_rec_get_next_low(rec1, TRUE); - rec2 = page_rec_get_next_low(rec2, TRUE); - } else { - rec1_heap_no = rec_get_heap_no_old(rec1); + if (UNIV_UNLIKELY(!rec1 || !rec2)) + { + ut_ad("corrupted page" == 0); + return; + } - if (rec1_heap_no == PAGE_HEAP_NO_SUPREMUM) { - break; - } + /* Copy lock requests on user records to new page and + reset the lock bits on the old */ + for (;;) + { + ut_ad(page_rec_is_metadata(rec1) == page_rec_is_metadata(rec2)); + ut_d(const rec_t* const orec= rec1); - rec2_heap_no = rec_get_heap_no_old(rec2); + ulint rec1_heap_no; + ulint rec2_heap_no; - ut_ad(rec_get_data_size_old(rec1) - == rec_get_data_size_old(rec2)); + if (comp) + { + rec1_heap_no= rec_get_heap_no_new(rec1); + if (!(rec1= page_rec_get_next_low(rec1, TRUE))) + { + ut_ad(rec1_heap_no == PAGE_HEAP_NO_SUPREMUM); + break; + } + rec2_heap_no= rec_get_heap_no_new(rec2); + rec2= page_rec_get_next_low(rec2, TRUE); + } + else + { + ut_d(const rec_t *old1= rec1); + rec1_heap_no= rec_get_heap_no_old(rec1); + if (!(rec1= page_rec_get_next_low(rec1, FALSE))) + { + ut_ad(rec1_heap_no == PAGE_HEAP_NO_SUPREMUM); + break; + } + + ut_ad(rec_get_data_size_old(old1) == rec_get_data_size_old(rec2)); + ut_ad(!memcmp(old1, rec2, rec_get_data_size_old(old1))); + + rec2_heap_no= rec_get_heap_no_old(rec2); + rec2= page_rec_get_next_low(rec2, FALSE); + } - ut_ad(!memcmp(rec1, rec2, - rec_get_data_size_old(rec1))); + if (UNIV_UNLIKELY(!rec2)) + { + ut_ad("corrupted page" == 0); + return; + } - rec1 = page_rec_get_next_low(rec1, FALSE); - rec2 = page_rec_get_next_low(rec2, FALSE); - } + trx_t *lock_trx= lock->trx; + lock_trx->mutex_lock(); - if (rec1_heap_no < lock->un_member.rec_lock.n_bits - && lock_rec_reset_nth_bit(lock, rec1_heap_no)) { - ut_ad(!page_rec_is_metadata(orec)); + if (rec1_heap_no < lock->un_member.rec_lock.n_bits && + lock_rec_reset_nth_bit(lock, rec1_heap_no)) + { + ut_ad(!page_rec_is_metadata(orec)); - if (type_mode & LOCK_WAIT) { - lock_reset_lock_and_trx_wait(lock); - } + if (type_mode & LOCK_WAIT) + { + ut_ad(lock_trx->lock.wait_lock == lock); + lock->type_mode&= ~LOCK_WAIT; + } - lock_rec_add_to_queue( - type_mode, new_block, rec2_heap_no, - lock->index, lock->trx, FALSE); - } - } - } + lock_rec_add_to_queue(type_mode, g.cell2(), new_id, + new_block->page.frame, + rec2_heap_no, lock->index, lock_trx, true); + } - lock_mutex_exit(); + lock_trx->mutex_unlock(); + } + } + } #ifdef UNIV_DEBUG_LOCK_VALIDATE - ut_ad(lock_rec_validate_page(block)); - ut_ad(lock_rec_validate_page(new_block)); + if (fil_space_t *space= fil_space_t::get(id.space())) + { + const bool is_latched{space->is_latched()}; + ut_ad(lock_rec_validate_page(block, is_latched)); + ut_ad(lock_rec_validate_page(new_block, is_latched)); + space->release(); + } #endif } /*************************************************************//** Moves the explicit locks on user records to another page if a record list start is moved to another page. */ +TRANSACTIONAL_TARGET void lock_move_rec_list_start( /*=====================*/ @@ -2764,104 +2621,114 @@ lock_move_rec_list_start( before the records were copied */ { - lock_t* lock; - const ulint comp = page_rec_is_comp(rec); + const ulint comp= page_rec_is_comp(rec); - ut_ad(block->frame == page_align(rec)); - ut_ad(new_block->frame == page_align(old_end)); - ut_ad(comp == page_rec_is_comp(old_end)); - ut_ad(!page_rec_is_metadata(rec)); + ut_ad(block->page.frame == page_align(rec)); + ut_ad(comp == page_is_comp(new_block->page.frame)); + ut_ad(new_block->page.frame == page_align(old_end)); + ut_ad(!page_rec_is_metadata(rec)); + const page_id_t id{block->page.id()}; + const page_id_t new_id{new_block->page.id()}; - lock_mutex_enter(); + { + /* This would likely be too large for a memory transaction. */ + LockMultiGuard g{lock_sys.rec_hash, id, new_id}; - for (lock = lock_sys.get_first(block->page.id()); - lock; - lock = lock_rec_get_next_on_page(lock)) { - const rec_t* rec1; - const rec_t* rec2; - const auto type_mode = lock->type_mode; - - if (comp) { - rec1 = page_rec_get_next_low( - buf_block_get_frame(block) - + PAGE_NEW_INFIMUM, TRUE); - rec2 = page_rec_get_next_low(old_end, TRUE); - } else { - rec1 = page_rec_get_next_low( - buf_block_get_frame(block) - + PAGE_OLD_INFIMUM, FALSE); - rec2 = page_rec_get_next_low(old_end, FALSE); - } + for (lock_t *lock= lock_sys_t::get_first(g.cell1(), id); lock; + lock= lock_rec_get_next_on_page(lock)) + { + const rec_t *rec1; + const rec_t *rec2; + const auto type_mode= lock->type_mode; - /* Copy lock requests on user records to new page and - reset the lock bits on the old */ + if (comp) + { + rec1= page_rec_get_next_low(block->page.frame + PAGE_NEW_INFIMUM, + TRUE); + rec2= page_rec_get_next_low(old_end, TRUE); + } + else + { + rec1= page_rec_get_next_low(block->page.frame + PAGE_OLD_INFIMUM, + FALSE); + rec2= page_rec_get_next_low(old_end, FALSE); + } - while (rec1 != rec) { - ut_ad(page_rec_is_metadata(rec1) - == page_rec_is_metadata(rec2)); - ut_d(const rec_t* const prev = rec1); + /* Copy lock requests on user records to new page and + reset the lock bits on the old */ - ulint rec1_heap_no; - ulint rec2_heap_no; + while (rec1 != rec) + { + if (UNIV_UNLIKELY(!rec1 || !rec2)) + { + ut_ad("corrupted page" == 0); + return; + } - if (comp) { - rec1_heap_no = rec_get_heap_no_new(rec1); - rec2_heap_no = rec_get_heap_no_new(rec2); + ut_ad(page_rec_is_metadata(rec1) == page_rec_is_metadata(rec2)); + ut_d(const rec_t* const prev= rec1); - rec1 = page_rec_get_next_low(rec1, TRUE); - rec2 = page_rec_get_next_low(rec2, TRUE); - } else { - rec1_heap_no = rec_get_heap_no_old(rec1); - rec2_heap_no = rec_get_heap_no_old(rec2); + ulint rec1_heap_no; + ulint rec2_heap_no; - ut_ad(!memcmp(rec1, rec2, - rec_get_data_size_old(rec2))); + if (comp) + { + rec1_heap_no= rec_get_heap_no_new(rec1); + rec2_heap_no= rec_get_heap_no_new(rec2); - rec1 = page_rec_get_next_low(rec1, FALSE); - rec2 = page_rec_get_next_low(rec2, FALSE); - } + rec1= page_rec_get_next_low(rec1, TRUE); + rec2= page_rec_get_next_low(rec2, TRUE); + } + else + { + rec1_heap_no= rec_get_heap_no_old(rec1); + rec2_heap_no= rec_get_heap_no_old(rec2); - if (rec1_heap_no < lock->un_member.rec_lock.n_bits - && lock_rec_reset_nth_bit(lock, rec1_heap_no)) { - ut_ad(!page_rec_is_metadata(prev)); + ut_ad(!memcmp(rec1, rec2, rec_get_data_size_old(rec2))); - if (type_mode & LOCK_WAIT) { - lock_reset_lock_and_trx_wait(lock); - } + rec1= page_rec_get_next_low(rec1, FALSE); + rec2= page_rec_get_next_low(rec2, FALSE); + } - lock_rec_add_to_queue( - type_mode, new_block, rec2_heap_no, - lock->index, lock->trx, FALSE); - } - } + trx_t *lock_trx= lock->trx; + lock_trx->mutex_lock(); + + if (rec1_heap_no < lock->un_member.rec_lock.n_bits && + lock_rec_reset_nth_bit(lock, rec1_heap_no)) + { + ut_ad(!page_rec_is_metadata(prev)); + + if (type_mode & LOCK_WAIT) + { + ut_ad(lock_trx->lock.wait_lock == lock); + lock->type_mode&= ~LOCK_WAIT; + } + + lock_rec_add_to_queue(type_mode, g.cell2(), new_id, + new_block->page.frame, + rec2_heap_no, lock->index, lock_trx, true); + } + + lock_trx->mutex_unlock(); + } #ifdef UNIV_DEBUG - if (page_rec_is_supremum(rec)) { - ulint i; - - for (i = PAGE_HEAP_NO_USER_LOW; - i < lock_rec_get_n_bits(lock); i++) { - if (lock_rec_get_nth_bit(lock, i)) { - ib::fatal() - << "lock_move_rec_list_start():" - << i << " not moved in " - << (void*) lock; - } - } - } + if (page_rec_is_supremum(rec)) + for (auto i= lock_rec_get_n_bits(lock); --i > PAGE_HEAP_NO_USER_LOW; ) + ut_ad(!lock_rec_get_nth_bit(lock, i)); #endif /* UNIV_DEBUG */ - } - - lock_mutex_exit(); + } + } #ifdef UNIV_DEBUG_LOCK_VALIDATE - ut_ad(lock_rec_validate_page(block)); + ut_ad(lock_rec_validate_page(block)); #endif } /*************************************************************//** Moves the explicit locks on user records to another page if a record list start is moved to another page. */ +TRANSACTIONAL_TARGET void lock_rtr_move_rec_list( /*===================*/ @@ -2872,74 +2739,80 @@ lock_rtr_move_rec_list( moved */ ulint num_move) /*!< in: num of rec to move */ { - lock_t* lock; - ulint comp; + if (!num_move) + return; - if (!num_move) { - return; - } + const ulint comp= page_rec_is_comp(rec_move[0].old_rec); - comp = page_rec_is_comp(rec_move[0].old_rec); + ut_ad(block->page.frame == page_align(rec_move[0].old_rec)); + ut_ad(new_block->page.frame == page_align(rec_move[0].new_rec)); + ut_ad(comp == page_rec_is_comp(rec_move[0].new_rec)); + const page_id_t id{block->page.id()}; + const page_id_t new_id{new_block->page.id()}; - ut_ad(block->frame == page_align(rec_move[0].old_rec)); - ut_ad(new_block->frame == page_align(rec_move[0].new_rec)); - ut_ad(comp == page_rec_is_comp(rec_move[0].new_rec)); - - lock_mutex_enter(); - - for (lock = lock_sys.get_first(block->page.id()); - lock; - lock = lock_rec_get_next_on_page(lock)) { - ulint moved = 0; - const rec_t* rec1; - const rec_t* rec2; - const auto type_mode = lock->type_mode; + { + /* This would likely be too large for a memory transaction. */ + LockMultiGuard g{lock_sys.rec_hash, id, new_id}; - /* Copy lock requests on user records to new page and - reset the lock bits on the old */ + for (lock_t *lock= lock_sys_t::get_first(g.cell1(), id); lock; + lock= lock_rec_get_next_on_page(lock)) + { + const rec_t *rec1; + const rec_t *rec2; + const auto type_mode= lock->type_mode; - while (moved < num_move) { - ulint rec1_heap_no; - ulint rec2_heap_no; + /* Copy lock requests on user records to new page and + reset the lock bits on the old */ - rec1 = rec_move[moved].old_rec; - rec2 = rec_move[moved].new_rec; - ut_ad(!page_rec_is_metadata(rec1)); - ut_ad(!page_rec_is_metadata(rec2)); + for (ulint moved= 0; moved < num_move; moved++) + { + ulint rec1_heap_no; + ulint rec2_heap_no; - if (comp) { - rec1_heap_no = rec_get_heap_no_new(rec1); - rec2_heap_no = rec_get_heap_no_new(rec2); + rec1= rec_move[moved].old_rec; + rec2= rec_move[moved].new_rec; + ut_ad(!page_rec_is_metadata(rec1)); + ut_ad(!page_rec_is_metadata(rec2)); - } else { - rec1_heap_no = rec_get_heap_no_old(rec1); - rec2_heap_no = rec_get_heap_no_old(rec2); + if (comp) + { + rec1_heap_no= rec_get_heap_no_new(rec1); + rec2_heap_no= rec_get_heap_no_new(rec2); + } + else + { + rec1_heap_no= rec_get_heap_no_old(rec1); + rec2_heap_no= rec_get_heap_no_old(rec2); - ut_ad(!memcmp(rec1, rec2, - rec_get_data_size_old(rec2))); - } + ut_ad(!memcmp(rec1, rec2, rec_get_data_size_old(rec2))); + } - if (rec1_heap_no < lock->un_member.rec_lock.n_bits - && lock_rec_reset_nth_bit(lock, rec1_heap_no)) { - if (type_mode & LOCK_WAIT) { - lock_reset_lock_and_trx_wait(lock); - } + trx_t *lock_trx= lock->trx; + lock_trx->mutex_lock(); - lock_rec_add_to_queue( - type_mode, new_block, rec2_heap_no, - lock->index, lock->trx, FALSE); + if (rec1_heap_no < lock->un_member.rec_lock.n_bits && + lock_rec_reset_nth_bit(lock, rec1_heap_no)) + { + if (type_mode & LOCK_WAIT) + { + ut_ad(lock_trx->lock.wait_lock == lock); + lock->type_mode&= ~LOCK_WAIT; + } - rec_move[moved].moved = true; - } + lock_rec_add_to_queue(type_mode, g.cell2(), new_id, + new_block->page.frame, + rec2_heap_no, lock->index, lock_trx, true); - moved++; - } - } + rec_move[moved].moved= true; + } - lock_mutex_exit(); + lock_trx->mutex_unlock(); + } + } + } #ifdef UNIV_DEBUG_LOCK_VALIDATE - ut_ad(lock_rec_validate_page(block)); + ut_ad(lock_rec_validate_page(block)); #endif } /*************************************************************//** @@ -2950,36 +2823,57 @@ lock_update_split_right( const buf_block_t* right_block, /*!< in: right page */ const buf_block_t* left_block) /*!< in: left page */ { - ulint heap_no = lock_get_min_heap_no(right_block); - - lock_mutex_enter(); - - /* Move the locks on the supremum of the left page to the supremum - of the right page */ + const ulint h= lock_get_min_heap_no(right_block); + const page_id_t l{left_block->page.id()}; + const page_id_t r{right_block->page.id()}; - lock_rec_move(right_block, left_block, - PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM); + /* This would likely be too large for a memory transaction. */ + LockMultiGuard g{lock_sys.rec_hash, l, r}; - /* Inherit the locks to the supremum of left page from the successor - of the infimum on right page */ + /* Move the locks on the supremum of the left page to the supremum + of the right page */ - lock_rec_inherit_to_gap<true>(left_block, right_block, - PAGE_HEAP_NO_SUPREMUM, heap_no); + lock_rec_move(g.cell2(), *right_block, r, g.cell1(), l, + PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM); - lock_mutex_exit(); + /* Inherit the locks to the supremum of left page from the successor + of the infimum on right page */ + lock_rec_inherit_to_gap<true>(g.cell1(), l, g.cell2(), r, + left_block->page.frame, PAGE_HEAP_NO_SUPREMUM, + h); } void lock_update_node_pointer(const buf_block_t *left_block, const buf_block_t *right_block) { const ulint h= lock_get_min_heap_no(right_block); + const page_id_t l{left_block->page.id()}; + const page_id_t r{right_block->page.id()}; + LockMultiGuard g{lock_sys.rec_hash, l, r}; - lock_mutex_enter(); - lock_rec_inherit_to_gap(right_block, left_block, + lock_rec_inherit_to_gap(g.cell2(), r, g.cell1(), l, right_block->page.frame, h, PAGE_HEAP_NO_SUPREMUM); - lock_mutex_exit(); } +#ifdef UNIV_DEBUG +static void lock_assert_no_spatial(const page_id_t id) +{ + const auto id_fold= id.fold(); + auto cell= lock_sys.prdt_page_hash.cell_get(id_fold); + auto latch= lock_sys_t::hash_table::latch(cell); + latch->acquire(); + /* there should exist no page lock on the left page, + otherwise, it will be blocked from merge */ + ut_ad(!lock_sys_t::get_first(*cell, id)); + latch->release(); + cell= lock_sys.prdt_hash.cell_get(id_fold); + latch= lock_sys_t::hash_table::latch(cell); + latch->acquire(); + ut_ad(!lock_sys_t::get_first(*cell, id)); + latch->release(); +} +#endif + /*************************************************************//** Updates the lock table when a page is merged to the right. */ void @@ -2995,77 +2889,56 @@ lock_update_merge_right( page which will be discarded */ { - ut_ad(!page_rec_is_metadata(orig_succ)); - - lock_mutex_enter(); - - /* Inherit the locks from the supremum of the left page to the - original successor of infimum on the right page, to which the left - page was merged */ - - lock_rec_inherit_to_gap(right_block, left_block, - page_rec_get_heap_no(orig_succ), - PAGE_HEAP_NO_SUPREMUM); + ut_ad(!page_rec_is_metadata(orig_succ)); - /* Reset the locks on the supremum of the left page, releasing - waiting transactions */ + const page_id_t l{left_block->page.id()}; + const page_id_t r{right_block->page.id()}; + /* This would likely be too large for a memory transaction. */ + LockMultiGuard g{lock_sys.rec_hash, l, r}; - lock_rec_reset_and_release_wait_low( - &lock_sys.rec_hash, left_block, PAGE_HEAP_NO_SUPREMUM); + /* Inherit the locks from the supremum of the left page to the + original successor of infimum on the right page, to which the left + page was merged */ + lock_rec_inherit_to_gap(g.cell2(), r, g.cell1(), l, right_block->page.frame, + page_rec_get_heap_no(orig_succ), + PAGE_HEAP_NO_SUPREMUM); - /* there should exist no page lock on the left page, - otherwise, it will be blocked from merge */ - ut_ad(!lock_sys.get_first_prdt_page(left_block->page.id())); + /* Reset the locks on the supremum of the left page, releasing + waiting transactions */ + lock_rec_reset_and_release_wait(g.cell1(), l, PAGE_HEAP_NO_SUPREMUM); + lock_rec_free_all_from_discard_page(l, g.cell1(), lock_sys.rec_hash); - lock_rec_free_all_from_discard_page(left_block); - - lock_mutex_exit(); + ut_d(lock_assert_no_spatial(l)); } -/*************************************************************//** -Updates the lock table when the root page is copied to another in -btr_root_raise_and_insert. Note that we leave lock structs on the +/** Update locks when the root page is copied to another in +btr_root_raise_and_insert(). Note that we leave lock structs on the root page, even though they do not make sense on other than leaf pages: the reason is that in a pessimistic update the infimum record of the root page will act as a dummy carrier of the locks of the record to be updated. */ -void -lock_update_root_raise( -/*===================*/ - const buf_block_t* block, /*!< in: index page to which copied */ - const buf_block_t* root) /*!< in: root page */ +void lock_update_root_raise(const buf_block_t &block, const page_id_t root) { - lock_mutex_enter(); - - /* Move the locks on the supremum of the root to the supremum - of block */ - - lock_rec_move(block, root, - PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM); - lock_mutex_exit(); + const page_id_t id{block.page.id()}; + /* This would likely be too large for a memory transaction. */ + LockMultiGuard g{lock_sys.rec_hash, id, root}; + /* Move the locks on the supremum of the root to the supremum of block */ + lock_rec_move(g.cell1(), block, id, g.cell2(), root, + PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM); } -/*************************************************************//** -Updates the lock table when a page is copied to another and the original page -is removed from the chain of leaf pages, except if page is the root! */ -void -lock_update_copy_and_discard( -/*=========================*/ - const buf_block_t* new_block, /*!< in: index page to - which copied */ - const buf_block_t* block) /*!< in: index page; - NOT the root! */ +/** Update the lock table when a page is copied to another. +@param new_block the target page +@param old old page (not index root page) */ +void lock_update_copy_and_discard(const buf_block_t &new_block, page_id_t old) { - lock_mutex_enter(); - - /* Move the locks on the supremum of the old page to the supremum - of new_page */ - - lock_rec_move(new_block, block, - PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM); - lock_rec_free_all_from_discard_page(block); - - lock_mutex_exit(); + const page_id_t id{new_block.page.id()}; + /* This would likely be too large for a memory transaction. */ + LockMultiGuard g{lock_sys.rec_hash, id, old}; + /* Move the locks on the supremum of the old page to the supremum of new */ + lock_rec_move(g.cell1(), new_block, id, g.cell2(), old, + PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM); + lock_rec_free_all_from_discard_page(old, g.cell2(), lock_sys.rec_hash); } /*************************************************************//** @@ -3076,69 +2949,58 @@ lock_update_split_left( const buf_block_t* right_block, /*!< in: right page */ const buf_block_t* left_block) /*!< in: left page */ { - ulint heap_no = lock_get_min_heap_no(right_block); - - lock_mutex_enter(); - - /* Inherit the locks to the supremum of the left page from the - successor of the infimum on the right page */ - - lock_rec_inherit_to_gap<true>(left_block, right_block, - PAGE_HEAP_NO_SUPREMUM, heap_no); - - lock_mutex_exit(); -} - -/*************************************************************//** -Updates the lock table when a page is merged to the left. */ -void -lock_update_merge_left( -/*===================*/ - const buf_block_t* left_block, /*!< in: left page to - which merged */ - const rec_t* orig_pred, /*!< in: original predecessor - of supremum on the left page - before merge */ - const buf_block_t* right_block) /*!< in: merged index page - which will be discarded */ -{ - const rec_t* left_next_rec; - - ut_ad(left_block->frame == page_align(orig_pred)); - - lock_mutex_enter(); - - left_next_rec = page_rec_get_next_const(orig_pred); - - if (!page_rec_is_supremum(left_next_rec)) { - - /* Inherit the locks on the supremum of the left page to the - first record which was moved from the right page */ - - lock_rec_inherit_to_gap(left_block, left_block, - page_rec_get_heap_no(left_next_rec), - PAGE_HEAP_NO_SUPREMUM); - - /* Reset the locks on the supremum of the left page, - releasing waiting transactions */ - - lock_rec_reset_and_release_wait_low( - &lock_sys.rec_hash, left_block, PAGE_HEAP_NO_SUPREMUM); - } - - /* Move the locks from the supremum of right page to the supremum - of the left page */ - - lock_rec_move(left_block, right_block, - PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM); + ulint h= lock_get_min_heap_no(right_block); + const page_id_t l{left_block->page.id()}; + const page_id_t r{right_block->page.id()}; + LockMultiGuard g{lock_sys.rec_hash, l, r}; + /* Inherit the locks to the supremum of the left page from the + successor of the infimum on the right page */ + lock_rec_inherit_to_gap<true>(g.cell1(), l, g.cell2(), r, + left_block->page.frame, PAGE_HEAP_NO_SUPREMUM, + h); +} + +/** Update the lock table when a page is merged to the left. +@param left left page +@param orig_pred original predecessor of supremum on the left page before merge +@param right merged, to-be-discarded right page */ +void lock_update_merge_left(const buf_block_t& left, const rec_t *orig_pred, + const page_id_t right) +{ + ut_ad(left.page.frame == page_align(orig_pred)); + + const page_id_t l{left.page.id()}; + const rec_t *left_next_rec= page_rec_get_next_const(orig_pred); + if (UNIV_UNLIKELY(!left_next_rec)) + { + ut_ad("corrupted page" == 0); + return; + } - /* there should exist no page lock on the right page, - otherwise, it will be blocked from merge */ - ut_ad(!lock_sys.get_first_prdt_page(right_block->page.id())); + /* This would likely be too large for a memory transaction. */ + LockMultiGuard g{lock_sys.rec_hash, l, right}; + if (!page_rec_is_supremum(left_next_rec)) + { + /* Inherit the locks on the supremum of the left page to the + first record which was moved from the right page */ + lock_rec_inherit_to_gap(g.cell1(), l, g.cell1(), l, left.page.frame, + page_rec_get_heap_no(left_next_rec), + PAGE_HEAP_NO_SUPREMUM); + + /* Reset the locks on the supremum of the left page, + releasing waiting transactions */ + lock_rec_reset_and_release_wait(g.cell1(), l, PAGE_HEAP_NO_SUPREMUM); + } - lock_rec_free_all_from_discard_page(right_block); + /* Move the locks from the supremum of right page to the supremum + of the left page */ + lock_rec_move(g.cell1(), left, l, g.cell2(), right, + PAGE_HEAP_NO_SUPREMUM, PAGE_HEAP_NO_SUPREMUM); + lock_rec_free_all_from_discard_page(right, g.cell2(), lock_sys.rec_hash); - lock_mutex_exit(); + /* there should exist no page lock on the right page, + otherwise, it will be blocked from merge */ + ut_d(lock_assert_no_spatial(right)); } /*************************************************************//** @@ -3147,9 +3009,9 @@ inherited from rec. */ void lock_rec_reset_and_inherit_gap_locks( /*=================================*/ - const buf_block_t* heir_block, /*!< in: block containing the + const buf_block_t& heir_block, /*!< in: block containing the record which inherits */ - const buf_block_t* block, /*!< in: block containing the + const page_id_t donor, /*!< in: page containing the record from which inherited; does NOT reset the locks on this record */ @@ -3158,13 +3020,12 @@ lock_rec_reset_and_inherit_gap_locks( ulint heap_no) /*!< in: heap_no of the donating record */ { - lock_mutex_enter(); - - lock_rec_reset_and_release_wait(heir_block, heir_heap_no); - - lock_rec_inherit_to_gap(heir_block, block, heir_heap_no, heap_no); - - lock_mutex_exit(); + const page_id_t heir{heir_block.page.id()}; + /* This is a rare operation and likely too large for a memory transaction. */ + LockMultiGuard g{lock_sys.rec_hash, heir, donor}; + lock_rec_reset_and_release_wait(g.cell1(), heir, heir_heap_no); + lock_rec_inherit_to_gap(g.cell1(), heir, g.cell2(), donor, + heir_block.page.frame, heir_heap_no, heap_no); } /*************************************************************//** @@ -3179,16 +3040,16 @@ lock_update_discard( const buf_block_t* block) /*!< in: index page which will be discarded */ { - const page_t* page = block->frame; + const page_t* page = block->page.frame; const rec_t* rec; ulint heap_no; + const page_id_t heir(heir_block->page.id()); const page_id_t page_id(block->page.id()); + /* This would likely be too large for a memory transaction. */ + LockMultiGuard g{lock_sys.rec_hash, heir, page_id}; - lock_mutex_enter(); - - if (lock_sys.get_first(page_id)) { - ut_ad(!lock_sys.get_first_prdt(page_id)); - ut_ad(!lock_sys.get_first_prdt_page(page_id)); + if (lock_sys_t::get_first(g.cell2(), page_id)) { + ut_d(lock_assert_no_spatial(page_id)); /* Inherit all the locks on the page to the record and reset all the locks on the page */ @@ -3198,11 +3059,13 @@ lock_update_discard( do { heap_no = rec_get_heap_no_new(rec); - lock_rec_inherit_to_gap(heir_block, block, + lock_rec_inherit_to_gap(g.cell1(), heir, + g.cell2(), page_id, + heir_block->page.frame, heir_heap_no, heap_no); lock_rec_reset_and_release_wait( - block, heap_no); + g.cell2(), page_id, heap_no); rec = page + rec_get_next_offs(rec, TRUE); } while (heap_no != PAGE_HEAP_NO_SUPREMUM); @@ -3212,26 +3075,35 @@ lock_update_discard( do { heap_no = rec_get_heap_no_old(rec); - lock_rec_inherit_to_gap(heir_block, block, + lock_rec_inherit_to_gap(g.cell1(), heir, + g.cell2(), page_id, + heir_block->page.frame, heir_heap_no, heap_no); lock_rec_reset_and_release_wait( - block, heap_no); + g.cell2(), page_id, heap_no); rec = page + rec_get_next_offs(rec, FALSE); } while (heap_no != PAGE_HEAP_NO_SUPREMUM); } - lock_rec_free_all_from_discard_page_low(page_id, - &lock_sys.rec_hash); + lock_rec_free_all_from_discard_page(page_id, g.cell2(), + lock_sys.rec_hash); } else { - lock_rec_free_all_from_discard_page_low(page_id, - &lock_sys.prdt_hash); - lock_rec_free_all_from_discard_page_low( - page_id, &lock_sys.prdt_page_hash); + const auto fold = page_id.fold(); + auto cell = lock_sys.prdt_hash.cell_get(fold); + auto latch = lock_sys_t::hash_table::latch(cell); + latch->acquire(); + lock_rec_free_all_from_discard_page(page_id, *cell, + lock_sys.prdt_hash); + latch->release(); + cell = lock_sys.prdt_page_hash.cell_get(fold); + latch = lock_sys_t::hash_table::latch(cell); + latch->acquire(); + lock_rec_free_all_from_discard_page(page_id, *cell, + lock_sys.prdt_page_hash); + latch->release(); } - - lock_mutex_exit(); } /*************************************************************//** @@ -3245,7 +3117,7 @@ lock_update_insert( ulint receiver_heap_no; ulint donator_heap_no; - ut_ad(block->frame == page_align(rec)); + ut_ad(block->page.frame == page_align(rec)); ut_ad(!page_rec_is_metadata(rec)); /* Inherit the gap-locking locks for rec, in gap mode, from the next @@ -3253,12 +3125,18 @@ lock_update_insert( if (page_rec_is_comp(rec)) { receiver_heap_no = rec_get_heap_no_new(rec); - donator_heap_no = rec_get_heap_no_new( - page_rec_get_next_low(rec, TRUE)); + rec = page_rec_get_next_low(rec, TRUE); + if (UNIV_UNLIKELY(!rec)) { + return; + } + donator_heap_no = rec_get_heap_no_new(rec); } else { receiver_heap_no = rec_get_heap_no_old(rec); - donator_heap_no = rec_get_heap_no_old( - page_rec_get_next_low(rec, FALSE)); + rec = page_rec_get_next_low(rec, FALSE); + if (UNIV_UNLIKELY(!rec)) { + return; + } + donator_heap_no = rec_get_heap_no_old(rec); } lock_rec_inherit_to_gap_if_gap_lock( @@ -3273,7 +3151,7 @@ lock_update_delete( const buf_block_t* block, /*!< in: buffer block containing rec */ const rec_t* rec) /*!< in: the record to be removed */ { - const page_t* page = block->frame; + const page_t* page = block->page.frame; ulint heap_no; ulint next_heap_no; @@ -3292,17 +3170,16 @@ lock_update_delete( FALSE)); } - lock_mutex_enter(); + const page_id_t id{block->page.id()}; + LockGuard g{lock_sys.rec_hash, id}; /* Let the next record inherit the locks from rec, in gap mode */ - lock_rec_inherit_to_gap(block, block, next_heap_no, heap_no); + lock_rec_inherit_to_gap(g.cell(), id, g.cell(), id, block->page.frame, + next_heap_no, heap_no); /* Reset the lock bits on rec and release waiting transactions */ - - lock_rec_reset_and_release_wait(block, heap_no); - - lock_mutex_exit(); + lock_rec_reset_and_release_wait(g.cell(), id, heap_no); } /*********************************************************************//** @@ -3322,102 +3199,89 @@ lock_rec_store_on_page_infimum( bits are reset on the record */ { - ulint heap_no = page_rec_get_heap_no(rec); - - ut_ad(block->frame == page_align(rec)); + const ulint heap_no= page_rec_get_heap_no(rec); - lock_mutex_enter(); + ut_ad(block->page.frame == page_align(rec)); + const page_id_t id{block->page.id()}; + ut_d(SCOPE_EXIT( + []() { DEBUG_SYNC_C("lock_rec_store_on_page_infimum_end"); })); - lock_rec_move(block, block, PAGE_HEAP_NO_INFIMUM, heap_no); - - lock_mutex_exit(); + LockGuard g{lock_sys.rec_hash, id}; + lock_rec_move(g.cell(), *block, id, g.cell(), id, + PAGE_HEAP_NO_INFIMUM, heap_no); } -/*********************************************************************//** -Restores the state of explicit lock requests on a single record, where the -state was stored on the infimum of the page. */ -void -lock_rec_restore_from_page_infimum( -/*===============================*/ - const buf_block_t* block, /*!< in: buffer block containing rec */ - const rec_t* rec, /*!< in: record whose lock state - is restored */ - const buf_block_t* donator)/*!< in: page (rec is not - necessarily on this page) - whose infimum stored the lock - state; lock bits are reset on - the infimum */ +/** Restore the explicit lock requests on a single record, where the +state was stored on the infimum of a page. +@param block buffer block containing rec +@param rec record whose lock state is restored +@param donator page (rec is not necessarily on this page) +whose infimum stored the lock state; lock bits are reset on the infimum */ +void lock_rec_restore_from_page_infimum(const buf_block_t &block, + const rec_t *rec, page_id_t donator) { - ulint heap_no = page_rec_get_heap_no(rec); - - lock_mutex_enter(); - - lock_rec_move(block, donator, heap_no, PAGE_HEAP_NO_INFIMUM); - - lock_mutex_exit(); + const ulint heap_no= page_rec_get_heap_no(rec); + const page_id_t id{block.page.id()}; + LockMultiGuard g{lock_sys.rec_hash, id, donator}; + lock_rec_move(g.cell1(), block, id, g.cell2(), donator, heap_no, + PAGE_HEAP_NO_INFIMUM); } /*========================= TABLE LOCKS ==============================*/ -/** Functor for accessing the embedded node within a table lock. */ -struct TableLockGetNode { - ut_list_node<lock_t>& operator() (lock_t& elem) - { - return(elem.un_member.tab_lock.locks); - } -}; - -/*********************************************************************//** -Creates a table lock object and adds it as the last in the lock queue -of the table. Does NOT check for deadlocks or lock compatibility. -@return own: new lock object */ -UNIV_INLINE -lock_t* -lock_table_create( -/*==============*/ - dict_table_t* table, /*!< in/out: database table - in dictionary cache */ - unsigned type_mode,/*!< in: lock mode possibly ORed with - LOCK_WAIT */ - trx_t* trx /*!< in: trx */ -#ifdef WITH_WSREP - , lock_t* c_lock = NULL /*!< in: conflicting lock */ -#endif - ) +/** +Create a table lock, without checking for deadlocks or lock compatibility. +@param table table on which the lock is created +@param type_mode lock type and mode +@param trx transaction +@param c_lock conflicting lock +@return the created lock object */ +lock_t *lock_table_create(dict_table_t *table, unsigned type_mode, trx_t *trx, + lock_t *c_lock) { lock_t* lock; - ut_ad(table && trx); - ut_ad(lock_mutex_own()); - ut_ad(trx_mutex_own(trx)); - ut_ad(trx->is_recovered || trx->state == TRX_STATE_ACTIVE); - ut_ad(!trx->auto_commit || trx->will_lock); - - if ((type_mode & LOCK_MODE_MASK) == LOCK_AUTO_INC) { + lock_sys.assert_locked(*table); + ut_ad(trx->mutex_is_owner()); + ut_ad(!trx->is_wsrep() || lock_sys.is_writer()); + ut_ad(trx->state == TRX_STATE_ACTIVE || trx->is_recovered); + ut_ad(!trx->is_autocommit_non_locking()); + /* During CREATE TABLE, we will write to newly created FTS_*_CONFIG + on which no lock has been created yet. */ + ut_ad(!trx->dict_operation_lock_mode + || (strstr(table->name.m_name, "/FTS_") + && strstr(table->name.m_name, "_CONFIG") + sizeof("_CONFIG") + == table->name.m_name + strlen(table->name.m_name) + 1)); + + switch (LOCK_MODE_MASK & type_mode) { + case LOCK_AUTO_INC: ++table->n_waiting_or_granted_auto_inc_locks; - } - - /* For AUTOINC locking we reuse the lock instance only if - there is no wait involved else we allocate the waiting lock - from the transaction lock heap. */ - if (type_mode == LOCK_AUTO_INC) { + /* For AUTOINC locking we reuse the lock instance only if + there is no wait involved else we allocate the waiting lock + from the transaction lock heap. */ + if (type_mode == LOCK_AUTO_INC) { + lock = table->autoinc_lock; - lock = table->autoinc_lock; - - table->autoinc_trx = trx; - - ib_vector_push(trx->autoinc_locks, &lock); - - } else if (trx->lock.table_cached - < UT_ARR_SIZE(trx->lock.table_pool)) { - lock = &trx->lock.table_pool[trx->lock.table_cached++]; - } else { + ut_ad(!table->autoinc_trx); + table->autoinc_trx = trx; - lock = static_cast<lock_t*>( - mem_heap_alloc(trx->lock.lock_heap, sizeof(*lock))); + ib_vector_push(trx->autoinc_locks, &lock); + goto allocated; + } + break; + case LOCK_X: + case LOCK_S: + ++table->n_lock_x_or_s; + break; } + lock = trx->lock.table_cached < array_elements(trx->lock.table_pool) + ? &trx->lock.table_pool[trx->lock.table_cached++] + : static_cast<lock_t*>( + mem_heap_alloc(trx->lock.lock_heap, sizeof *lock)); + +allocated: lock->type_mode = ib_uint32_t(type_mode | LOCK_TABLE); lock->trx = trx; @@ -3427,46 +3291,19 @@ lock_table_create( UT_LIST_ADD_LAST(trx->lock.trx_locks, lock); -#ifdef WITH_WSREP - if (c_lock && trx->is_wsrep()) { - if (wsrep_thd_is_BF(trx->mysql_thd, FALSE)) { - ut_list_insert(table->locks, c_lock, lock, - TableLockGetNode()); - if (UNIV_UNLIKELY(wsrep_debug)) { - wsrep_report_bf_lock_wait(trx->mysql_thd, trx->id); - wsrep_report_bf_lock_wait(c_lock->trx->mysql_thd, c_lock->trx->id); - } - } else { - ut_list_append(table->locks, lock, TableLockGetNode()); - } - - trx_mutex_enter(c_lock->trx); - - if (c_lock->trx->lock.que_state == TRX_QUE_LOCK_WAIT) { - c_lock->trx->lock.was_chosen_as_deadlock_victim = TRUE; - - if (UNIV_UNLIKELY(wsrep_debug)) { - wsrep_report_bf_lock_wait(trx->mysql_thd, trx->id); - wsrep_report_bf_lock_wait(c_lock->trx->mysql_thd, c_lock->trx->id); - wsrep_print_wait_locks(c_lock); - } - - /* The lock release will call lock_grant(), - which would acquire trx->mutex again. */ - trx_mutex_exit(trx); - lock_cancel_waiting_and_release( - c_lock->trx->lock.wait_lock); - trx_mutex_enter(trx); - } - - trx_mutex_exit(c_lock->trx); - } else -#endif /* WITH_WSREP */ ut_list_append(table->locks, lock, TableLockGetNode()); if (type_mode & LOCK_WAIT) { - - lock_set_lock_and_trx_wait(lock, trx); + if (trx->lock.wait_trx) { + ut_ad(!c_lock || trx->lock.wait_trx == c_lock->trx); + ut_ad(trx->lock.wait_lock); + ut_ad((*trx->lock.wait_lock).trx == trx); + } else { + ut_ad(c_lock); + trx->lock.wait_trx = c_lock->trx; + ut_ad(!trx->lock.wait_lock); + } + trx->lock.wait_lock = lock; } lock->trx->lock.table_locks.push_back(lock); @@ -3487,7 +3324,6 @@ lock_table_pop_autoinc_locks( /*=========================*/ trx_t* trx) /*!< in/out: transaction that owns the AUTOINC locks */ { - ut_ad(lock_mutex_own()); ut_ad(!ib_vector_is_empty(trx->autoinc_locks)); /* Skip any gaps, gaps are NULL lock entries in the @@ -3512,21 +3348,20 @@ lock_table_remove_autoinc_lock( lock_t* lock, /*!< in: table lock */ trx_t* trx) /*!< in/out: transaction that owns the lock */ { - lock_t* autoinc_lock; - lint i = ib_vector_size(trx->autoinc_locks) - 1; + ut_ad(lock->type_mode == (LOCK_AUTO_INC | LOCK_TABLE)); + lock_sys.assert_locked(*lock->un_member.tab_lock.table); + ut_ad(trx->mutex_is_owner()); - ut_ad(lock_mutex_own()); - ut_ad(lock_get_mode(lock) == LOCK_AUTO_INC); - ut_ad(lock_get_type_low(lock) & LOCK_TABLE); - ut_ad(!ib_vector_is_empty(trx->autoinc_locks)); + auto s = ib_vector_size(trx->autoinc_locks); + ut_ad(s); /* With stored functions and procedures the user may drop a table within the same "statement". This special case has to be handled by deleting only those AUTOINC locks that were held by the table being dropped. */ - autoinc_lock = *static_cast<lock_t**>( - ib_vector_get(trx->autoinc_locks, i)); + lock_t* autoinc_lock = *static_cast<lock_t**>( + ib_vector_get(trx->autoinc_locks, --s)); /* This is the default fast case. */ @@ -3538,13 +3373,13 @@ lock_table_remove_autoinc_lock( /* Handle freeing the locks from within the stack. */ - while (--i >= 0) { + while (s) { autoinc_lock = *static_cast<lock_t**>( - ib_vector_get(trx->autoinc_locks, i)); + ib_vector_get(trx->autoinc_locks, --s)); if (autoinc_lock == lock) { void* null_var = NULL; - ib_vector_set(trx->autoinc_locks, i, &null_var); + ib_vector_set(trx->autoinc_locks, s, &null_var); return; } } @@ -3559,46 +3394,50 @@ Removes a table lock request from the queue and the trx list of locks; this is a low-level function which does NOT check if waiting requests can now be granted. */ UNIV_INLINE -void +const dict_table_t* lock_table_remove_low( /*==================*/ lock_t* lock) /*!< in/out: table lock */ { + ut_ad(lock->is_table()); + trx_t* trx; dict_table_t* table; - ut_ad(lock_mutex_own()); - + ut_ad(lock->is_table()); trx = lock->trx; table = lock->un_member.tab_lock.table; + lock_sys.assert_locked(*table); + ut_ad(trx->mutex_is_owner()); /* Remove the table from the transaction's AUTOINC vector, if the lock that is being released is an AUTOINC lock. */ - if (lock_get_mode(lock) == LOCK_AUTO_INC) { + switch (lock->mode()) { + case LOCK_AUTO_INC: + ut_ad((table->autoinc_trx == trx) == !lock->is_waiting()); - /* The table's AUTOINC lock can get transferred to - another transaction before we get here. */ if (table->autoinc_trx == trx) { table->autoinc_trx = NULL; - } - - /* The locks must be freed in the reverse order from - the one in which they were acquired. This is to avoid - traversing the AUTOINC lock vector unnecessarily. - - We only store locks that were granted in the - trx->autoinc_locks vector (see lock_table_create() - and lock_grant()). Therefore it can be empty and we - need to check for that. */ - - if (!lock_get_wait(lock) - && !ib_vector_is_empty(trx->autoinc_locks)) { + /* The locks must be freed in the reverse order from + the one in which they were acquired. This is to avoid + traversing the AUTOINC lock vector unnecessarily. + We only store locks that were granted in the + trx->autoinc_locks vector (see lock_table_create() + and lock_grant()). */ lock_table_remove_autoinc_lock(lock, trx); } - ut_a(table->n_waiting_or_granted_auto_inc_locks > 0); - table->n_waiting_or_granted_auto_inc_locks--; + ut_ad(table->n_waiting_or_granted_auto_inc_locks); + --table->n_waiting_or_granted_auto_inc_locks; + break; + case LOCK_X: + case LOCK_S: + ut_ad(table->n_lock_x_or_s); + --table->n_lock_x_or_s; + break; + default: + break; } UT_LIST_REMOVE(trx->lock.trx_locks, lock); @@ -3606,14 +3445,14 @@ lock_table_remove_low( MONITOR_INC(MONITOR_TABLELOCK_REMOVED); MONITOR_DEC(MONITOR_NUM_TABLELOCK); + return table; } /*********************************************************************//** Enqueues a waiting request for a table lock which cannot be granted immediately. Checks for deadlocks. @retval DB_LOCK_WAIT if the waiting lock was enqueued -@retval DB_DEADLOCK if this transaction was chosen as the victim -@retval DB_SUCCESS if the other transaction committed or aborted */ +@retval DB_DEADLOCK if this transaction was chosen as the victim */ static dberr_t lock_table_enqueue_waiting( @@ -3621,75 +3460,30 @@ lock_table_enqueue_waiting( unsigned mode, /*!< in: lock mode this transaction is requesting */ dict_table_t* table, /*!< in/out: table */ - que_thr_t* thr /*!< in: query thread */ -#ifdef WITH_WSREP - , lock_t* c_lock /*!< in: conflicting lock or NULL */ -#endif -) + que_thr_t* thr, /*!< in: query thread */ + lock_t* c_lock) /*!< in: conflicting lock or NULL */ { - trx_t* trx; - lock_t* lock; - - ut_ad(lock_mutex_own()); + lock_sys.assert_locked(*table); ut_ad(!srv_read_only_mode); - trx = thr_get_trx(thr); - ut_ad(trx_mutex_own(trx)); - ut_a(!que_thr_stop(thr)); - - switch (trx_get_dict_operation(trx)) { - case TRX_DICT_OP_NONE: - break; - case TRX_DICT_OP_TABLE: - case TRX_DICT_OP_INDEX: - ib::error() << "A table lock wait happens in a dictionary" - " operation. Table " << table->name - << ". " << BUG_REPORT_MSG; - ut_ad(0); - } - -#ifdef WITH_WSREP - if (trx->is_wsrep() && trx->lock.was_chosen_as_deadlock_victim) { - return(DB_DEADLOCK); - } -#endif /* WITH_WSREP */ + trx_t* trx = thr_get_trx(thr); + ut_ad(trx->mutex_is_owner()); + ut_ad(!trx->dict_operation_lock_mode); /* Enqueue the lock request that will wait to be granted */ - lock = lock_table_create(table, mode | LOCK_WAIT, trx -#ifdef WITH_WSREP - , c_lock -#endif - ); - - const trx_t* victim_trx = - DeadlockChecker::check_and_resolve(lock, trx); - - if (victim_trx != 0) { - ut_ad(victim_trx == trx); - - /* The order here is important, we don't want to - lose the state of the lock before calling remove. */ - lock_table_remove_low(lock); - lock_reset_lock_and_trx_wait(lock); - - return(DB_DEADLOCK); - - } else if (trx->lock.wait_lock == NULL) { - /* Deadlock resolution chose another transaction as a victim, - and we accidentally got our lock granted! */ - - return(DB_SUCCESS); - } - - trx->lock.que_state = TRX_QUE_LOCK_WAIT; - - trx->lock.wait_started = time(NULL); - trx->lock.was_chosen_as_deadlock_victim = false; - - ut_a(que_thr_stop(thr)); + lock_table_create(table, mode | LOCK_WAIT, trx, c_lock); + + trx->lock.wait_thr = thr; + /* Apart from Galera, only transactions that have waiting lock + may be chosen as deadlock victims. Only one lock can be waited for at a + time, and a transaction is associated with a single thread. That is why + there must not be waiting lock requests if the transaction is deadlock + victim and it is not WSREP. Galera transaction abort can be invoked + from MDL acquisition code when the transaction does not have waiting + lock, that's why we check only deadlock victim bit here. */ + ut_ad(!(trx->lock.was_chosen_as_deadlock_victim & 1)); MONITOR_INC(MONITOR_TABLELOCK_WAIT); - return(DB_LOCK_WAIT); } @@ -3709,32 +3503,24 @@ lock_table_other_has_incompatible( const dict_table_t* table, /*!< in: table */ lock_mode mode) /*!< in: lock mode */ { - lock_t* lock; + lock_sys.assert_locked(*table); - ut_ad(lock_mutex_own()); + static_assert(LOCK_IS == 0, "compatibility"); + static_assert(LOCK_IX == 1, "compatibility"); - for (lock = UT_LIST_GET_LAST(table->locks); - lock != NULL; - lock = UT_LIST_GET_PREV(un_member.tab_lock.locks, lock)) { + if (UNIV_LIKELY(mode <= LOCK_IX && !table->n_lock_x_or_s)) { + return(NULL); + } - if (lock->trx != trx - && !lock_mode_compatible(lock_get_mode(lock), mode) - && (wait || !lock_get_wait(lock))) { + for (lock_t* lock = UT_LIST_GET_LAST(table->locks); + lock; + lock = UT_LIST_GET_PREV(un_member.tab_lock.locks, lock)) { -#ifdef WITH_WSREP - if (lock->trx->is_wsrep()) { - if (UNIV_UNLIKELY(wsrep_debug)) { - ib::info() << "WSREP: table lock abort for table:" - << table->name; - ib::info() << " SQL: " - << wsrep_thd_query(lock->trx->mysql_thd); - } - trx_mutex_enter(lock->trx); - wsrep_kill_victim((trx_t *)trx, (lock_t *)lock); - trx_mutex_exit(lock->trx); - } -#endif /* WITH_WSREP */ + trx_t* lock_trx = lock->trx; + if (lock_trx != trx + && !lock_mode_compatible(lock->mode(), mode) + && (wait || !lock->is_waiting())) { return(lock); } } @@ -3742,175 +3528,158 @@ lock_table_other_has_incompatible( return(NULL); } -/*********************************************************************//** -Locks the specified database table in the mode given. If the lock cannot -be granted immediately, the query thread is put to wait. -@return DB_SUCCESS, DB_LOCK_WAIT, or DB_DEADLOCK */ -dberr_t -lock_table( -/*=======*/ - unsigned flags, /*!< in: if BTR_NO_LOCKING_FLAG bit is set, - does nothing */ - dict_table_t* table, /*!< in/out: database table - in dictionary cache */ - lock_mode mode, /*!< in: lock mode */ - que_thr_t* thr) /*!< in: query thread */ +/** Aqcuire or enqueue a table lock */ +static dberr_t lock_table_low(dict_table_t *table, lock_mode mode, + que_thr_t *thr, trx_t *trx) { - trx_t* trx; - dberr_t err; - lock_t* wait_for; - - ut_ad(table && thr); - - /* Given limited visibility of temp-table we can avoid - locking overhead */ - if ((flags & BTR_NO_LOCKING_FLAG) - || srv_read_only_mode - || table->is_temporary()) { - - return(DB_SUCCESS); - } - - ut_a(flags == 0); - - trx = thr_get_trx(thr); - - /* Look for equal or stronger locks the same trx already - has on the table. No need to acquire the lock mutex here - because only this transacton can add/access table locks - to/from trx_t::table_locks. */ + DBUG_EXECUTE_IF("innodb_table_deadlock", return DB_DEADLOCK;); + lock_t *wait_for= + lock_table_other_has_incompatible(trx, LOCK_WAIT, table, mode); + dberr_t err= DB_SUCCESS; - if (lock_table_has(trx, table, mode)) { + trx->mutex_lock(); - return(DB_SUCCESS); - } + if (wait_for) + err= lock_table_enqueue_waiting(mode, table, thr, wait_for); + else + lock_table_create(table, mode, trx, nullptr); - /* Read only transactions can write to temp tables, we don't want - to promote them to RW transactions. Their updates cannot be visible - to other transactions. Therefore we can keep them out - of the read views. */ + trx->mutex_unlock(); - if ((mode == LOCK_IX || mode == LOCK_X) - && !trx->read_only - && trx->rsegs.m_redo.rseg == 0) { + return err; +} - trx_set_rw_mode(trx); - } +#ifdef WITH_WSREP +/** Aqcuire or enqueue a table lock in Galera replication mode. */ +ATTRIBUTE_NOINLINE +static dberr_t lock_table_wsrep(dict_table_t *table, lock_mode mode, + que_thr_t *thr, trx_t *trx) +{ + LockMutexGuard g{SRW_LOCK_CALL}; + return lock_table_low(table, mode, thr, trx); +} +#endif - lock_mutex_enter(); +/** Acquire a table lock. +@param table table to be locked +@param fktable pointer to table, in case of a FOREIGN key check +@param mode lock mode +@param thr SQL execution thread +@retval DB_SUCCESS if the lock was acquired +@retval DB_DEADLOCK if a deadlock occurred, or fktable && *fktable != table +@retval DB_LOCK_WAIT if lock_wait() must be invoked */ +dberr_t lock_table(dict_table_t *table, dict_table_t *const*fktable, + lock_mode mode, que_thr_t *thr) +{ + ut_ad(table); - DBUG_EXECUTE_IF("fatal-semaphore-timeout", - { os_thread_sleep(3600000000LL); }); + if (!fktable && table->is_temporary()) + return DB_SUCCESS; - /* We have to check if the new lock is compatible with any locks - other transactions have in the table lock queue. */ + ut_ad(fktable || table->get_ref_count() || !table->can_be_evicted); - wait_for = lock_table_other_has_incompatible( - trx, LOCK_WAIT, table, mode); + trx_t *trx= thr_get_trx(thr); - trx_mutex_enter(trx); + /* Look for equal or stronger locks the same trx already has on the + table. No need to acquire LockMutexGuard here because only the + thread that is executing a transaction can access trx_t::table_locks. */ + if (lock_table_has(trx, table, mode) || srv_read_only_mode) + return DB_SUCCESS; - /* Another trx has a request on the table in an incompatible - mode: this trx may have to wait */ + if ((mode == LOCK_IX || mode == LOCK_X) && + !trx->read_only && !trx->rsegs.m_redo.rseg) + trx_set_rw_mode(trx); - if (wait_for != NULL) { - err = lock_table_enqueue_waiting(flags | mode, table, - thr #ifdef WITH_WSREP - , wait_for + if (trx->is_wsrep()) + return lock_table_wsrep(table, mode, thr, trx); #endif - ); - } else { - lock_table_create(table, flags | mode, trx); - - ut_a(!flags || mode == LOCK_S || mode == LOCK_X); - - err = DB_SUCCESS; - } - - lock_mutex_exit(); - - trx_mutex_exit(trx); + lock_sys.rd_lock(SRW_LOCK_CALL); + dberr_t err; + if (fktable != nullptr && *fktable != table) + err= DB_DEADLOCK; + else + { + table->lock_mutex_lock(); + err= lock_table_low(table, mode, thr, trx); + table->lock_mutex_unlock(); + } + lock_sys.rd_unlock(); - return(err); + return err; } -/*********************************************************************//** -Creates a table IX lock object for a resurrected transaction. */ -void -lock_table_ix_resurrect( -/*====================*/ - dict_table_t* table, /*!< in/out: table */ - trx_t* trx) /*!< in/out: transaction */ +/** Create a table lock object for a resurrected transaction. +@param table table to be X-locked +@param trx transaction +@param mode LOCK_X or LOCK_IX */ +void lock_table_resurrect(dict_table_t *table, trx_t *trx, lock_mode mode) { - ut_ad(trx->is_recovered); + ut_ad(trx->is_recovered); + ut_ad(mode == LOCK_X || mode == LOCK_IX); - if (lock_table_has(trx, table, LOCK_IX)) { - return; - } + if (lock_table_has(trx, table, mode)) + return; - lock_mutex_enter(); - - /* We have to check if the new lock is compatible with any locks - other transactions have in the table lock queue. */ - - ut_ad(!lock_table_other_has_incompatible( - trx, LOCK_WAIT, table, LOCK_IX)); + { + /* This is executed at server startup while no connections + are alowed. Do not bother with lock elision. */ + LockMutexGuard g{SRW_LOCK_CALL}; + ut_ad(!lock_table_other_has_incompatible(trx, LOCK_WAIT, table, mode)); - trx_mutex_enter(trx); - lock_table_create(table, LOCK_IX, trx); - lock_mutex_exit(); - trx_mutex_exit(trx); + trx->mutex_lock(); + lock_table_create(table, mode, trx); + } + trx->mutex_unlock(); } -/*********************************************************************//** -Checks if a waiting table lock request still has to wait in a queue. -@return TRUE if still has to wait */ -static -bool -lock_table_has_to_wait_in_queue( -/*============================*/ - const lock_t* wait_lock) /*!< in: waiting table lock */ +/** Find a lock that a waiting table lock request still has to wait for. */ +static const lock_t *lock_table_has_to_wait_in_queue(const lock_t *wait_lock) { - const dict_table_t* table; - const lock_t* lock; + ut_ad(wait_lock->is_waiting()); + ut_ad(wait_lock->is_table()); - ut_ad(lock_mutex_own()); - ut_ad(lock_get_wait(wait_lock)); + dict_table_t *table= wait_lock->un_member.tab_lock.table; + lock_sys.assert_locked(*table); - table = wait_lock->un_member.tab_lock.table; + static_assert(LOCK_IS == 0, "compatibility"); + static_assert(LOCK_IX == 1, "compatibility"); - for (lock = UT_LIST_GET_FIRST(table->locks); - lock != wait_lock; - lock = UT_LIST_GET_NEXT(un_member.tab_lock.locks, lock)) { + if (UNIV_LIKELY(wait_lock->mode() <= LOCK_IX && !table->n_lock_x_or_s)) + return nullptr; - if (lock_has_to_wait(wait_lock, lock)) { + for (const lock_t *lock= UT_LIST_GET_FIRST(table->locks); lock != wait_lock; + lock= UT_LIST_GET_NEXT(un_member.tab_lock.locks, lock)) + if (lock_has_to_wait(wait_lock, lock)) + return lock; - return(true); - } - } - - return(false); + return nullptr; } /*************************************************************//** Removes a table lock request, waiting or granted, from the queue and grants locks to other transactions in the queue, if they now are entitled to a -lock. */ -static -void -lock_table_dequeue( -/*===============*/ - lock_t* in_lock)/*!< in/out: table lock object; transactions waiting - behind will get their lock requests granted, if - they are now qualified to it */ +lock. +@param[in,out] in_lock table lock +@param[in] owns_wait_mutex whether lock_sys.wait_mutex is held */ +static void lock_table_dequeue(lock_t *in_lock, bool owns_wait_mutex) { - ut_ad(lock_mutex_own()); - ut_a(lock_get_type_low(in_lock) == LOCK_TABLE); - +#ifdef SAFE_MUTEX + ut_ad(owns_wait_mutex == mysql_mutex_is_owner(&lock_sys.wait_mutex)); +#endif + ut_ad(in_lock->trx->mutex_is_owner()); lock_t* lock = UT_LIST_GET_NEXT(un_member.tab_lock.locks, in_lock); - lock_table_remove_low(in_lock); + const dict_table_t* table = lock_table_remove_low(in_lock); + + static_assert(LOCK_IS == 0, "compatibility"); + static_assert(LOCK_IX == 1, "compatibility"); + + if (UNIV_LIKELY(in_lock->mode() <= LOCK_IX && !table->n_lock_x_or_s)) { + return; + } + + bool acquired = false; /* Check if waiting locks in the queue can now be granted: grant locks if there are no conflicting locks ahead. */ @@ -3918,135 +3687,121 @@ lock_table_dequeue( for (/* No op */; lock != NULL; lock = UT_LIST_GET_NEXT(un_member.tab_lock.locks, lock)) { + if (!lock->is_waiting()) { + continue; + } - if (lock_get_wait(lock) - && !lock_table_has_to_wait_in_queue(lock)) { + if (!owns_wait_mutex) { + mysql_mutex_lock(&lock_sys.wait_mutex); + acquired = owns_wait_mutex = true; + } + + ut_ad(lock->trx->lock.wait_trx); + ut_ad(lock->trx->lock.wait_lock); + if (const lock_t* c = lock_table_has_to_wait_in_queue(lock)) { + trx_t* c_trx = c->trx; + lock->trx->lock.wait_trx = c_trx; + if (c_trx->lock.wait_trx + && innodb_deadlock_detect + && Deadlock::to_check.emplace(c_trx).second) { + Deadlock::to_be_checked = true; + } + } else { /* Grant the lock */ ut_ad(in_lock->trx != lock->trx); + in_lock->trx->mutex_unlock(); lock_grant(lock); + in_lock->trx->mutex_lock(); } } -} - -/** Sets a lock on a table based on the given mode. -@param[in] table table to lock -@param[in,out] trx transaction -@param[in] mode LOCK_X or LOCK_S -@return error code or DB_SUCCESS. */ -dberr_t -lock_table_for_trx( - dict_table_t* table, - trx_t* trx, - enum lock_mode mode) -{ - mem_heap_t* heap; - que_thr_t* thr; - dberr_t err; - sel_node_t* node; - heap = mem_heap_create(512); - - node = sel_node_create(heap); - thr = pars_complete_graph_for_exec(node, trx, heap, NULL); - thr->graph->state = QUE_FORK_ACTIVE; - /* We use the select query graph as the dummy graph needed - in the lock module call */ + if (acquired) { + mysql_mutex_unlock(&lock_sys.wait_mutex); + } +} - thr = static_cast<que_thr_t*>( - que_fork_get_first_thr( - static_cast<que_fork_t*>(que_node_get_parent(thr)))); - thr->start_running(); +/** Sets a lock on a table based on the given mode. +@param table table to lock +@param trx transaction +@param mode LOCK_X or LOCK_S +@param no_wait whether to skip handling DB_LOCK_WAIT +@return error code */ +dberr_t lock_table_for_trx(dict_table_t *table, trx_t *trx, lock_mode mode, + bool no_wait) +{ + mem_heap_t *heap= mem_heap_create(512); + sel_node_t *node= sel_node_create(heap); + que_thr_t *thr= pars_complete_graph_for_exec(node, trx, heap, nullptr); + thr->graph->state= QUE_FORK_ACTIVE; + + thr= static_cast<que_thr_t*> + (que_fork_get_first_thr(static_cast<que_fork_t*> + (que_node_get_parent(thr)))); run_again: - thr->run_node = thr; - thr->prev_node = thr->common.parent; - - err = lock_table(0, table, mode, thr); - - trx->error_state = err; - - if (UNIV_LIKELY(err == DB_SUCCESS)) { - thr->stop_no_error(); - } else { - que_thr_stop_for_mysql(thr); - - if (row_mysql_handle_errors(&err, trx, thr, NULL)) { - goto run_again; - } - } + thr->run_node= thr; + thr->prev_node= thr->common.parent; + dberr_t err= lock_table(table, nullptr, mode, thr); + + switch (err) { + case DB_SUCCESS: + break; + case DB_LOCK_WAIT: + if (no_wait) + { + lock_sys.cancel_lock_wait_for_trx(trx); + break; + } + /* fall through */ + default: + trx->error_state= err; + if (row_mysql_handle_errors(&err, trx, thr, nullptr)) + goto run_again; + } - que_graph_free(thr->graph); - trx->op_info = ""; + que_graph_free(thr->graph); + trx->op_info= ""; - return(err); + return err; } -/*=========================== LOCK RELEASE ==============================*/ -static -void -lock_grant_and_move_on_rec( - lock_t* first_lock, - ulint heap_no) +/** Exclusively lock the data dictionary tables. +@param trx dictionary transaction +@return error code +@retval DB_SUCCESS on success */ +dberr_t lock_sys_tables(trx_t *trx) { - lock_t* lock; - const page_id_t page_id(first_lock->un_member.rec_lock.page_id); - const ulint rec_fold= page_id.fold(); - lock_t* previous = static_cast<lock_t*>( - lock_sys.rec_hash.array[lock_sys.hash(page_id)] - .node); - if (previous == NULL) { - return; - } - if (previous == first_lock) { - lock = previous; - } else { - while (previous->hash && - previous->hash != first_lock) { - previous = previous->hash; - } - lock = previous->hash; - } - /* Grant locks if there are no conflicting locks ahead. - Move granted locks to the head of the list. */ - while (lock) { - ut_ad(!lock->trx->is_wsrep()); - /* If the lock is a wait lock on this page, and it does not need to wait. */ - if (lock->un_member.rec_lock.page_id == page_id - && lock_rec_get_nth_bit(lock, heap_no) - && lock_get_wait(lock) - && !lock_rec_has_to_wait_in_queue(lock)) { - - lock_grant(lock); - - if (previous != NULL) { - /* Move the lock to the head of the list. */ - HASH_GET_NEXT(hash, previous) = HASH_GET_NEXT(hash, lock); - lock_rec_insert_to_head(lock, rec_fold); - } else { - /* Already at the head of the list. */ - previous = lock; - } - /* Move on to the next lock. */ - lock = static_cast<lock_t *>(HASH_GET_NEXT(hash, previous)); - } else { - previous = lock; - lock = static_cast<lock_t *>(HASH_GET_NEXT(hash, lock)); - } - } + dberr_t err; + if (!(err= lock_table_for_trx(dict_sys.sys_tables, trx, LOCK_X)) && + !(err= lock_table_for_trx(dict_sys.sys_columns, trx, LOCK_X)) && + !(err= lock_table_for_trx(dict_sys.sys_indexes, trx, LOCK_X)) && + !(err= lock_table_for_trx(dict_sys.sys_fields, trx, LOCK_X))) + { + if (dict_sys.sys_foreign) + err= lock_table_for_trx(dict_sys.sys_foreign, trx, LOCK_X); + if (!err && dict_sys.sys_foreign_cols) + err= lock_table_for_trx(dict_sys.sys_foreign_cols, trx, LOCK_X); + if (!err && dict_sys.sys_virtual) + err= lock_table_for_trx(dict_sys.sys_virtual, trx, LOCK_X); + } + return err; } +/*=========================== LOCK RELEASE ==============================*/ + /*************************************************************//** Removes a granted record lock of a transaction from the queue and grants locks to other transactions waiting in the queue if they now are entitled to a lock. */ +TRANSACTIONAL_TARGET void lock_rec_unlock( /*============*/ trx_t* trx, /*!< in/out: transaction that has set a record lock */ - const buf_block_t* block, /*!< in: buffer block containing rec */ + const page_id_t id, /*!< in: page containing rec */ const rec_t* rec, /*!< in: record */ lock_mode lock_mode)/*!< in: LOCK_S or LOCK_X */ { @@ -4056,31 +3811,26 @@ lock_rec_unlock( ut_ad(trx); ut_ad(rec); - ut_ad(block->frame == page_align(rec)); ut_ad(!trx->lock.wait_lock); ut_ad(trx_state_eq(trx, TRX_STATE_ACTIVE)); ut_ad(!page_rec_is_metadata(rec)); heap_no = page_rec_get_heap_no(rec); - lock_mutex_enter(); - trx_mutex_enter(trx); + LockGuard g{lock_sys.rec_hash, id}; - first_lock = lock_rec_get_first(&lock_sys.rec_hash, block, heap_no); + first_lock = lock_sys_t::get_first(g.cell(), id, heap_no); /* Find the last lock with the same lock_mode and transaction on the record. */ for (lock = first_lock; lock != NULL; lock = lock_rec_get_next(heap_no, lock)) { - if (lock->trx == trx && lock_get_mode(lock) == lock_mode) { + if (lock->trx == trx && lock->mode() == lock_mode) { goto released; } } - lock_mutex_exit(); - trx_mutex_exit(trx); - { ib::error err; err << "Unlock row could not find a " << lock_mode @@ -4095,232 +3845,392 @@ lock_rec_unlock( return; released: - ut_a(!lock_get_wait(lock)); - lock_rec_reset_nth_bit(lock, heap_no); + ut_a(!lock->is_waiting()); + { + TMTrxGuard tg{*trx}; + lock_rec_reset_nth_bit(lock, heap_no); + } - if (innodb_lock_schedule_algorithm - == INNODB_LOCK_SCHEDULE_ALGORITHM_FCFS || - thd_is_replication_slave_thread(lock->trx->mysql_thd)) { + /* Check if we can now grant waiting lock requests */ - /* Check if we can now grant waiting lock requests */ + for (lock = first_lock; lock != NULL; + lock = lock_rec_get_next(heap_no, lock)) { + if (!lock->is_waiting()) { + continue; + } + mysql_mutex_lock(&lock_sys.wait_mutex); + ut_ad(lock->trx->lock.wait_trx); + ut_ad(lock->trx->lock.wait_lock); - for (lock = first_lock; lock != NULL; - lock = lock_rec_get_next(heap_no, lock)) { - if (!lock_get_wait(lock)) { - continue; - } - const lock_t* c = lock_rec_has_to_wait_in_queue(lock); - if (!c) { - /* Grant the lock */ - ut_ad(trx != lock->trx); - lock_grant(lock); - } + if (const lock_t* c = lock_rec_has_to_wait_in_queue(g.cell(), + lock)) { + lock->trx->lock.wait_trx = c->trx; + } else { + /* Grant the lock */ + ut_ad(trx != lock->trx); + lock_grant(lock); } - } else { - lock_grant_and_move_on_rec(first_lock, heap_no); + mysql_mutex_unlock(&lock_sys.wait_mutex); } - - lock_mutex_exit(); - trx_mutex_exit(trx); } -#ifdef UNIV_DEBUG -/*********************************************************************//** -Check if a transaction that has X or IX locks has set the dict_op -code correctly. */ -static -void -lock_check_dict_lock( -/*==================*/ - const lock_t* lock) /*!< in: lock to check */ -{ - if (lock_get_type_low(lock) == LOCK_REC) { - ut_ad(!lock->index->table->is_temporary()); - - /* Check if the transcation locked a record - in a system table in X mode. It should have set - the dict_op code correctly if it did. */ - if (lock->index->table->id < DICT_HDR_FIRST_ID - && lock_get_mode(lock) == LOCK_X) { - - ut_ad(lock_get_mode(lock) != LOCK_IX); - ut_ad(lock->trx->dict_operation != TRX_DICT_OP_NONE); - } - } else { - ut_ad(lock_get_type_low(lock) & LOCK_TABLE); +/** Release the explicit locks of a committing transaction, +and release possible other transactions waiting because of these locks. +@return whether the operation succeeded */ +TRANSACTIONAL_TARGET static bool lock_release_try(trx_t *trx) +{ + /* At this point, trx->lock.trx_locks cannot be modified by other + threads, because our transaction has been committed. + See the checks and assertions in lock_rec_create_low() and + lock_rec_add_to_queue(). + + The function lock_table_create() should never be invoked on behalf + of a transaction running in another thread. Also there, we will + assert that the current transaction be active. */ + DBUG_ASSERT(trx->state == TRX_STATE_COMMITTED_IN_MEMORY); + DBUG_ASSERT(!trx->is_referenced()); + + bool all_released= true; +restart: + ulint count= 1000; + /* We will not attempt hardware lock elision (memory transaction) + here. Both lock_rec_dequeue_from_page() and lock_table_dequeue() + would likely lead to a memory transaction due to a system call, to + wake up a waiting transaction. */ + lock_sys.rd_lock(SRW_LOCK_CALL); + trx->mutex_lock(); + + /* Note: Anywhere else, trx->mutex is not held while acquiring + a lock table latch, but here we are following the opposite order. + To avoid deadlocks, we only try to acquire the lock table latches + but not keep waiting for them. */ - const dict_table_t* table = lock->un_member.tab_lock.table; - ut_ad(!table->is_temporary()); + for (lock_t *lock= UT_LIST_GET_LAST(trx->lock.trx_locks); lock; ) + { + ut_ad(lock->trx == trx); + lock_t *prev= UT_LIST_GET_PREV(trx_locks, lock); + if (!lock->is_table()) + { + ut_ad(!lock->index->table->is_temporary()); + ut_ad(lock->mode() != LOCK_X || + lock->index->table->id >= DICT_HDR_FIRST_ID || + trx->dict_operation || trx->was_dict_operation); + auto &lock_hash= lock_sys.hash_get(lock->type_mode); + auto cell= lock_hash.cell_get(lock->un_member.rec_lock.page_id.fold()); + auto latch= lock_sys_t::hash_table::latch(cell); + if (!latch->try_acquire()) + all_released= false; + else + { + lock_rec_dequeue_from_page(lock, false); + latch->release(); + } + } + else + { + dict_table_t *table= lock->un_member.tab_lock.table; + ut_ad(!table->is_temporary()); + ut_ad(table->id >= DICT_HDR_FIRST_ID || + (lock->mode() != LOCK_IX && lock->mode() != LOCK_X) || + trx->dict_operation || trx->was_dict_operation); + if (!table->lock_mutex_trylock()) + all_released= false; + else + { + lock_table_dequeue(lock, false); + table->lock_mutex_unlock(); + } + } - /* Check if the transcation locked a system table - in IX mode. It should have set the dict_op code - correctly if it did. */ - if (table->id < DICT_HDR_FIRST_ID - && (lock_get_mode(lock) == LOCK_X - || lock_get_mode(lock) == LOCK_IX)) { + lock= all_released ? UT_LIST_GET_LAST(trx->lock.trx_locks) : prev; + if (!--count) + break; + } - ut_ad(lock->trx->dict_operation != TRX_DICT_OP_NONE); - } - } + lock_sys.rd_unlock(); + trx->mutex_unlock(); + if (all_released && !count) + goto restart; + return all_released; } -#endif /* UNIV_DEBUG */ /** Release the explicit locks of a committing transaction, and release possible other transactions waiting because of these locks. */ -void lock_release(trx_t* trx) +void lock_release(trx_t *trx) { #ifdef UNIV_DEBUG - std::set<table_id_t> to_evict; - if (innodb_evict_tables_on_commit_debug && !trx->is_recovered) -# if 1 /* if dict_stats_exec_sql() were not playing dirty tricks */ - if (!mutex_own(&dict_sys.mutex)) -# else /* this would be more proper way to do it */ - if (!trx->dict_operation_lock_mode && !trx->dict_operation) -# endif - for (const auto& p : trx->mod_tables) - if (!p.first->is_temporary()) - to_evict.emplace(p.first->id); + std::set<table_id_t> to_evict; + if (innodb_evict_tables_on_commit_debug && + !trx->is_recovered && !dict_sys.locked()) + for (const auto& p : trx->mod_tables) + if (!p.first->is_temporary()) + to_evict.emplace(p.first->id); #endif - ulint count = 0; - trx_id_t max_trx_id = trx_sys.get_max_trx_id(); - - lock_mutex_enter(); - ut_ad(!trx_mutex_own(trx)); + ulint count; - for (lock_t* lock = UT_LIST_GET_LAST(trx->lock.trx_locks); - lock != NULL; - lock = UT_LIST_GET_LAST(trx->lock.trx_locks)) { - - ut_d(lock_check_dict_lock(lock)); + for (count= 5; count--; ) + if (lock_release_try(trx)) + goto released; - if (lock_get_type_low(lock) == LOCK_REC) { - - lock_rec_dequeue_from_page(lock); - } else { - dict_table_t* table; + /* Fall back to acquiring lock_sys.latch in exclusive mode */ +restart: + count= 1000; + /* There is probably no point to try lock elision here; + in lock_release_try() it is different. */ + lock_sys.wr_lock(SRW_LOCK_CALL); + trx->mutex_lock(); - table = lock->un_member.tab_lock.table; - - if (lock_get_mode(lock) != LOCK_IS - && trx->undo_no != 0) { - - /* The trx may have modified the table. We - block the use of the MySQL query cache for - all currently active transactions. */ + while (lock_t *lock= UT_LIST_GET_LAST(trx->lock.trx_locks)) + { + ut_ad(lock->trx == trx); + if (!lock->is_table()) + { + ut_ad(!lock->index->table->is_temporary()); + ut_ad(lock->mode() != LOCK_X || + lock->index->table->id >= DICT_HDR_FIRST_ID || + trx->dict_operation || trx->was_dict_operation); + lock_rec_dequeue_from_page(lock, false); + } + else + { + ut_d(dict_table_t *table= lock->un_member.tab_lock.table); + ut_ad(!table->is_temporary()); + ut_ad(table->id >= DICT_HDR_FIRST_ID || + (lock->mode() != LOCK_IX && lock->mode() != LOCK_X) || + trx->dict_operation || trx->was_dict_operation); + lock_table_dequeue(lock, false); + } - table->query_cache_inv_trx_id = max_trx_id; - } + if (!--count) + break; + } - lock_table_dequeue(lock); - } + lock_sys.wr_unlock(); + trx->mutex_unlock(); + if (!count) + goto restart; - if (count == LOCK_RELEASE_INTERVAL) { - /* Release the mutex for a while, so that we - do not monopolize it */ +released: + if (UNIV_UNLIKELY(Deadlock::to_be_checked)) + { + mysql_mutex_lock(&lock_sys.wait_mutex); + lock_sys.deadlock_check(); + mysql_mutex_unlock(&lock_sys.wait_mutex); + } - lock_mutex_exit(); + trx->lock.n_rec_locks= 0; - lock_mutex_enter(); +#ifdef UNIV_DEBUG + if (to_evict.empty()) + return; + dict_sys.lock(SRW_LOCK_CALL); + LockMutexGuard g{SRW_LOCK_CALL}; + for (const table_id_t id : to_evict) + if (dict_table_t *table= dict_sys.find_table(id)) + if (!table->get_ref_count() && !UT_LIST_GET_LEN(table->locks)) + dict_sys.remove(table, true); + dict_sys.unlock(); +#endif +} - count = 0; - } +/** Release the explicit locks of a committing transaction while +dict_sys.latch is exclusively locked, +and release possible other transactions waiting because of these locks. */ +void lock_release_on_drop(trx_t *trx) +{ + ut_ad(lock_sys.is_writer()); + ut_ad(trx->mutex_is_owner()); + ut_ad(trx->dict_operation); - ++count; - } + while (lock_t *lock= UT_LIST_GET_LAST(trx->lock.trx_locks)) + { + ut_ad(lock->trx == trx); + if (!lock->is_table()) + { + ut_ad(!lock->index->table->is_temporary()); + ut_ad(lock->mode() != LOCK_X || + lock->index->table->id >= DICT_HDR_FIRST_ID || + trx->dict_operation); + lock_rec_dequeue_from_page(lock, false); + } + else + { + ut_d(dict_table_t *table= lock->un_member.tab_lock.table); + ut_ad(!table->is_temporary()); + ut_ad(table->id >= DICT_HDR_FIRST_ID || + (lock->mode() != LOCK_IX && lock->mode() != LOCK_X) || + trx->dict_operation); + lock_table_dequeue(lock, false); + } + } +} - lock_mutex_exit(); +/** Release non-exclusive locks on XA PREPARE, +and wake up possible other transactions waiting because of these locks. +@param trx transaction in XA PREPARE state +@return whether all locks were released */ +static bool lock_release_on_prepare_try(trx_t *trx) +{ + /* At this point, trx->lock.trx_locks can still be modified by other + threads to convert implicit exclusive locks into explicit ones. + + The function lock_table_create() should never be invoked on behalf + of a transaction that is running in another thread. Also there, we + will assert that the current transaction be active. */ + DBUG_ASSERT(trx->state == TRX_STATE_PREPARED); + + bool all_released= true; + lock_sys.rd_lock(SRW_LOCK_CALL); + trx->mutex_lock(); + + /* Note: Normally, trx->mutex is not held while acquiring + a lock table latch, but here we are following the opposite order. + To avoid deadlocks, we only try to acquire the lock table latches + but not keep waiting for them. */ + + for (lock_t *prev, *lock= UT_LIST_GET_LAST(trx->lock.trx_locks); lock; + lock= prev) + { + ut_ad(lock->trx == trx); + prev= UT_LIST_GET_PREV(trx_locks, lock); + if (!lock->is_table()) + { + ut_ad(!lock->index->table->is_temporary()); + if (lock->mode() == LOCK_X && !lock->is_gap()) { + ut_ad(lock->trx->isolation_level > TRX_ISO_READ_COMMITTED || + /* Insert-intention lock is valid for supremum for isolation + level > TRX_ISO_READ_COMMITTED */ + lock->mode() == LOCK_X || + !lock_rec_get_nth_bit(lock, PAGE_HEAP_NO_SUPREMUM)); + continue; + } + auto &lock_hash= lock_sys.hash_get(lock->type_mode); + auto cell= lock_hash.cell_get(lock->un_member.rec_lock.page_id.fold()); + auto latch= lock_sys_t::hash_table::latch(cell); + if (latch->try_acquire()) + { + lock_rec_dequeue_from_page(lock, false); + latch->release(); + } + else + all_released= false; + } + else + { + dict_table_t *table= lock->un_member.tab_lock.table; + ut_ad(!table->is_temporary()); + switch (lock->mode()) { + case LOCK_IS: + case LOCK_S: + if (table->lock_mutex_trylock()) + { + lock_table_dequeue(lock, false); + table->lock_mutex_unlock(); + } + else + all_released= false; + break; + case LOCK_IX: + case LOCK_X: + ut_ad(table->id >= DICT_HDR_FIRST_ID || trx->dict_operation); + /* fall through */ + default: + break; + } + } + } -#ifdef UNIV_DEBUG - if (to_evict.empty()) { - return; - } - mutex_enter(&dict_sys.mutex); - lock_mutex_enter(); - for (table_id_t id : to_evict) { - if (dict_table_t *table = dict_table_open_on_id( - id, TRUE, DICT_TABLE_OP_OPEN_ONLY_IF_CACHED)) { - if (!table->get_ref_count() - && !UT_LIST_GET_LEN(table->locks)) { - dict_sys.remove(table, true); - } - } - } - lock_mutex_exit(); - mutex_exit(&dict_sys.mutex); -#endif + lock_sys.rd_unlock(); + trx->mutex_unlock(); + return all_released; } /** Release non-exclusive locks on XA PREPARE, and release possible other transactions waiting because of these locks. */ void lock_release_on_prepare(trx_t *trx) { - ulint count= 0; - lock_mutex_enter(); - ut_ad(!trx_mutex_own(trx)); + auto _ = make_scope_exit([trx]() { trx->set_skip_lock_inheritance(); }); - for (lock_t *lock= UT_LIST_GET_LAST(trx->lock.trx_locks); lock; ) + for (ulint count= 5; count--; ) + if (lock_release_on_prepare_try(trx)) + return; + + LockMutexGuard g{SRW_LOCK_CALL}; + trx->mutex_lock(); + + for (lock_t *prev, *lock= UT_LIST_GET_LAST(trx->lock.trx_locks); lock; + lock= prev) { ut_ad(lock->trx == trx); - - if (lock_get_type_low(lock) == LOCK_REC) + prev= UT_LIST_GET_PREV(trx_locks, lock); + if (!lock->is_table()) { ut_ad(!lock->index->table->is_temporary()); - if (lock_rec_get_gap(lock) || lock_get_mode(lock) != LOCK_X) - lock_rec_dequeue_from_page(lock); + if (lock->mode() != LOCK_X || lock->is_gap()) + lock_rec_dequeue_from_page(lock, false); else - { - ut_ad(trx->dict_operation || - lock->index->table->id >= DICT_HDR_FIRST_ID); ut_ad(lock->trx->isolation_level > TRX_ISO_READ_COMMITTED || /* Insert-intention lock is valid for supremum for isolation level > TRX_ISO_READ_COMMITTED */ - lock_get_mode(lock) == LOCK_X || + lock->mode() == LOCK_X || !lock_rec_get_nth_bit(lock, PAGE_HEAP_NO_SUPREMUM)); -retain_lock: - lock= UT_LIST_GET_PREV(trx_locks, lock); - continue; - } } else { - ut_ad(lock_get_type_low(lock) & LOCK_TABLE); ut_d(dict_table_t *table= lock->un_member.tab_lock.table); ut_ad(!table->is_temporary()); - - switch (lock_get_mode(lock)) { + switch (lock->mode()) { case LOCK_IS: case LOCK_S: - lock_table_dequeue(lock); + lock_table_dequeue(lock, false); break; case LOCK_IX: case LOCK_X: ut_ad(table->id >= DICT_HDR_FIRST_ID || trx->dict_operation); /* fall through */ default: - goto retain_lock; + break; } } + } - if (++count == LOCK_RELEASE_INTERVAL) - { - lock_mutex_exit(); - count= 0; - lock_mutex_enter(); - } + trx->mutex_unlock(); +} + +/** Release locks on a table whose creation is being rolled back */ +ATTRIBUTE_COLD +void lock_release_on_rollback(trx_t *trx, dict_table_t *table) +{ + trx->mod_tables.erase(table); - lock= UT_LIST_GET_LAST(trx->lock.trx_locks); + /* This is very rarely executed code, in the rare case that an + CREATE TABLE operation is being rolled back. Theoretically, + we might try to remove the locks in multiple memory transactions. */ + lock_sys.wr_lock(SRW_LOCK_CALL); + trx->mutex_lock(); + + for (lock_t *next, *lock= UT_LIST_GET_FIRST(table->locks); lock; lock= next) + { + next= UT_LIST_GET_NEXT(un_member.tab_lock.locks, lock); + ut_ad(lock->trx == trx); + UT_LIST_REMOVE(trx->lock.trx_locks, lock); + ut_list_remove(table->locks, lock, TableLockGetNode()); } - lock_mutex_exit(); + for (lock_t *p, *lock= UT_LIST_GET_LAST(trx->lock.trx_locks); lock; lock= p) + { + p= UT_LIST_GET_PREV(trx_locks, lock); + ut_ad(lock->trx == trx); + if (lock->is_table()) + ut_ad(lock->un_member.tab_lock.table != table); + else if (lock->index->table == table) + lock_rec_dequeue_from_page(lock, false); + } - trx->set_skip_lock_inheritance(); + lock_sys.wr_unlock(); + trx->mutex_unlock(); } -/* True if a lock mode is S or X */ -#define IS_LOCK_S_OR_X(lock) \ - (lock_get_mode(lock) == LOCK_S \ - || lock_get_mode(lock) == LOCK_X) - /*********************************************************************//** Removes table locks of the transaction on a table to be dropped. */ static @@ -4331,38 +4241,24 @@ lock_trx_table_locks_remove( { trx_t* trx = lock_to_remove->trx; - ut_ad(lock_mutex_own()); - - /* It is safe to read this because we are holding the lock mutex */ - if (!trx->lock.cancel) { - trx_mutex_enter(trx); - } else { - ut_ad(trx_mutex_own(trx)); - } + ut_ad(lock_to_remove->is_table()); + lock_sys.assert_locked(*lock_to_remove->un_member.tab_lock.table); + ut_ad(trx->mutex_is_owner()); for (lock_list::iterator it = trx->lock.table_locks.begin(), end = trx->lock.table_locks.end(); it != end; ++it) { const lock_t* lock = *it; ut_ad(!lock || trx == lock->trx); - ut_ad(!lock || lock_get_type_low(lock) & LOCK_TABLE); + ut_ad(!lock || lock->is_table()); ut_ad(!lock || lock->un_member.tab_lock.table); if (lock == lock_to_remove) { *it = NULL; - - if (!trx->lock.cancel) { - trx_mutex_exit(trx); - } - return; } } - if (!trx->lock.cancel) { - trx_mutex_exit(trx); - } - /* Lock must exist in the vector. */ ut_error; } @@ -4376,32 +4272,37 @@ static void lock_table_print(FILE* file, const lock_t* lock) { - ut_ad(lock_mutex_own()); - ut_a(lock_get_type_low(lock) == LOCK_TABLE); + lock_sys.assert_locked(); + ut_a(lock->is_table()); fputs("TABLE LOCK table ", file); ut_print_name(file, lock->trx, lock->un_member.tab_lock.table->name.m_name); - fprintf(file, " trx id " TRX_ID_FMT, trx_get_id_for_print(lock->trx)); + fprintf(file, " trx id " TRX_ID_FMT, lock->trx->id); - if (lock_get_mode(lock) == LOCK_S) { + switch (auto mode = lock->mode()) { + case LOCK_S: fputs(" lock mode S", file); - } else if (lock_get_mode(lock) == LOCK_X) { + break; + case LOCK_X: ut_ad(lock->trx->id != 0); fputs(" lock mode X", file); - } else if (lock_get_mode(lock) == LOCK_IS) { + break; + case LOCK_IS: fputs(" lock mode IS", file); - } else if (lock_get_mode(lock) == LOCK_IX) { + break; + case LOCK_IX: ut_ad(lock->trx->id != 0); fputs(" lock mode IX", file); - } else if (lock_get_mode(lock) == LOCK_AUTO_INC) { + break; + case LOCK_AUTO_INC: fputs(" lock mode AUTO-INC", file); - } else { - fprintf(file, " unknown lock mode %lu", - (ulong) lock_get_mode(lock)); + break; + default: + fprintf(file, " unknown lock mode %u", mode); } - if (lock_get_wait(lock)) { + if (lock->is_waiting()) { fputs(" waiting", file); } @@ -4414,10 +4315,10 @@ lock_table_print(FILE* file, const lock_t* lock) @param[in,out] mtr mini-transaction for accessing the record */ static void lock_rec_print(FILE* file, const lock_t* lock, mtr_t& mtr) { - ut_ad(lock_mutex_own()); - ut_a(lock_get_type_low(lock) == LOCK_REC); + ut_ad(!lock->is_table()); - const page_id_t page_id(lock->un_member.rec_lock.page_id); + const page_id_t page_id{lock->un_member.rec_lock.page_id}; + ut_d(lock_sys.hash_get(lock->type_mode).assert_locked(page_id)); fprintf(file, "RECORD LOCKS space id %u page no %u n bits " ULINTPF " index %s of table ", @@ -4425,29 +4326,32 @@ static void lock_rec_print(FILE* file, const lock_t* lock, mtr_t& mtr) lock_rec_get_n_bits(lock), lock->index->name()); ut_print_name(file, lock->trx, lock->index->table->name.m_name); - fprintf(file, " trx id " TRX_ID_FMT, trx_get_id_for_print(lock->trx)); + fprintf(file, " trx id " TRX_ID_FMT, lock->trx->id); - if (lock_get_mode(lock) == LOCK_S) { + switch (lock->mode()) { + case LOCK_S: fputs(" lock mode S", file); - } else if (lock_get_mode(lock) == LOCK_X) { + break; + case LOCK_X: fputs(" lock_mode X", file); - } else { + break; + default: ut_error; } - if (lock_rec_get_gap(lock)) { + if (lock->is_gap()) { fputs(" locks gap before rec", file); } - if (lock_rec_get_rec_not_gap(lock)) { + if (lock->is_record_not_gap()) { fputs(" locks rec but not gap", file); } - if (lock_rec_get_insert_intention(lock)) { + if (lock->is_insert_intention()) { fputs(" insert intention", file); } - if (lock_get_wait(lock)) { + if (lock->is_waiting()) { fputs(" waiting", file); } @@ -4470,7 +4374,7 @@ static void lock_rec_print(FILE* file, const lock_t* lock, mtr_t& mtr) fprintf(file, "Record lock, heap no %lu", (ulong) i); if (block) { - ut_ad(page_is_leaf(block->frame)); + ut_ad(page_is_leaf(block->page.frame)); const rec_t* rec; rec = page_find_rec_with_heap_no( @@ -4507,12 +4411,13 @@ http://bugs.mysql.com/36942 */ /*********************************************************************//** Calculates the number of record lock structs in the record lock hash table. @return number of record locks */ +TRANSACTIONAL_TARGET static ulint lock_get_n_rec_locks() { ulint n_locks = 0; ulint i; - ut_ad(lock_mutex_own()); + lock_sys.assert_locked(); for (i = 0; i < lock_sys.rec_hash.n_cells; i++) { const lock_t* lock; @@ -4533,26 +4438,25 @@ static ulint lock_get_n_rec_locks() /*********************************************************************//** Prints info of locks for all transactions. -@return FALSE if not able to obtain lock mutex -and exits without printing info */ +@return FALSE if not able to acquire lock_sys.latch (and dislay info) */ ibool lock_print_info_summary( /*====================*/ FILE* file, /*!< in: file where to print */ - ibool nowait) /*!< in: whether to wait for the lock mutex */ + ibool nowait) /*!< in: whether to wait for lock_sys.latch */ { - /* if nowait is FALSE, wait on the lock mutex, - otherwise return immediately if fail to obtain the - mutex. */ + /* Here, lock elision does not make sense, because + for the output we are going to invoke system calls, + which would interrupt a memory transaction. */ if (!nowait) { - lock_mutex_enter(); - } else if (lock_mutex_enter_nowait()) { + lock_sys.wr_lock(SRW_LOCK_CALL); + } else if (!lock_sys.wr_lock_try()) { fputs("FAIL TO OBTAIN LOCK MUTEX," " SKIP LOCK INFO PRINTING\n", file); return(FALSE); } - if (lock_deadlock_found) { + if (lock_sys.deadlocks) { fputs("------------------------\n" "LATEST DETECTED DEADLOCK\n" "------------------------\n", file); @@ -4579,7 +4483,7 @@ lock_print_info_summary( ? (purge_sys.running() ? "running" : purge_sys.paused() ? "stopped" : "running but idle") : "disabled", - size_t{trx_sys.rseg_history_len}); + trx_sys.history_size_approx()); #ifdef PRINT_NUM_OF_LOCK_STRUCTS fprintf(file, @@ -4592,27 +4496,27 @@ lock_print_info_summary( /** Prints transaction lock wait and MVCC state. @param[in,out] file file where to print @param[in] trx transaction -@param[in] now current time */ -void -lock_trx_print_wait_and_mvcc_state(FILE* file, const trx_t* trx, time_t now) +@param[in] now current my_hrtime_coarse() */ +void lock_trx_print_wait_and_mvcc_state(FILE *file, const trx_t *trx, + my_hrtime_t now) { fprintf(file, "---"); trx_print_latched(file, trx, 600); trx->read_view.print_limits(file); - if (trx->lock.que_state == TRX_QUE_LOCK_WAIT) { - + if (const lock_t* wait_lock = trx->lock.wait_lock) { + const my_hrtime_t suspend_time= trx->lock.suspend_time; fprintf(file, - "------- TRX HAS BEEN WAITING %lu SEC" + "------- TRX HAS BEEN WAITING %llu ns" " FOR THIS LOCK TO BE GRANTED:\n", - (ulong) difftime(now, trx->lock.wait_started)); + now.val - suspend_time.val); - if (lock_get_type_low(trx->lock.wait_lock) == LOCK_REC) { + if (!wait_lock->is_table()) { mtr_t mtr; - lock_rec_print(file, trx->lock.wait_lock, mtr); + lock_rec_print(file, wait_lock, mtr); } else { - lock_table_print(file, trx->lock.wait_lock); + lock_table_print(file, wait_lock); } fprintf(file, "------------------\n"); @@ -4631,15 +4535,13 @@ lock_trx_print_locks( mtr_t mtr; uint32_t i= 0; /* Iterate over the transaction's locks. */ + lock_sys.assert_locked(); for (lock_t *lock = UT_LIST_GET_FIRST(trx->lock.trx_locks); lock != NULL; lock = UT_LIST_GET_NEXT(trx_locks, lock)) { - if (lock_get_type_low(lock) == LOCK_REC) { - + if (!lock->is_table()) { lock_rec_print(file, lock, mtr); } else { - ut_ad(lock_get_type_low(lock) & LOCK_TABLE); - lock_table_print(file, lock); } @@ -4657,9 +4559,9 @@ lock_trx_print_locks( /** Functor to display all transactions */ struct lock_print_info { - lock_print_info(FILE* file, time_t now) : + lock_print_info(FILE* file, my_hrtime_t now) : file(file), now(now), - purge_trx(purge_sys.query ? purge_sys.query->trx : NULL) + purge_trx(purge_sys.query ? purge_sys.query->trx : nullptr) {} void operator()(const trx_t &trx) const @@ -4673,27 +4575,24 @@ struct lock_print_info } FILE* const file; - const time_t now; + const my_hrtime_t now; const trx_t* const purge_trx; }; /*********************************************************************//** -Prints info of locks for each transaction. This function assumes that the -caller holds the lock mutex and more importantly it will release the lock -mutex on behalf of the caller. (This should be fixed in the future). */ +Prints info of locks for each transaction. This function will release +lock_sys.latch, which the caller must be holding in exclusive mode. */ void lock_print_info_all_transactions( /*=============================*/ FILE* file) /*!< in/out: file where to print */ { - ut_ad(lock_mutex_own()); - fprintf(file, "LIST OF TRANSACTIONS FOR EACH SESSION:\n"); - trx_sys.trx_list.for_each(lock_print_info(file, time(nullptr))); - lock_mutex_exit(); + trx_sys.trx_list.for_each(lock_print_info(file, my_hrtime_coarse())); + lock_sys.wr_unlock(); - ut_ad(lock_validate()); + ut_d(lock_validate()); } #ifdef UNIV_DEBUG @@ -4709,7 +4608,7 @@ lock_trx_table_locks_find( { bool found = false; - ut_ad(trx_mutex_own(trx)); + ut_ad(trx->mutex_is_owner()); for (lock_list::const_iterator it = trx->lock.table_locks.begin(), end = trx->lock.table_locks.end(); it != end; ++it) { @@ -4728,7 +4627,7 @@ lock_trx_table_locks_find( } ut_a(trx == lock->trx); - ut_a(lock_get_type_low(lock) & LOCK_TABLE); + ut_a(lock->is_table()); ut_a(lock->un_member.tab_lock.table != NULL); } @@ -4746,29 +4645,29 @@ lock_table_queue_validate( { const lock_t* lock; - ut_ad(lock_mutex_own()); + lock_sys.assert_locked(*table); for (lock = UT_LIST_GET_FIRST(table->locks); lock != NULL; lock = UT_LIST_GET_NEXT(un_member.tab_lock.locks, lock)) { /* 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.latch. It may change from ACTIVE or PREPARED to PREPARED or COMMITTED. */ - trx_mutex_enter(lock->trx); + lock->trx->mutex_lock(); check_trx_state(lock->trx); if (lock->trx->state == TRX_STATE_COMMITTED_IN_MEMORY) { - } else if (!lock_get_wait(lock)) { + } else if (!lock->is_waiting()) { ut_a(!lock_table_other_has_incompatible( lock->trx, 0, table, - lock_get_mode(lock))); + lock->mode())); } else { ut_a(lock_table_has_to_wait_in_queue(lock)); } ut_a(lock_trx_table_locks_find(lock->trx, lock)); - trx_mutex_exit(lock->trx); + lock->trx->mutex_unlock(); } return(TRUE); @@ -4783,9 +4682,9 @@ lock_rec_queue_validate( /*====================*/ bool locked_lock_trx_sys, /*!< in: if the caller holds - both the lock mutex and + both the lock_sys.latch and trx_sys_t->lock. */ - const buf_block_t* block, /*!< in: buffer block containing rec */ + const page_id_t id, /*!< in: page identifier */ const rec_t* rec, /*!< in: record to look at */ const dict_index_t* index, /*!< in: index, or NULL if not known */ const rec_offs* offsets)/*!< in: rec_get_offsets(rec, index) */ @@ -4794,49 +4693,48 @@ lock_rec_queue_validate( ulint heap_no; ut_a(rec); - ut_a(block->frame == page_align(rec)); ut_ad(rec_offs_validate(rec, index, offsets)); ut_ad(!page_rec_is_comp(rec) == !rec_offs_comp(offsets)); ut_ad(page_rec_is_leaf(rec)); - ut_ad(lock_mutex_own() == locked_lock_trx_sys); ut_ad(!index || dict_index_is_clust(index) || !dict_index_is_online_ddl(index)); heap_no = page_rec_get_heap_no(rec); if (!locked_lock_trx_sys) { - lock_mutex_enter(); + lock_sys.wr_lock(SRW_LOCK_CALL); } + hash_cell_t &cell= *lock_sys.rec_hash.cell_get(id.fold()); + lock_sys.assert_locked(cell); + if (!page_rec_is_user_rec(rec)) { - for (lock = lock_rec_get_first(&lock_sys.rec_hash, - block, heap_no); + for (lock = lock_sys_t::get_first(cell, id, heap_no); lock != NULL; lock = lock_rec_get_next_const(heap_no, lock)) { ut_ad(!index || lock->index == index); - trx_mutex_enter(lock->trx); + lock->trx->mutex_lock(); ut_ad(!lock->trx->read_only || !lock->trx->is_autocommit_non_locking()); ut_ad(trx_state_eq(lock->trx, TRX_STATE_COMMITTED_IN_MEMORY) - || !lock_get_wait(lock) - || lock_rec_has_to_wait_in_queue(lock)); - trx_mutex_exit(lock->trx); + || !lock->is_waiting() + || lock_rec_has_to_wait_in_queue(cell, lock)); + lock->trx->mutex_unlock(); } func_exit: if (!locked_lock_trx_sys) { - lock_mutex_exit(); + lock_sys.wr_unlock(); } return true; } ut_ad(page_rec_is_leaf(rec)); - ut_ad(lock_mutex_own()); const trx_id_t impl_trx_id = index && index->is_primary() ? lock_clust_rec_some_has_impl(rec, index, offsets) @@ -4848,12 +4746,12 @@ func_exit: /* impl_trx could have been committed before we acquire its mutex, but not thereafter. */ - mutex_enter(&impl_trx->mutex); + impl_trx->mutex_lock(); ut_ad(impl_trx->state != TRX_STATE_NOT_STARTED); if (impl_trx->state == TRX_STATE_COMMITTED_IN_MEMORY) { } else if (const lock_t* other_lock = lock_rec_other_has_expl_req( - LOCK_S, block, true, heap_no, + LOCK_S, cell, id, true, heap_no, impl_trx)) { /* The impl_trx is holding an implicit lock on the given record 'rec'. So there cannot be another @@ -4881,28 +4779,29 @@ func_exit: for BF abort or kill victim. ** There should not be two BF transactions waiting for same record lock */ - if (other_lock->trx->is_wsrep() && !lock_get_wait(other_lock)) { + if (other_lock->trx->is_wsrep() && !other_lock->is_waiting()) { wsrep_report_bf_lock_wait(impl_trx->mysql_thd, impl_trx->id); wsrep_report_bf_lock_wait(other_lock->trx->mysql_thd, other_lock->trx->id); if (!lock_rec_has_expl(LOCK_X | LOCK_REC_NOT_GAP, - block, heap_no, + cell, id, heap_no, impl_trx)) { ib::info() << "WSREP impl BF lock conflict"; } } else #endif /* WITH_WSREP */ { - ut_ad(lock_get_wait(other_lock)); + ut_ad(other_lock->is_waiting()); ut_ad(lock_rec_has_expl(LOCK_X | LOCK_REC_NOT_GAP, - block, heap_no, impl_trx)); + cell, id, heap_no, + impl_trx)); } } - mutex_exit(&impl_trx->mutex); + impl_trx->mutex_unlock(); } - for (lock = lock_rec_get_first(&lock_sys.rec_hash, block, heap_no); + for (lock = lock_sys_t::get_first(cell, id, heap_no); lock != NULL; lock = lock_rec_get_next_const(heap_no, lock)) { ut_ad(!lock->trx->read_only @@ -4913,19 +4812,16 @@ func_exit: ut_a(lock->index == index); } - if (!lock_rec_get_gap(lock) && !lock_get_wait(lock)) { - - lock_mode mode; - - if (lock_get_mode(lock) == LOCK_S) { - mode = LOCK_X; - } else { - mode = LOCK_S; - } + if (lock->is_waiting()) { + ut_a(lock->is_gap() + || lock_rec_has_to_wait_in_queue(cell, lock)); + } else if (!lock->is_gap()) { + const lock_mode mode = lock->mode() == LOCK_S + ? LOCK_X : LOCK_S; const lock_t* other_lock = lock_rec_other_has_expl_req( - mode, block, false, heap_no, + mode, cell, id, false, heap_no, lock->trx); #ifdef WITH_WSREP if (UNIV_UNLIKELY(other_lock && lock->trx->is_wsrep())) { @@ -4942,26 +4838,17 @@ func_exit: } else #endif /* WITH_WSREP */ ut_ad(!other_lock); - } else if (lock_get_wait(lock) && !lock_rec_get_gap(lock)) { - - ut_a(lock_rec_has_to_wait_in_queue(lock)); } } - ut_ad(innodb_lock_schedule_algorithm == INNODB_LOCK_SCHEDULE_ALGORITHM_FCFS || - lock_queue_validate(lock)); - goto func_exit; } -/*********************************************************************//** -Validates the record lock queues on a page. -@return TRUE if ok */ -static -ibool -lock_rec_validate_page( -/*===================*/ - const buf_block_t* block) /*!< in: buffer block */ +/** Validate the record lock queues on a page. +@param block buffer pool block +@param latched whether the tablespace latch may be held +@return true if ok */ +static bool lock_rec_validate_page(const buf_block_t *block, bool latched) { const lock_t* lock; const rec_t* rec; @@ -4973,15 +4860,17 @@ lock_rec_validate_page( rec_offs* offsets = offsets_; rec_offs_init(offsets_); - lock_mutex_enter(); + const page_id_t id{block->page.id()}; + + LockGuard g{lock_sys.rec_hash, id}; loop: - lock = lock_sys.get_first(block->page.id()); + lock = lock_sys_t::get_first(g.cell(), id); if (!lock) { goto function_exit; } - DBUG_ASSERT(block->page.status != buf_page_t::FREED); + DBUG_ASSERT(!block->page.is_freed()); for (i = 0; i < nth_lock; i++) { @@ -4996,13 +4885,13 @@ loop: || !lock->trx->is_autocommit_non_locking()); /* Only validate the record queues when this thread is not - holding a space->latch. */ - if (!sync_check_find(SYNC_FSP)) + holding a tablespace latch. */ + if (!latched) for (i = nth_bit; i < lock_rec_get_n_bits(lock); i++) { bool locked = lock_rec_get_nth_bit(lock, i); if (locked || i == PAGE_HEAP_NO_SUPREMUM) { - rec = page_find_rec_with_heap_no(block->frame, i); + rec = page_find_rec_with_heap_no(block->page.frame, i); ut_a(rec); ut_ad(!locked || page_rec_is_leaf(rec)); @@ -5015,7 +4904,7 @@ loop: offsets = rec_get_offsets(rec, lock->index, offsets, lock->index->n_core_fields, ULINT_UNDEFINED, &heap); - lock_rec_queue_validate(TRUE, block, rec, + lock_rec_queue_validate(true, id, rec, lock->index, offsets); } @@ -5031,8 +4920,6 @@ loop: goto loop; function_exit: - lock_mutex_exit(); - if (heap != NULL) { mem_heap_free(heap); } @@ -5051,7 +4938,7 @@ lock_rec_validate( page_id_t* limit) /*!< in/out: upper limit of (space, page_no) */ { - ut_ad(lock_mutex_own()); + lock_sys.assert_locked(); for (const lock_t* lock = static_cast<const lock_t*>( HASH_GET_FIRST(&lock_sys.rec_hash, start)); @@ -5060,7 +4947,7 @@ lock_rec_validate( ut_ad(!lock->trx->read_only || !lock->trx->is_autocommit_non_locking()); - ut_ad(lock_get_type(lock) == LOCK_REC); + ut_ad(!lock->is_table()); page_id_t current(lock->un_member.rec_lock.page_id); @@ -5078,9 +4965,7 @@ Validate a record lock's block */ static void lock_rec_block_validate(const page_id_t page_id) { /* The lock and the block that it is referring to may be freed at - this point. We pass BUF_GET_POSSIBLY_FREED to skip a debug check. - If the lock exists in lock_rec_validate_page() we assert - block->page.status != FREED. */ + this point. */ buf_block_t* block; mtr_t mtr; @@ -5097,15 +4982,12 @@ static void lock_rec_block_validate(const page_id_t page_id) block = buf_page_get_gen( page_id, space->zip_size(), - RW_X_LATCH, NULL, + RW_S_LATCH, NULL, BUF_GET_POSSIBLY_FREED, - __FILE__, __LINE__, &mtr, &err); + &mtr, &err); - if (block && block->page.status != buf_page_t::FREED) { - buf_block_dbg_add_level(block, SYNC_NO_ORDER_CHECK); - - ut_ad(lock_rec_validate_page(block)); - } + ut_ad(!block + || lock_rec_validate_page(block, space->is_latched())); mtr_commit(&mtr); @@ -5113,65 +4995,48 @@ static void lock_rec_block_validate(const page_id_t page_id) } } - static my_bool lock_validate_table_locks(rw_trx_hash_element_t *element, void*) { - ut_ad(lock_mutex_own()); - mutex_enter(&element->mutex); + lock_sys.assert_locked(); + element->mutex.wr_lock(); if (element->trx) { check_trx_state(element->trx); for (const lock_t *lock= UT_LIST_GET_FIRST(element->trx->lock.trx_locks); lock != NULL; lock= UT_LIST_GET_NEXT(trx_locks, lock)) - { - if (lock_get_type_low(lock) & LOCK_TABLE) + if (lock->is_table()) lock_table_queue_validate(lock->un_member.tab_lock.table); - } } - mutex_exit(&element->mutex); + element->mutex.wr_unlock(); return 0; } -/*********************************************************************//** -Validates the lock system. -@return TRUE if ok */ -static -bool -lock_validate() -/*===========*/ +/** Validate the transactional locks. */ +static void lock_validate() { - std::set<page_id_t> pages; - - lock_mutex_enter(); - - /* Validate table locks */ - trx_sys.rw_trx_hash.iterate(lock_validate_table_locks); - - /* Iterate over all the record locks and validate the locks. We - don't want to hog the lock_sys_t::mutex. Release it during the - validation check. */ - - for (ulint i = 0; i < lock_sys.rec_hash.n_cells; i++) { - page_id_t limit(0, 0); - - while (const lock_t* lock = lock_rec_validate(i, &limit)) { - if (lock_rec_find_set_bit(lock) == ULINT_UNDEFINED) { - /* The lock bitmap is empty; ignore it. */ - continue; - } - pages.insert(lock->un_member.rec_lock.page_id); - } - } - - lock_mutex_exit(); + std::set<page_id_t> pages; + { + LockMutexGuard g{SRW_LOCK_CALL}; + /* Validate table locks */ + trx_sys.rw_trx_hash.iterate(lock_validate_table_locks); - for (page_id_t page_id : pages) { - lock_rec_block_validate(page_id); - } + for (ulint i= 0; i < lock_sys.rec_hash.n_cells; i++) + { + page_id_t limit{0, 0}; + while (const lock_t *lock= lock_rec_validate(i, &limit)) + { + if (lock_rec_find_set_bit(lock) == ULINT_UNDEFINED) + /* The lock bitmap is empty; ignore it. */ + continue; + pages.insert(lock->un_member.rec_lock.page_id); + } + } + } - return(true); + for (page_id_t page_id : pages) + lock_rec_block_validate(page_id); } #endif /* UNIV_DEBUG */ /*============ RECORD LOCK CHECKS FOR ROW OPERATIONS ====================*/ @@ -5183,11 +5048,10 @@ be suspended for some reason; if not, then puts the transaction and the query thread to the lock wait state and inserts a waiting request for a gap x-lock to the lock queue. @return DB_SUCCESS, DB_LOCK_WAIT, or DB_DEADLOCK */ +TRANSACTIONAL_TARGET dberr_t lock_rec_insert_check_and_lock( /*===========================*/ - ulint flags, /*!< in: if BTR_NO_LOCKING_FLAG bit is - set, does nothing */ const rec_t* rec, /*!< in: record after which to insert */ buf_block_t* block, /*!< in/out: buffer block of rec */ dict_index_t* index, /*!< in: index */ @@ -5198,137 +5062,96 @@ lock_rec_insert_check_and_lock( LOCK_GAP type locks from the successor record */ { - ut_ad(block->frame == page_align(rec)); - ut_ad(!dict_index_is_online_ddl(index) - || index->is_primary() - || (flags & BTR_CREATE_FLAG)); - ut_ad(mtr->is_named_space(index->table->space)); - ut_ad(page_rec_is_leaf(rec)); - - if (flags & BTR_NO_LOCKING_FLAG) { - - return(DB_SUCCESS); - } + ut_ad(block->page.frame == page_align(rec)); + ut_ad(mtr->is_named_space(index->table->space)); + ut_ad(page_is_leaf(block->page.frame)); + ut_ad(!index->table->is_temporary()); - ut_ad(!index->table->is_temporary()); - ut_ad(page_is_leaf(block->frame)); - - dberr_t err; - lock_t* lock; - bool inherit_in = *inherit; - trx_t* trx = thr_get_trx(thr); - const rec_t* next_rec = page_rec_get_next_const(rec); - ulint heap_no = page_rec_get_heap_no(next_rec); - ut_ad(!rec_is_metadata(next_rec, *index)); - - lock_mutex_enter(); - /* Because this code is invoked for a running transaction by - the thread that is serving the transaction, it is not necessary - to hold trx->mutex here. */ - - /* When inserting a record into an index, the table must be at - least IX-locked. When we are building an index, we would pass - BTR_NO_LOCKING_FLAG and skip the locking altogether. */ - ut_ad(lock_table_has(trx, index->table, LOCK_IX)); - - lock = lock_rec_get_first(&lock_sys.rec_hash, block, heap_no); - - if (lock == NULL) { - /* We optimize CPU time usage in the simplest case */ - - lock_mutex_exit(); - - if (inherit_in && !dict_index_is_clust(index)) { - /* Update the page max trx id field */ - page_update_max_trx_id(block, - buf_block_get_page_zip(block), - trx->id, mtr); - } - - *inherit = false; - - return(DB_SUCCESS); - } - - /* Spatial index does not use GAP lock protection. It uses - "predicate lock" to protect the "range" */ - if (dict_index_is_spatial(index)) { - return(DB_SUCCESS); - } - - *inherit = true; - - /* If another transaction has an explicit lock request which locks - the gap, waiting or granted, on the successor, the insert has to wait. - - An exception is the case where the lock by the another transaction - is a gap type lock which it placed to wait for its turn to insert. We - do not consider that kind of a lock conflicting with our insert. This - eliminates an unnecessary deadlock which resulted when 2 transactions - had to wait for their insert. Both had waiting gap type lock requests - on the successor, which produced an unnecessary deadlock. */ + const rec_t *next_rec= page_rec_get_next_const(rec); + if (UNIV_UNLIKELY(!next_rec || rec_is_metadata(next_rec, *index))) + return DB_CORRUPTION; - const unsigned type_mode = LOCK_X | LOCK_GAP | LOCK_INSERT_INTENTION; - - if ( -#ifdef WITH_WSREP - lock_t* c_lock = -#endif /* WITH_WSREP */ - lock_rec_other_has_conflicting(type_mode, block, heap_no, trx)) { - /* Note that we may get DB_SUCCESS also here! */ - trx_mutex_enter(trx); + dberr_t err= DB_SUCCESS; + bool inherit_in= *inherit; + trx_t *trx= thr_get_trx(thr); + ulint heap_no= page_rec_get_heap_no(next_rec); + const page_id_t id{block->page.id()}; - err = lock_rec_enqueue_waiting( -#ifdef WITH_WSREP - c_lock, -#endif /* WITH_WSREP */ - type_mode, block, heap_no, index, thr, NULL); + { + LockGuard g{lock_sys.rec_hash, id}; + /* Because this code is invoked for a running transaction by + the thread that is serving the transaction, it is not necessary + to hold trx->mutex here. */ - trx_mutex_exit(trx); - } else { - err = DB_SUCCESS; - } + /* When inserting a record into an index, the table must be at + least IX-locked. When we are building an index, we would pass + BTR_NO_LOCKING_FLAG and skip the locking altogether. */ + ut_ad(lock_table_has(trx, index->table, LOCK_IX)); - lock_mutex_exit(); + *inherit= lock_sys_t::get_first(g.cell(), id, heap_no); - switch (err) { - case DB_SUCCESS_LOCKED_REC: - err = DB_SUCCESS; - /* fall through */ - case DB_SUCCESS: - if (!inherit_in || dict_index_is_clust(index)) { - break; - } + if (*inherit) + { + /* Spatial index does not use GAP lock protection. It uses + "predicate lock" to protect the "range" */ + if (index->is_spatial()) + return DB_SUCCESS; + + /* If another transaction has an explicit lock request which locks + the gap, waiting or granted, on the successor, the insert has to wait. + + An exception is the case where the lock by the another transaction + is a gap type lock which it placed to wait for its turn to insert. We + do not consider that kind of a lock conflicting with our insert. This + eliminates an unnecessary deadlock which resulted when 2 transactions + had to wait for their insert. Both had waiting gap type lock requests + on the successor, which produced an unnecessary deadlock. */ + const unsigned type_mode= LOCK_X | LOCK_GAP | LOCK_INSERT_INTENTION; + + if (lock_t *c_lock= lock_rec_other_has_conflicting(type_mode, + g.cell(), id, + heap_no, trx)) + { + trx->mutex_lock(); + err= lock_rec_enqueue_waiting(c_lock, type_mode, id, block->page.frame, + heap_no, index, thr, nullptr); + trx->mutex_unlock(); + } + } + } - /* Update the page max trx id field */ - page_update_max_trx_id( - block, buf_block_get_page_zip(block), trx->id, mtr); - default: - /* We only care about the two return values. */ - break; - } + switch (err) { + case DB_SUCCESS_LOCKED_REC: + err = DB_SUCCESS; + /* fall through */ + case DB_SUCCESS: + if (!inherit_in || index->is_clust()) + break; + /* Update the page max trx id field */ + page_update_max_trx_id(block, buf_block_get_page_zip(block), trx->id, mtr); + default: + /* We only care about the two return values. */ + break; + } #ifdef UNIV_DEBUG - { - mem_heap_t* heap = NULL; - rec_offs offsets_[REC_OFFS_NORMAL_SIZE]; - const rec_offs* offsets; - rec_offs_init(offsets_); + { + mem_heap_t *heap= nullptr; + rec_offs offsets_[REC_OFFS_NORMAL_SIZE]; + const rec_offs *offsets; + rec_offs_init(offsets_); - offsets = rec_get_offsets(next_rec, index, offsets_, - index->n_core_fields, - ULINT_UNDEFINED, &heap); + offsets= rec_get_offsets(next_rec, index, offsets_, index->n_core_fields, + ULINT_UNDEFINED, &heap); - ut_ad(lock_rec_queue_validate( - FALSE, block, next_rec, index, offsets)); + ut_ad(lock_rec_queue_validate(false, id, next_rec, index, offsets)); - if (heap != NULL) { - mem_heap_free(heap); - } - } + if (UNIV_LIKELY_NULL(heap)) + mem_heap_free(heap); + } #endif /* UNIV_DEBUG */ - return(err); + return err; } /*********************************************************************//** @@ -5337,36 +5160,41 @@ has an implicit lock on the record. The transaction instance must have a reference count > 0 so that it can't be committed and freed before this function has completed. */ static -void +bool lock_rec_convert_impl_to_expl_for_trx( /*==================================*/ - const buf_block_t* block, /*!< in: buffer block of rec */ - const rec_t* rec, /*!< in: user record on page */ - dict_index_t* index, /*!< in: index of record */ trx_t* trx, /*!< in/out: active transaction */ - ulint heap_no)/*!< in: rec heap number to lock */ + const page_id_t id, /*!< in: page identifier */ + const rec_t* rec, /*!< in: user record on page */ + dict_index_t* index) /*!< in: index of record */ { - ut_ad(trx->is_referenced()); - ut_ad(page_rec_is_leaf(rec)); - ut_ad(!rec_is_metadata(rec, *index)); + if (!trx) + return false; - DEBUG_SYNC_C("before_lock_rec_convert_impl_to_expl_for_trx"); - lock_mutex_enter(); - trx_mutex_enter(trx); - ut_ad(!trx_state_eq(trx, TRX_STATE_NOT_STARTED)); + ut_ad(trx->is_referenced()); + ut_ad(page_rec_is_leaf(rec)); + ut_ad(!rec_is_metadata(rec, *index)); - if (!trx_state_eq(trx, TRX_STATE_COMMITTED_IN_MEMORY) - && !lock_rec_has_expl(LOCK_X | LOCK_REC_NOT_GAP, - block, heap_no, trx)) { - lock_rec_add_to_queue(LOCK_REC | LOCK_X | LOCK_REC_NOT_GAP, - block, heap_no, index, trx, true); - } + DEBUG_SYNC_C("before_lock_rec_convert_impl_to_expl_for_trx"); + ulint heap_no= page_rec_get_heap_no(rec); - lock_mutex_exit(); - trx_mutex_exit(trx); - trx->release_reference(); + { + LockGuard g{lock_sys.rec_hash, id}; + trx->mutex_lock(); + ut_ad(!trx_state_eq(trx, TRX_STATE_NOT_STARTED)); + + if (!trx_state_eq(trx, TRX_STATE_COMMITTED_IN_MEMORY) && + !lock_rec_has_expl(LOCK_X | LOCK_REC_NOT_GAP, g.cell(), id, heap_no, + trx)) + lock_rec_add_to_queue(LOCK_X | LOCK_REC_NOT_GAP, g.cell(), id, + page_align(rec), heap_no, index, trx, true); + } - DEBUG_SYNC_C("after_lock_rec_convert_impl_to_expl_for_trx"); + trx->mutex_unlock(); + trx->release_reference(); + + DEBUG_SYNC_C("after_lock_rec_convert_impl_to_expl_for_trx"); + return false; } @@ -5374,8 +5202,9 @@ lock_rec_convert_impl_to_expl_for_trx( struct lock_rec_other_trx_holds_expl_arg { const ulint heap_no; - const buf_block_t * const block; - const trx_t *impl_trx; + const hash_cell_t &cell; + const page_id_t id; + const trx_t &impl_trx; }; @@ -5383,22 +5212,23 @@ static my_bool lock_rec_other_trx_holds_expl_callback( rw_trx_hash_element_t *element, lock_rec_other_trx_holds_expl_arg *arg) { - mutex_enter(&element->mutex); + element->mutex.wr_lock(); if (element->trx) { - trx_mutex_enter(element->trx); + element->trx->mutex_lock(); ut_ad(element->trx->state != TRX_STATE_NOT_STARTED); 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, - arg->heap_no, element->trx); + ? nullptr + : lock_rec_has_expl(LOCK_S | LOCK_REC_NOT_GAP, + arg->cell, arg->id, arg->heap_no, element->trx); /* An explicit lock is held by trx other than the trx holding the implicit lock. */ - ut_ad(!expl_lock || expl_lock->trx == arg->impl_trx); - trx_mutex_exit(element->trx); + ut_ad(!expl_lock || expl_lock->trx == &arg->impl_trx); + element->trx->mutex_unlock(); } - mutex_exit(&element->mutex); + element->mutex.wr_unlock(); return 0; } @@ -5414,38 +5244,30 @@ static my_bool lock_rec_other_trx_holds_expl_callback( @param caller_trx trx of current thread @param[in] trx trx holding implicit lock on rec @param[in] rec user record - @param[in] block buffer block containing the record + @param[in] id page identifier */ - static void lock_rec_other_trx_holds_expl(trx_t *caller_trx, trx_t *trx, const rec_t *rec, - const buf_block_t *block) + const page_id_t id) { if (trx) { ut_ad(!page_rec_is_metadata(rec)); - lock_mutex_enter(); + LockGuard g{lock_sys.rec_hash, id}; ut_ad(trx->is_referenced()); - trx_mutex_enter(trx); - const trx_state_t state = trx->state; - trx_mutex_exit(trx); + const trx_state_t state{trx->state}; ut_ad(state != TRX_STATE_NOT_STARTED); if (state == TRX_STATE_COMMITTED_IN_MEMORY) - { - /* The transaction was committed before our lock_mutex_enter(). */ - lock_mutex_exit(); + /* The transaction was committed before we acquired LockGuard. */ return; - } - lock_rec_other_trx_holds_expl_arg arg= { page_rec_get_heap_no(rec), block, - trx }; + lock_rec_other_trx_holds_expl_arg arg= + { page_rec_get_heap_no(rec), g.cell(), id, *trx }; trx_sys.rw_trx_hash.iterate(caller_trx, lock_rec_other_trx_holds_expl_callback, &arg); - lock_mutex_exit(); } } #endif /* UNIV_DEBUG */ - /** If an implicit x-lock exists on a record, convert it to an explicit one. Often, this is called by a transaction that is about to enter a lock wait @@ -5457,31 +5279,34 @@ This may also be called by the same transaction that is already holding an implicit exclusive lock on the record. In this case, no explicit lock should be created. +@tparam is_primary whether the index is the primary key @param[in,out] caller_trx current transaction -@param[in] block index tree leaf page +@param[in] id index tree leaf page identifier @param[in] rec record on the leaf page @param[in] index the index of the record @param[in] offsets rec_get_offsets(rec,index) @return whether caller_trx already holds an exclusive lock on rec */ +template<bool is_primary> static bool lock_rec_convert_impl_to_expl( trx_t* caller_trx, - const buf_block_t* block, + page_id_t id, const rec_t* rec, dict_index_t* index, const rec_offs* offsets) { trx_t* trx; - ut_ad(!lock_mutex_own()); + lock_sys.assert_unlocked(); ut_ad(page_rec_is_user_rec(rec)); ut_ad(rec_offs_validate(rec, index, offsets)); ut_ad(!page_rec_is_comp(rec) == !rec_offs_comp(offsets)); ut_ad(page_rec_is_leaf(rec)); ut_ad(!rec_is_metadata(rec, *index)); + ut_ad(index->is_primary() == is_primary); - if (dict_index_is_clust(index)) { + if (is_primary) { trx_id_t trx_id; trx_id = lock_clust_rec_some_has_impl(rec, index, offsets); @@ -5504,24 +5329,10 @@ lock_rec_convert_impl_to_expl( return true; } - ut_d(lock_rec_other_trx_holds_expl(caller_trx, trx, rec, - block)); + ut_d(lock_rec_other_trx_holds_expl(caller_trx, trx, rec, id)); } - if (trx != 0) { - ulint heap_no = page_rec_get_heap_no(rec); - - ut_ad(trx->is_referenced()); - - /* If the transaction is still active and has no - explicit x-lock set on the record, set one for it. - trx cannot be committed until the ref count is zero. */ - - lock_rec_convert_impl_to_expl_for_trx( - block, rec, index, trx, heap_no); - } - - return false; + return lock_rec_convert_impl_to_expl_for_trx(trx, id, rec, index); } /*********************************************************************//** @@ -5535,8 +5346,6 @@ lock queue. dberr_t lock_clust_rec_modify_check_and_lock( /*=================================*/ - ulint flags, /*!< in: if BTR_NO_LOCKING_FLAG - bit is set, does nothing */ const buf_block_t* block, /*!< in: buffer block of rec */ const rec_t* rec, /*!< in: record which should be modified */ @@ -5550,12 +5359,8 @@ lock_clust_rec_modify_check_and_lock( ut_ad(rec_offs_validate(rec, index, offsets)); ut_ad(page_rec_is_leaf(rec)); ut_ad(dict_index_is_clust(index)); - ut_ad(block->frame == page_align(rec)); + ut_ad(block->page.frame == page_align(rec)); - if (flags & BTR_NO_LOCKING_FLAG) { - - return(DB_SUCCESS); - } ut_ad(!rec_is_metadata(rec, *index)); ut_ad(!index->table->is_temporary()); @@ -5566,16 +5371,18 @@ lock_clust_rec_modify_check_and_lock( /* If a transaction has no explicit x-lock set on the record, set one for it */ - if (lock_rec_convert_impl_to_expl(thr_get_trx(thr), block, rec, index, - offsets)) { + if (lock_rec_convert_impl_to_expl<true>(thr_get_trx(thr), + block->page.id(), + rec, index, offsets)) { /* We already hold an implicit exclusive lock. */ return DB_SUCCESS; } - err = lock_rec_lock(TRUE, LOCK_X | LOCK_REC_NOT_GAP, + err = lock_rec_lock(true, LOCK_X | LOCK_REC_NOT_GAP, block, heap_no, index, thr); - ut_ad(lock_rec_queue_validate(FALSE, block, rec, index, offsets)); + ut_ad(lock_rec_queue_validate(false, block->page.id(), + rec, index, offsets)); if (err == DB_SUCCESS_LOCKED_REC) { err = DB_SUCCESS; @@ -5609,7 +5416,7 @@ lock_sec_rec_modify_check_and_lock( ut_ad(!dict_index_is_clust(index)); ut_ad(!dict_index_is_online_ddl(index) || (flags & BTR_CREATE_FLAG)); - ut_ad(block->frame == page_align(rec)); + ut_ad(block->page.frame == page_align(rec)); ut_ad(mtr->is_named_space(index->table->space)); ut_ad(page_rec_is_leaf(rec)); ut_ad(!rec_is_metadata(rec, *index)); @@ -5632,7 +5439,7 @@ lock_sec_rec_modify_check_and_lock( high priority threads. To avoid this GAP-locking we mark that this transaction is using unique key scan here. */ if (trx->is_wsrep() && wsrep_thd_is_BF(trx->mysql_thd, false)) - trx->wsrep_UK_scan= true; + trx->wsrep = 3; #endif /* WITH_WSREP */ /* Another transaction cannot have an implicit lock on the record, @@ -5640,11 +5447,11 @@ lock_sec_rec_modify_check_and_lock( index record, and this would not have been possible if another active transaction had modified this secondary index record. */ - err = lock_rec_lock(TRUE, LOCK_X | LOCK_REC_NOT_GAP, + err = lock_rec_lock(true, LOCK_X | LOCK_REC_NOT_GAP, block, heap_no, index, thr); #ifdef WITH_WSREP - trx->wsrep_UK_scan= false; + if (trx->wsrep == 3) trx->wsrep = 1; #endif /* WITH_WSREP */ #ifdef UNIV_DEBUG @@ -5659,7 +5466,7 @@ lock_sec_rec_modify_check_and_lock( ULINT_UNDEFINED, &heap); ut_ad(lock_rec_queue_validate( - FALSE, block, rec, index, offsets)); + false, block->page.id(), rec, index, offsets)); if (heap != NULL) { mem_heap_free(heap); @@ -5707,11 +5514,10 @@ lock_sec_rec_read_check_and_lock( que_thr_t* thr) /*!< in: query thread */ { dberr_t err; - ulint heap_no; ut_ad(!dict_index_is_clust(index)); ut_ad(!dict_index_is_online_ddl(index)); - ut_ad(block->frame == page_align(rec)); + ut_ad(block->page.frame == page_align(rec)); ut_ad(page_rec_is_user_rec(rec) || page_rec_is_supremum(rec)); ut_ad(rec_offs_validate(rec, index, offsets)); ut_ad(page_rec_is_leaf(rec)); @@ -5725,18 +5531,16 @@ lock_sec_rec_read_check_and_lock( } ut_ad(!rec_is_metadata(rec, *index)); - heap_no = page_rec_get_heap_no(rec); - - /* Some transaction may have an implicit x-lock on the record only - if the max trx id for the page >= min trx id for the trx list or a - database recovery is running. */ trx_t *trx = thr_get_trx(thr); - if (!lock_table_has(trx, index->table, LOCK_X) - && !page_rec_is_supremum(rec) - && page_get_max_trx_id(block->frame) >= trx_sys.get_min_trx_id() - && lock_rec_convert_impl_to_expl(thr_get_trx(thr), block, rec, - index, offsets) + + if (lock_table_has(trx, index->table, mode)) { + return DB_SUCCESS; + } + + if (!page_rec_is_supremum(rec) + && lock_rec_convert_impl_to_expl<false>( + trx, block->page.id(), rec, index, offsets) && gap_mode == LOCK_REC_NOT_GAP) { /* We already hold an implicit exclusive lock. */ return DB_SUCCESS; @@ -5751,17 +5555,18 @@ lock_sec_rec_read_check_and_lock( high priority threads. To avoid this GAP-locking we mark that this transaction is using unique key scan here. */ if (trx->is_wsrep() && wsrep_thd_is_BF(trx->mysql_thd, false)) - trx->wsrep_UK_scan= true; + trx->wsrep = 3; #endif /* WITH_WSREP */ - err = lock_rec_lock(FALSE, gap_mode | mode, - block, heap_no, index, thr); + err = lock_rec_lock(false, gap_mode | mode, + block, page_rec_get_heap_no(rec), index, thr); #ifdef WITH_WSREP - trx->wsrep_UK_scan= false; + if (trx->wsrep == 3) trx->wsrep = 1; #endif /* WITH_WSREP */ - ut_ad(lock_rec_queue_validate(FALSE, block, rec, index, offsets)); + ut_ad(lock_rec_queue_validate(false, block->page.id(), + rec, index, offsets)); return(err); } @@ -5795,11 +5600,8 @@ lock_clust_rec_read_check_and_lock( LOCK_REC_NOT_GAP */ que_thr_t* thr) /*!< in: query thread */ { - dberr_t err; - ulint heap_no; - ut_ad(dict_index_is_clust(index)); - ut_ad(block->frame == page_align(rec)); + ut_ad(block->page.frame == page_align(rec)); ut_ad(page_rec_is_user_rec(rec) || page_rec_is_supremum(rec)); ut_ad(gap_mode == LOCK_ORDINARY || gap_mode == LOCK_GAP || gap_mode == LOCK_REC_NOT_GAP); @@ -5814,22 +5616,24 @@ lock_clust_rec_read_check_and_lock( return(DB_SUCCESS); } - heap_no = page_rec_get_heap_no(rec); + const page_id_t id{block->page.id()}; + + ulint heap_no = page_rec_get_heap_no(rec); trx_t *trx = thr_get_trx(thr); if (!lock_table_has(trx, index->table, LOCK_X) && heap_no != PAGE_HEAP_NO_SUPREMUM - && lock_rec_convert_impl_to_expl(trx, block, rec, - index, offsets) + && lock_rec_convert_impl_to_expl<true>(trx, id, + rec, index, offsets) && gap_mode == LOCK_REC_NOT_GAP) { /* We already hold an implicit exclusive lock. */ return DB_SUCCESS; } - err = lock_rec_lock(FALSE, gap_mode | mode, - block, heap_no, index, thr); + dberr_t err = lock_rec_lock(false, gap_mode | mode, + block, heap_no, index, thr); - ut_ad(lock_rec_queue_validate(FALSE, block, rec, index, offsets)); + ut_ad(lock_rec_queue_validate(false, id, rec, index, offsets)); DEBUG_SYNC_C("after_lock_clust_rec_read_check_and_lock"); @@ -5888,37 +5692,6 @@ lock_clust_rec_read_check_and_lock_alt( } /*******************************************************************//** -Release the last lock from the transaction's autoinc locks. */ -UNIV_INLINE -void -lock_release_autoinc_last_lock( -/*===========================*/ - ib_vector_t* autoinc_locks) /*!< in/out: vector of AUTOINC locks */ -{ - ulint last; - lock_t* lock; - - ut_ad(lock_mutex_own()); - ut_a(!ib_vector_is_empty(autoinc_locks)); - - /* The lock to be release must be the last lock acquired. */ - last = ib_vector_size(autoinc_locks) - 1; - lock = *static_cast<lock_t**>(ib_vector_get(autoinc_locks, last)); - - /* Should have only AUTOINC locks in the vector. */ - ut_a(lock_get_mode(lock) == LOCK_AUTO_INC); - ut_a(lock_get_type(lock) == LOCK_TABLE); - - ut_a(lock->un_member.tab_lock.table != NULL); - - /* This will remove the lock from the trx autoinc_locks too. */ - lock_table_dequeue(lock); - - /* Remove from the table vector too. */ - lock_trx_table_locks_remove(lock); -} - -/*******************************************************************//** Check if a transaction holds any autoinc locks. @return TRUE if the transaction holds any AUTOINC locks. */ static @@ -5932,179 +5705,233 @@ lock_trx_holds_autoinc_locks( return(!ib_vector_is_empty(trx->autoinc_locks)); } -/*******************************************************************//** -Release all the transaction's autoinc locks. */ -static -void -lock_release_autoinc_locks( -/*=======================*/ - trx_t* trx) /*!< in/out: transaction */ -{ - ut_ad(lock_mutex_own()); - /* If this is invoked for a running transaction by the thread - that is serving the transaction, then it is not necessary to - hold trx->mutex here. */ - - ut_a(trx->autoinc_locks != NULL); - - /* We release the locks in the reverse order. This is to - avoid searching the vector for the element to delete at - the lower level. See (lock_table_remove_low()) for details. */ - while (!ib_vector_is_empty(trx->autoinc_locks)) { - - /* lock_table_remove_low() will also remove the lock from - the transaction's autoinc_locks vector. */ - lock_release_autoinc_last_lock(trx->autoinc_locks); - } - - /* Should release all locks. */ - ut_a(ib_vector_is_empty(trx->autoinc_locks)); -} - -/*******************************************************************//** -Gets the type of a lock. Non-inline version for using outside of the -lock module. -@return LOCK_TABLE or LOCK_REC */ -ulint -lock_get_type( -/*==========*/ - const lock_t* lock) /*!< in: lock */ +/** Release all AUTO_INCREMENT locks of the transaction. */ +static void lock_release_autoinc_locks(trx_t *trx) { - return(lock_get_type_low(lock)); + { + LockMutexGuard g{SRW_LOCK_CALL}; + mysql_mutex_lock(&lock_sys.wait_mutex); + trx->mutex_lock(); + auto autoinc_locks= trx->autoinc_locks; + ut_a(autoinc_locks); + + /* We release the locks in the reverse order. This is to avoid + searching the vector for the element to delete at the lower level. + See (lock_table_remove_low()) for details. */ + while (ulint size= ib_vector_size(autoinc_locks)) + { + lock_t *lock= *static_cast<lock_t**> + (ib_vector_get(autoinc_locks, size - 1)); + ut_ad(lock->type_mode == (LOCK_AUTO_INC | LOCK_TABLE)); + lock_table_dequeue(lock, true); + lock_trx_table_locks_remove(lock); + } + } + mysql_mutex_unlock(&lock_sys.wait_mutex); + trx->mutex_unlock(); } -/*******************************************************************//** -Gets the id of the transaction owning a lock. -@return transaction id */ -trx_id_t -lock_get_trx_id( -/*============*/ - const lock_t* lock) /*!< in: lock */ +/** Cancel a waiting lock request and release possibly waiting transactions */ +template <bool from_deadlock= false> +void lock_cancel_waiting_and_release(lock_t *lock) { - return(trx_get_id_for_print(lock->trx)); -} - -/*******************************************************************//** -Gets the table on which the lock is. -@return table */ -UNIV_INLINE -dict_table_t* -lock_get_table( -/*===========*/ - const lock_t* lock) /*!< in: lock */ -{ - switch (lock_get_type_low(lock)) { - case LOCK_REC: - ut_ad(dict_index_is_clust(lock->index) - || !dict_index_is_online_ddl(lock->index)); - return(lock->index->table); - case LOCK_TABLE: - return(lock->un_member.tab_lock.table); - default: - ut_error; - return(NULL); - } -} + lock_sys.assert_locked(*lock); + mysql_mutex_assert_owner(&lock_sys.wait_mutex); + trx_t *trx= lock->trx; + trx->mutex_lock(); + ut_d(const auto trx_state= trx->state); + ut_ad(trx_state == TRX_STATE_COMMITTED_IN_MEMORY || + trx_state == TRX_STATE_ACTIVE); -/*******************************************************************//** -Gets the id of the table on which the lock is. -@return id of the table */ -table_id_t -lock_get_table_id( -/*==============*/ - const lock_t* lock) /*!< in: lock */ -{ - dict_table_t* table = lock_get_table(lock); - ut_ad(!table->is_temporary()); - return(table->id); -} + if (!lock->is_table()) + lock_rec_dequeue_from_page(lock, true); + else + { + if (lock->type_mode == (LOCK_AUTO_INC | LOCK_TABLE)) + { + ut_ad(trx->autoinc_locks); + ib_vector_remove(trx->autoinc_locks, lock); + } + lock_table_dequeue(lock, true); + /* Remove the lock from table lock vector too. */ + lock_trx_table_locks_remove(lock); + } -/** Determine which table a lock is associated with. -@param[in] lock the lock -@return name of the table */ -const table_name_t& -lock_get_table_name( - const lock_t* lock) -{ - return(lock_get_table(lock)->name); -} + /* Reset the wait flag and the back pointer to lock in trx. */ + lock_reset_lock_and_trx_wait(lock); -/*******************************************************************//** -For a record lock, gets the index on which the lock is. -@return index */ -const dict_index_t* -lock_rec_get_index( -/*===============*/ - const lock_t* lock) /*!< in: lock */ -{ - ut_a(lock_get_type_low(lock) == LOCK_REC); - ut_ad(dict_index_is_clust(lock->index) - || !dict_index_is_online_ddl(lock->index)); + lock_wait_end<from_deadlock>(trx); - return(lock->index); + trx->mutex_unlock(); } -/*******************************************************************//** -For a record lock, gets the name of the index on which the lock is. -The string should not be free()'d or modified. -@return name of the index */ -const char* -lock_rec_get_index_name( -/*====================*/ - const lock_t* lock) /*!< in: lock */ +void lock_sys_t::cancel_lock_wait_for_trx(trx_t *trx) { - ut_a(lock_get_type_low(lock) == LOCK_REC); - ut_ad(dict_index_is_clust(lock->index) - || !dict_index_is_online_ddl(lock->index)); + lock_sys.wr_lock(SRW_LOCK_CALL); + mysql_mutex_lock(&lock_sys.wait_mutex); + if (lock_t *lock= trx->lock.wait_lock) + { + /* check if victim is still waiting */ + if (lock->is_waiting()) + lock_cancel_waiting_and_release(lock); + } + lock_sys.wr_unlock(); + mysql_mutex_unlock(&lock_sys.wait_mutex); +} + +/** Cancel a waiting lock request. +@tparam check_victim whether to check for DB_DEADLOCK +@param trx active transaction +@param lock waiting lock request +@retval DB_SUCCESS if no lock existed +@retval DB_DEADLOCK if trx->lock.was_chosen_as_deadlock_victim was set +@retval DB_LOCK_WAIT if the lock was canceled */ +template<bool check_victim> +dberr_t lock_sys_t::cancel(trx_t *trx, lock_t *lock) +{ + DEBUG_SYNC_C("lock_sys_t_cancel_enter"); + mysql_mutex_assert_owner(&lock_sys.wait_mutex); + ut_ad(trx->state == TRX_STATE_ACTIVE); + /* trx->lock.wait_lock may be changed by other threads as long as + we are not holding lock_sys.latch. + + So, trx->lock.wait_lock==lock does not necessarily hold, but both + pointers should be valid, because other threads cannot assign + trx->lock.wait_lock=nullptr (or invalidate *lock) while we are + holding lock_sys.wait_mutex. Also, the type of trx->lock.wait_lock + (record or table lock) cannot be changed by other threads. So, it is + safe to call lock->is_table() while not holding lock_sys.latch. If + we have to release and reacquire lock_sys.wait_mutex, we must reread + trx->lock.wait_lock. We must also reread trx->lock.wait_lock after + lock_sys.latch acquiring, as it can be changed to not-null in lock moving + functions even if we hold lock_sys.wait_mutex. */ + dberr_t err= DB_SUCCESS; + /* This would be too large for a memory transaction, except in the + DB_DEADLOCK case, which was already tested in lock_trx_handle_wait(). */ + if (lock->is_table()) + { + if (!lock_sys.rd_lock_try()) + { + mysql_mutex_unlock(&lock_sys.wait_mutex); + lock_sys.rd_lock(SRW_LOCK_CALL); + mysql_mutex_lock(&lock_sys.wait_mutex); + lock= trx->lock.wait_lock; + /* Even if waiting lock was cancelled while lock_sys.wait_mutex was + unlocked, we need to return deadlock error if transaction was chosen + as deadlock victim to rollback it */ + if (check_victim && trx->lock.was_chosen_as_deadlock_victim) + err= DB_DEADLOCK; + else if (lock) + goto resolve_table_lock; + } + else + { + /* This function is invoked from the thread which executes the + transaction. Table locks are requested before record locks. Some other + transaction can't change trx->lock.wait_lock from table to record for the + current transaction at this point, because the current transaction has not + requested record locks yet. There is no need to move any table locks by + other threads. And trx->lock.wait_lock can't be set to null while we are + holding lock_sys.wait_mutex. That's why there is no need to reload + trx->lock.wait_lock here. */ + ut_ad(lock == trx->lock.wait_lock); +resolve_table_lock: + dict_table_t *table= lock->un_member.tab_lock.table; + if (!table->lock_mutex_trylock()) + { + /* The correct latching order is: + lock_sys.latch, table->lock_mutex_lock(), lock_sys.wait_mutex. + Thus, we must release lock_sys.wait_mutex for a blocking wait. */ + mysql_mutex_unlock(&lock_sys.wait_mutex); + table->lock_mutex_lock(); + mysql_mutex_lock(&lock_sys.wait_mutex); + /* Cache trx->lock.wait_lock under the corresponding latches. */ + lock= trx->lock.wait_lock; + if (!lock) + goto retreat; + else if (check_victim && trx->lock.was_chosen_as_deadlock_victim) + { + err= DB_DEADLOCK; + goto retreat; + } + } + else + /* Cache trx->lock.wait_lock under the corresponding latches if + it was not cached yet */ + lock= trx->lock.wait_lock; + if (lock->is_waiting()) + lock_cancel_waiting_and_release(lock); + /* Even if lock->is_waiting() did not hold above, we must return + DB_LOCK_WAIT, or otherwise optimistic parallel replication could + occasionally hang. Potentially affected tests: + rpl.rpl_parallel_optimistic + rpl.rpl_parallel_optimistic_nobinlog + rpl.rpl_parallel_optimistic_xa_lsu_off */ + err= DB_LOCK_WAIT; +retreat: + table->lock_mutex_unlock(); + } + lock_sys.rd_unlock(); + } + else + { + /* To prevent the record lock from being moved between pages + during a page split or merge, we must hold exclusive lock_sys.latch. */ + if (!lock_sys.wr_lock_try()) + { + mysql_mutex_unlock(&lock_sys.wait_mutex); + lock_sys.wr_lock(SRW_LOCK_CALL); + mysql_mutex_lock(&lock_sys.wait_mutex); + /* Cache trx->lock.wait_lock under the corresponding latches. */ + lock= trx->lock.wait_lock; + /* Even if waiting lock was cancelled while lock_sys.wait_mutex was + unlocked, we need to return deadlock error if transaction was chosen + as deadlock victim to rollback it */ + if (check_victim && trx->lock.was_chosen_as_deadlock_victim) + err= DB_DEADLOCK; + else if (lock) + goto resolve_record_lock; + } + else + { + /* Cache trx->lock.wait_lock under the corresponding latches if + it was not cached yet */ + lock= trx->lock.wait_lock; +resolve_record_lock: + if (lock->is_waiting()) + lock_cancel_waiting_and_release(lock); + /* Even if lock->is_waiting() did not hold above, we must return + DB_LOCK_WAIT, or otherwise optimistic parallel replication could + occasionally hang. Potentially affected tests: + rpl.rpl_parallel_optimistic + rpl.rpl_parallel_optimistic_nobinlog + rpl.rpl_parallel_optimistic_xa_lsu_off */ + err= DB_LOCK_WAIT; + } + lock_sys.wr_unlock(); + } - return(lock->index->name); + return err; } -/*********************************************************************//** -Cancels a waiting lock request and releases possible other transactions -waiting behind it. */ -void -lock_cancel_waiting_and_release( -/*============================*/ - lock_t* lock) /*!< in/out: waiting lock request */ +/** Cancel a waiting lock request (if any) when killing a transaction */ +void lock_sys_t::cancel(trx_t *trx) { - que_thr_t* thr; - - ut_ad(lock_mutex_own()); - ut_ad(trx_mutex_own(lock->trx)); - ut_ad(lock->trx->state == TRX_STATE_ACTIVE); - - lock->trx->lock.cancel = true; - - if (lock_get_type_low(lock) == LOCK_REC) { - - lock_rec_dequeue_from_page(lock); - } else { - ut_ad(lock_get_type_low(lock) & LOCK_TABLE); - - if (lock->trx->autoinc_locks != NULL) { - /* Release the transaction's AUTOINC locks. */ - lock_release_autoinc_locks(lock->trx); - } - - lock_table_dequeue(lock); - /* Remove the lock from table lock vector too. */ - lock_trx_table_locks_remove(lock); - } - - /* Reset the wait flag and the back pointer to lock in trx. */ - - lock_reset_lock_and_trx_wait(lock); - - /* The following function releases the trx from lock wait. */ - - thr = que_thr_end_lock_wait(lock->trx); - - if (thr != NULL) { - lock_wait_release_thread_if_suspended(thr); - } - - lock->trx->lock.cancel = false; + mysql_mutex_lock(&lock_sys.wait_mutex); + /* Cache trx->lock.wait_lock to avoid unnecessary atomic variable load */ + if (lock_t *lock= trx->lock.wait_lock) + { + /* Dictionary transactions must be immune to KILL, because they + may be executed as part of a multi-transaction DDL operation, such + as rollback_inplace_alter_table() or ha_innobase::delete_table(). */ + if (!trx->dict_operation) + { + trx->error_state= DB_INTERRUPTED; + cancel<false>(trx, lock); + } + } + lock_sys.deadlock_check(); + mysql_mutex_unlock(&lock_sys.wait_mutex); } /*********************************************************************//** @@ -6116,8 +5943,8 @@ lock_unlock_table_autoinc( /*======================*/ trx_t* trx) /*!< in/out: transaction */ { - ut_ad(!lock_mutex_own()); - ut_ad(!trx_mutex_own(trx)); + lock_sys.assert_unlocked(); + ut_ad(!trx->mutex_is_owner()); ut_ad(!trx->lock.wait_lock); /* This can be invoked on NOT_STARTED, ACTIVE, PREPARED, @@ -6131,72 +5958,40 @@ lock_unlock_table_autoinc( necessary to hold trx->mutex here. */ if (lock_trx_holds_autoinc_locks(trx)) { - lock_mutex_enter(); - lock_release_autoinc_locks(trx); - - lock_mutex_exit(); } } -static inline dberr_t lock_trx_handle_wait_low(trx_t* trx) -{ - ut_ad(lock_mutex_own()); - ut_ad(trx_mutex_own(trx)); +/** Handle a pending lock wait (DB_LOCK_WAIT) in a semi-consistent read +while holding a clustered index leaf page latch. - if (trx->lock.was_chosen_as_deadlock_victim) { - return DB_DEADLOCK; - } - if (!trx->lock.wait_lock) { - /* The lock was probably granted before we got here. */ - return DB_SUCCESS; - } - - lock_cancel_waiting_and_release(trx->lock.wait_lock); - return DB_LOCK_WAIT; -} - -/*********************************************************************//** -Check whether the transaction has already been rolled back because it -was selected as a deadlock victim, or if it has to wait then cancel -the wait lock. -@return DB_DEADLOCK, DB_LOCK_WAIT or DB_SUCCESS */ -dberr_t -lock_trx_handle_wait( -/*=================*/ - trx_t* trx) /*!< in/out: trx lock state */ -{ -#ifdef WITH_WSREP - /* We already own mutexes */ - if (trx->lock.was_chosen_as_wsrep_victim) { - return lock_trx_handle_wait_low(trx); - } -#endif /* WITH_WSREP */ - lock_mutex_enter(); - trx_mutex_enter(trx); - dberr_t err = lock_trx_handle_wait_low(trx); - lock_mutex_exit(); - trx_mutex_exit(trx); - return err; -} - -/*********************************************************************//** -Get the number of locks on a table. -@return number of locks */ -ulint -lock_table_get_n_locks( -/*===================*/ - const dict_table_t* table) /*!< in: table */ +@param trx transaction that is or was waiting for a lock +@retval DB_SUCCESS if the lock was granted +@retval DB_DEADLOCK if the transaction must be aborted due to a deadlock +@retval DB_LOCK_WAIT if a lock wait would be necessary; the pending + lock request was released */ +dberr_t lock_trx_handle_wait(trx_t *trx) { - ulint n_table_locks; - - lock_mutex_enter(); - - n_table_locks = UT_LIST_GET_LEN(table->locks); - - lock_mutex_exit(); - - return(n_table_locks); + DEBUG_SYNC_C("lock_trx_handle_wait_enter"); + if (trx->lock.was_chosen_as_deadlock_victim) + return DB_DEADLOCK; + DEBUG_SYNC_C("lock_trx_handle_wait_before_unlocked_wait_lock_check"); + /* trx->lock.was_chosen_as_deadlock_victim must always be set before + trx->lock.wait_lock if the transaction was chosen as deadlock victim, + the function must not return DB_SUCCESS if + trx->lock.was_chosen_as_deadlock_victim is set. */ + if (!trx->lock.wait_lock) + return trx->lock.was_chosen_as_deadlock_victim ? DB_DEADLOCK : DB_SUCCESS; + dberr_t err= DB_SUCCESS; + mysql_mutex_lock(&lock_sys.wait_mutex); + if (trx->lock.was_chosen_as_deadlock_victim) + err= DB_DEADLOCK; + /* Cache trx->lock.wait_lock to avoid unnecessary atomic variable load */ + else if (lock_t *wait_lock= trx->lock.wait_lock) + err= lock_sys_t::cancel<true>(trx, wait_lock); + lock_sys.deadlock_check(); + mysql_mutex_unlock(&lock_sys.wait_mutex); + return err; } #ifdef UNIV_DEBUG @@ -6210,11 +6005,11 @@ lock_table_get_n_locks( static my_bool lock_table_locks_lookup(rw_trx_hash_element_t *element, const dict_table_t *table) { - ut_ad(lock_mutex_own()); - mutex_enter(&element->mutex); + lock_sys.assert_locked(); + element->mutex.wr_lock(); if (element->trx) { - trx_mutex_enter(element->trx); + element->trx->mutex_lock(); check_trx_state(element->trx); if (element->trx->state != TRX_STATE_COMMITTED_IN_MEMORY) { @@ -6223,7 +6018,7 @@ static my_bool lock_table_locks_lookup(rw_trx_hash_element_t *element, lock= UT_LIST_GET_NEXT(trx_locks, lock)) { ut_ad(lock->trx == element->trx); - if (lock_get_type_low(lock) == LOCK_REC) + if (!lock->is_table()) { ut_ad(lock->index->online_status != ONLINE_INDEX_CREATION || lock->index->is_primary()); @@ -6233,39 +6028,46 @@ static my_bool lock_table_locks_lookup(rw_trx_hash_element_t *element, ut_ad(lock->un_member.tab_lock.table != table); } } - trx_mutex_exit(element->trx); + element->trx->mutex_unlock(); } - mutex_exit(&element->mutex); + element->mutex.wr_unlock(); return 0; } #endif /* UNIV_DEBUG */ -/*******************************************************************//** -Check if there are any locks (table or rec) against table. +/** Check if there are any locks on a table. @return true if table has either table or record locks. */ -bool -lock_table_has_locks( -/*=================*/ - const dict_table_t* table) /*!< in: check if there are any locks - held on records in this table or on the - table itself */ -{ - ibool has_locks; - - ut_ad(table != NULL); - lock_mutex_enter(); - - has_locks = UT_LIST_GET_LEN(table->locks) > 0 || table->n_rec_locks > 0; - +TRANSACTIONAL_TARGET +bool lock_table_has_locks(dict_table_t *table) +{ + if (table->n_rec_locks) + return true; + ulint len; +#if !defined NO_ELISION && !defined SUX_LOCK_GENERIC + if (xbegin()) + { + if (table->lock_mutex_is_locked()) + xabort(); + len= UT_LIST_GET_LEN(table->locks); + xend(); + } + else +#endif + { + table->lock_mutex_lock(); + len= UT_LIST_GET_LEN(table->locks); + table->lock_mutex_unlock(); + } + if (len) + return true; #ifdef UNIV_DEBUG - if (!has_locks) { - trx_sys.rw_trx_hash.iterate(lock_table_locks_lookup, table); - } + { + LockMutexGuard g{SRW_LOCK_CALL}; + trx_sys.rw_trx_hash.iterate(lock_table_locks_lookup, + const_cast<const dict_table_t*>(table)); + } #endif /* UNIV_DEBUG */ - - lock_mutex_exit(); - - return(has_locks); + return false; } /*******************************************************************//** @@ -6278,17 +6080,6 @@ lock_table_lock_list_init( UT_LIST_INIT(*lock_list, &lock_table_t::locks); } -/*******************************************************************//** -Initialise the trx lock list. */ -void -lock_trx_lock_list_init( -/*====================*/ - trx_lock_list_t* lock_list) /*!< List to initialise */ -{ - UT_LIST_INIT(*lock_list, &lock_t::trx_locks); -} - - #ifdef UNIV_DEBUG /*******************************************************************//** Check if the transaction holds any locks on the sys tables @@ -6302,7 +6093,7 @@ lock_trx_has_sys_table_locks( const lock_t* strongest_lock = 0; lock_mode strongest = LOCK_NONE; - lock_mutex_enter(); + LockMutexGuard g{SRW_LOCK_CALL}; const lock_list::const_iterator end = trx->lock.table_locks.end(); lock_list::const_iterator it = trx->lock.table_locks.begin(); @@ -6315,7 +6106,7 @@ lock_trx_has_sys_table_locks( if (lock != NULL && dict_is_sys_table(lock->un_member.tab_lock.table->id)) { - strongest = lock_get_mode(lock); + strongest = lock->mode(); ut_ad(strongest != LOCK_NONE); strongest_lock = lock; break; @@ -6323,7 +6114,6 @@ lock_trx_has_sys_table_locks( } if (strongest == LOCK_NONE) { - lock_mutex_exit(); return(NULL); } @@ -6335,10 +6125,10 @@ lock_trx_has_sys_table_locks( } ut_ad(trx == lock->trx); - ut_ad(lock_get_type_low(lock) & LOCK_TABLE); - ut_ad(lock->un_member.tab_lock.table != NULL); + ut_ad(lock->is_table()); + ut_ad(lock->un_member.tab_lock.table); - lock_mode mode = lock_get_mode(lock); + lock_mode mode = lock->mode(); if (dict_is_sys_table(lock->un_member.tab_lock.table->id) && lock_mode_stronger_or_eq(mode, strongest)) { @@ -6348,567 +6138,392 @@ lock_trx_has_sys_table_locks( } } - lock_mutex_exit(); - return(strongest_lock); } /** Check if the transaction holds an explicit exclusive lock on a record. @param[in] trx transaction @param[in] table table -@param[in] block leaf page +@param[in] id leaf page identifier @param[in] heap_no heap number identifying the record @return whether an explicit X-lock is held */ -bool -lock_trx_has_expl_x_lock( - const trx_t* trx, /*!< in: transaction to check */ - const dict_table_t* table, /*!< in: table to check */ - const buf_block_t* block, /*!< in: buffer block of the record */ - ulint heap_no)/*!< in: record heap number */ -{ - ut_ad(heap_no > PAGE_HEAP_NO_SUPREMUM); - - lock_mutex_enter(); - ut_ad(lock_table_has(trx, table, LOCK_IX)); - ut_ad(lock_table_has(trx, table, LOCK_X) - || lock_rec_has_expl(LOCK_X | LOCK_REC_NOT_GAP, block, heap_no, - trx)); - lock_mutex_exit(); - return(true); -} -#endif /* UNIV_DEBUG */ - -/** rewind(3) the file used for storing the latest detected deadlock and -print a heading message to stderr if printing of all deadlocks to stderr -is enabled. */ -void -DeadlockChecker::start_print() -{ - ut_ad(lock_mutex_own()); - - rewind(lock_latest_err_file); - ut_print_timestamp(lock_latest_err_file); - - if (srv_print_all_deadlocks) { - ib::info() << "Transactions deadlock detected, dumping" - " detailed information."; - } -} - -/** Print a message to the deadlock file and possibly to stderr. -@param msg message to print */ -void -DeadlockChecker::print(const char* msg) -{ - fputs(msg, lock_latest_err_file); - - if (srv_print_all_deadlocks) { - ib::info() << msg; - } -} - -/** Print transaction data to the deadlock file and possibly to stderr. -@param trx transaction -@param max_query_len max query length to print */ -void -DeadlockChecker::print(const trx_t* trx, ulint max_query_len) -{ - ut_ad(lock_mutex_own()); - - ulint n_rec_locks = lock_number_of_rows_locked(&trx->lock); - ulint n_trx_locks = UT_LIST_GET_LEN(trx->lock.trx_locks); - ulint heap_size = mem_heap_get_size(trx->lock.lock_heap); - - trx_print_low(lock_latest_err_file, trx, max_query_len, - n_rec_locks, n_trx_locks, heap_size); - - if (srv_print_all_deadlocks) { - trx_print_low(stderr, trx, max_query_len, - n_rec_locks, n_trx_locks, heap_size); - } -} - -/** Print lock data to the deadlock file and possibly to stderr. -@param lock record or table type lock */ -void -DeadlockChecker::print(const lock_t* lock) -{ - ut_ad(lock_mutex_own()); - - if (lock_get_type_low(lock) == LOCK_REC) { - mtr_t mtr; - lock_rec_print(lock_latest_err_file, lock, mtr); - - if (srv_print_all_deadlocks) { - lock_rec_print(stderr, lock, mtr); - } - } else { - lock_table_print(lock_latest_err_file, lock); - - if (srv_print_all_deadlocks) { - lock_table_print(stderr, lock); - } - } -} - -/** Get the next lock in the queue that is owned by a transaction whose -sub-tree has not already been searched. -Note: "next" here means PREV for table locks. - -@param lock Lock in queue -@param heap_no heap_no if lock is a record lock else ULINT_UNDEFINED - -@return next lock or NULL if at end of queue */ -const lock_t* -DeadlockChecker::get_next_lock(const lock_t* lock, ulint heap_no) const +bool lock_trx_has_expl_x_lock(const trx_t &trx, const dict_table_t &table, + page_id_t id, ulint heap_no) { - ut_ad(lock_mutex_own()); - - do { - if (lock_get_type_low(lock) == LOCK_REC) { - ut_ad(heap_no != ULINT_UNDEFINED); - lock = lock_rec_get_next_const(heap_no, lock); - } else { - ut_ad(heap_no == ULINT_UNDEFINED); - ut_ad(lock_get_type_low(lock) == LOCK_TABLE); - - lock = UT_LIST_GET_NEXT( - un_member.tab_lock.locks, lock); - } - - } while (lock != NULL && is_visited(lock)); - - ut_ad(lock == NULL - || lock_get_type_low(lock) == lock_get_type_low(m_wait_lock)); - - return(lock); -} - -/** Get the first lock to search. The search starts from the current -wait_lock. What we are really interested in is an edge from the -current wait_lock's owning transaction to another transaction that has -a lock ahead in the queue. We skip locks where the owning transaction's -sub-tree has already been searched. - -Note: The record locks are traversed from the oldest lock to the -latest. For table locks we go from latest to oldest. - -For record locks, we first position the "iterator" on the first lock on -the page and then reposition on the actual heap_no. This is required -due to the way the record lock has is implemented. - -@param[out] heap_no if rec lock, else ULINT_UNDEFINED. -@return first lock or NULL */ -const lock_t* -DeadlockChecker::get_first_lock(ulint* heap_no) const -{ - ut_ad(lock_mutex_own()); - - const lock_t* lock = m_wait_lock; - - if (lock_get_type_low(lock) == LOCK_REC) { - /* We are only interested in records that match the heap_no. */ - *heap_no = lock_rec_find_set_bit(lock); - - ut_ad(*heap_no <= 0xffff); - ut_ad(*heap_no != ULINT_UNDEFINED); - - /* Find the locks on the page. */ - lock = lock_sys.get_first( - lock->type_mode & LOCK_PREDICATE - ? lock_sys.prdt_hash - : lock_sys.rec_hash, - lock->un_member.rec_lock.page_id); - - /* Position on the first lock on the physical record.*/ - if (!lock_rec_get_nth_bit(lock, *heap_no)) { - lock = lock_rec_get_next_const(*heap_no, lock); - } - - ut_a(!lock_get_wait(lock)); - } else { - /* Table locks don't care about the heap_no. */ - *heap_no = ULINT_UNDEFINED; - ut_ad(lock_get_type_low(lock) == LOCK_TABLE); - dict_table_t* table = lock->un_member.tab_lock.table; - lock = UT_LIST_GET_FIRST(table->locks); - } - - /* Must find at least two locks, otherwise there cannot be a - waiting lock, secondly the first lock cannot be the wait_lock. */ - ut_a(lock != NULL); - ut_a(lock != m_wait_lock || - (innodb_lock_schedule_algorithm - == INNODB_LOCK_SCHEDULE_ALGORITHM_VATS - && !thd_is_replication_slave_thread(lock->trx->mysql_thd))); - - /* Check that the lock type doesn't change. */ - ut_ad(lock_get_type_low(lock) == lock_get_type_low(m_wait_lock)); - - return(lock); + ut_ad(heap_no > PAGE_HEAP_NO_SUPREMUM); + ut_ad(lock_table_has(&trx, &table, LOCK_IX)); + if (!lock_table_has(&trx, &table, LOCK_X)) + { + LockGuard g{lock_sys.rec_hash, id}; + ut_ad(lock_rec_has_expl(LOCK_X | LOCK_REC_NOT_GAP, + g.cell(), id, heap_no, &trx)); + } + return true; } +#endif /* UNIV_DEBUG */ -/** Notify that a deadlock has been detected and print the conflicting -transaction info. -@param lock lock causing deadlock */ -void -DeadlockChecker::notify(const lock_t* lock) const +namespace Deadlock { - ut_ad(lock_mutex_own()); - - start_print(); - - print("\n*** (1) TRANSACTION:\n"); - - print(m_wait_lock->trx, 3000); - - print("*** (1) WAITING FOR THIS LOCK TO BE GRANTED:\n"); + /** rewind(3) the file used for storing the latest detected deadlock and + print a heading message to stderr if printing of all deadlocks to stderr + is enabled. */ + static void start_print() + { + lock_sys.assert_locked(); - print(m_wait_lock); + rewind(lock_latest_err_file); + ut_print_timestamp(lock_latest_err_file); - print("*** (2) TRANSACTION:\n"); + if (srv_print_all_deadlocks) + ib::info() << "Transactions deadlock detected," + " dumping detailed information."; + } - print(lock->trx, 3000); + /** Print a message to the deadlock file and possibly to stderr. + @param msg message to print */ + static void print(const char *msg) + { + fputs(msg, lock_latest_err_file); + if (srv_print_all_deadlocks) + ib::info() << msg; + } - print("*** (2) HOLDS THE LOCK(S):\n"); + /** Print transaction data to the deadlock file and possibly to stderr. + @param trx transaction */ + static void print(const trx_t &trx) + { + lock_sys.assert_locked(); - print(lock); + ulint n_rec_locks= trx.lock.n_rec_locks; + ulint n_trx_locks= UT_LIST_GET_LEN(trx.lock.trx_locks); + ulint heap_size= mem_heap_get_size(trx.lock.lock_heap); - /* It is possible that the joining transaction was granted its - lock when we rolled back some other waiting transaction. */ + trx_print_low(lock_latest_err_file, &trx, 3000, + n_rec_locks, n_trx_locks, heap_size); - if (m_start->lock.wait_lock != 0) { - print("*** (2) WAITING FOR THIS LOCK TO BE GRANTED:\n"); + if (srv_print_all_deadlocks) + trx_print_low(stderr, &trx, 3000, n_rec_locks, n_trx_locks, heap_size); + } - print(m_start->lock.wait_lock); - } + /** Print lock data to the deadlock file and possibly to stderr. + @param lock record or table type lock */ + static void print(const lock_t &lock) + { + lock_sys.assert_locked(); - DBUG_PRINT("ib_lock", ("deadlock detected")); -} + if (!lock.is_table()) + { + mtr_t mtr; + lock_rec_print(lock_latest_err_file, &lock, mtr); -/** Select the victim transaction that should be rolledback. -@return victim transaction */ -const trx_t* -DeadlockChecker::select_victim() const -{ - ut_ad(lock_mutex_own()); - ut_ad(m_start->lock.wait_lock != 0); - ut_ad(m_wait_lock->trx != m_start); + if (srv_print_all_deadlocks) + lock_rec_print(stderr, &lock, mtr); + } + else + { + lock_table_print(lock_latest_err_file, &lock); - if (trx_weight_ge(m_wait_lock->trx, m_start)) { - /* The joining transaction is 'smaller', - choose it as the victim and roll it back. */ -#ifdef WITH_WSREP - if (wsrep_thd_is_BF(m_start->mysql_thd, FALSE)) { - return(m_wait_lock->trx); - } -#endif /* WITH_WSREP */ - return(m_start); - } + if (srv_print_all_deadlocks) + lock_table_print(stderr, &lock); + } + } + ATTRIBUTE_COLD + /** Report a deadlock (cycle in the waits-for graph). + @param trx transaction waiting for a lock in this thread + @param current_trx whether trx belongs to the current thread + @return the transaction to be rolled back (unless one was committed already) + @return nullptr if no deadlock */ + static trx_t *report(trx_t *const trx, bool current_trx) + { + mysql_mutex_assert_owner(&lock_sys.wait_mutex); + ut_ad(xtest() || lock_sys.is_writer() == !current_trx); + + /* Normally, trx should be a direct part of the deadlock + cycle. However, if innodb_deadlock_detect had been OFF in the + past, or if current_trx=false, trx may be waiting for a lock that + is held by a participant of a pre-existing deadlock, without being + part of the deadlock itself. That is, the path to the deadlock may be + P-shaped instead of O-shaped, with trx being at the foot of the P. + + We will process the entire path leading to a cycle, and we will + choose the victim (to be aborted) among the cycle. */ + + static const char rollback_msg[]= "*** WE ROLL BACK TRANSACTION (%u)\n"; + char buf[9 + sizeof rollback_msg]; + + /* If current_trx=true, trx is owned by this thread, and we can + safely invoke these without holding trx->mutex or lock_sys.latch. + If current_trx=false, a concurrent commit is protected by both + lock_sys.latch and lock_sys.wait_mutex. */ + const undo_no_t trx_weight= TRX_WEIGHT(trx) | + (trx->mysql_thd && #ifdef WITH_WSREP - if (wsrep_thd_is_BF(m_wait_lock->trx->mysql_thd, FALSE)) { - return(m_start); - } + (thd_has_edited_nontrans_tables(trx->mysql_thd) || + (trx->is_wsrep() && wsrep_thd_is_BF(trx->mysql_thd, false))) +#else + thd_has_edited_nontrans_tables(trx->mysql_thd) #endif /* WITH_WSREP */ + ? 1ULL << 63 : 0); - return(m_wait_lock->trx); -} - -/** Looks iteratively for a deadlock. Note: the joining transaction may -have been granted its lock by the deadlock checks. -@return 0 if no deadlock else the victim transaction instance.*/ -const trx_t* -DeadlockChecker::search() -{ - ut_ad(lock_mutex_own()); - ut_ad(!trx_mutex_own(m_start)); - - ut_ad(m_start != NULL); - ut_ad(m_wait_lock != NULL); - ut_ad(!m_wait_lock->trx->auto_commit || m_wait_lock->trx->will_lock); - ut_d(check_trx_state(m_wait_lock->trx)); - ut_ad(m_mark_start <= s_lock_mark_counter); - - /* Look at the locks ahead of wait_lock in the lock queue. */ - ulint heap_no; - const lock_t* lock = get_first_lock(&heap_no); - - for (;;) { - /* We should never visit the same sub-tree more than once. */ - ut_ad(lock == NULL || !is_visited(lock)); - - while (m_n_elems > 0 && lock == NULL) { - - /* Restore previous search state. */ - - pop(lock, heap_no); - - lock = get_next_lock(lock, heap_no); - } - - if (lock == NULL) { - break; - } - - if (lock == m_wait_lock) { + trx_t *victim= nullptr; + undo_no_t victim_weight= ~0ULL; + unsigned victim_pos= 0, trx_pos= 0; - /* We can mark this subtree as searched */ - ut_ad(lock->trx->lock.deadlock_mark <= m_mark_start); - - lock->trx->lock.deadlock_mark = ++s_lock_mark_counter; - - /* We are not prepared for an overflow. This 64-bit - counter should never wrap around. At 10^9 increments - per second, it would take 10^3 years of uptime. */ - - ut_ad(s_lock_mark_counter > 0); - - /* Backtrack */ - lock = NULL; - continue; - } - - if (!lock_has_to_wait(m_wait_lock, lock)) { - /* No conflict, next lock */ - lock = get_next_lock(lock, heap_no); - continue; - } - - if (lock->trx == m_start) { - /* Found a cycle. */ - notify(lock); - return select_victim(); - } - - if (is_too_deep()) { - /* Search too deep to continue. */ - m_too_deep = true; - return m_start; - } - - /* We do not need to report autoinc locks to the upper - layer. These locks are released before commit, so they - can not cause deadlocks with binlog-fixed commit - order. */ - if (m_report_waiters - && (lock_get_type_low(lock) != LOCK_TABLE - || lock_get_mode(lock) != LOCK_AUTO_INC)) { - thd_rpl_deadlock_check(m_start->mysql_thd, - lock->trx->mysql_thd); - } - - if (lock->trx->lock.que_state == TRX_QUE_LOCK_WAIT) { - /* Another trx ahead has requested a lock in an - incompatible mode, and is itself waiting for a lock. */ - - ++m_cost; - - if (!push(lock, heap_no)) { - m_too_deep = true; - return m_start; - } - - m_wait_lock = lock->trx->lock.wait_lock; - - lock = get_first_lock(&heap_no); - - if (is_visited(lock)) { - lock = get_next_lock(lock, heap_no); - } - } else { - lock = get_next_lock(lock, heap_no); - } - } - - ut_a(lock == NULL && m_n_elems == 0); - - /* No deadlock found. */ - return(0); -} - -/** Print info about transaction that was rolled back. -@param trx transaction rolled back -@param lock lock trx wants */ -void -DeadlockChecker::rollback_print(const trx_t* trx, const lock_t* lock) -{ - ut_ad(lock_mutex_own()); - - /* If the lock search exceeds the max step - or the max depth, the current trx will be - the victim. Print its information. */ - start_print(); - - print("TOO DEEP OR LONG SEARCH IN THE LOCK TABLE" - " WAITS-FOR GRAPH, WE WILL ROLL BACK" - " FOLLOWING TRANSACTION \n\n" - "*** TRANSACTION:\n"); + /* Here, lock elision does not make sense, because + for the output we are going to invoke system calls, + which would interrupt a memory transaction. */ + if (current_trx && !lock_sys.wr_lock_try()) + { + mysql_mutex_unlock(&lock_sys.wait_mutex); + lock_sys.wr_lock(SRW_LOCK_CALL); + mysql_mutex_lock(&lock_sys.wait_mutex); + } - print(trx, 3000); + { + unsigned l= 0; + /* Now that we are holding lock_sys.wait_mutex again, check + whether a cycle still exists. */ + trx_t *cycle= find_cycle(trx); + if (!cycle) + goto func_exit; /* One of the transactions was already aborted. */ + for (trx_t *next= cycle;;) + { + next= next->lock.wait_trx; + l++; + const undo_no_t next_weight= TRX_WEIGHT(next) | + (next->mysql_thd && +#ifdef WITH_WSREP + (thd_has_edited_nontrans_tables(next->mysql_thd) || + (next->is_wsrep() && wsrep_thd_is_BF(next->mysql_thd, false))) +#else + thd_has_edited_nontrans_tables(next->mysql_thd) +#endif /* WITH_WSREP */ + ? 1ULL << 63 : 0); + if (next_weight < victim_weight) + { + victim_weight= next_weight; + victim= next; + victim_pos= l; + } + if (next == victim) + trx_pos= l; + if (next == cycle) + break; + } - print("*** WAITING FOR THIS LOCK TO BE GRANTED:\n"); + if (trx_pos && trx_weight == victim_weight) + { + victim= trx; + victim_pos= trx_pos; + } - print(lock); -} + /* Finally, display the deadlock */ + switch (const auto r= static_cast<enum report>(innodb_deadlock_report)) { + case REPORT_OFF: + break; + case REPORT_BASIC: + case REPORT_FULL: + start_print(); + l= 0; -/** Rollback transaction selected as the victim. */ -void -DeadlockChecker::trx_rollback() -{ - ut_ad(lock_mutex_own()); + for (trx_t *next= cycle;;) + { + next= next->lock.wait_trx; + ut_ad(next); + ut_ad(next->state == TRX_STATE_ACTIVE); + const lock_t *wait_lock= next->lock.wait_lock; + ut_ad(wait_lock); + snprintf(buf, sizeof buf, "\n*** (%u) TRANSACTION:\n", ++l); + print(buf); + print(*next); + print("*** WAITING FOR THIS LOCK TO BE GRANTED:\n"); + print(*wait_lock); + if (r == REPORT_BASIC); + else if (wait_lock->is_table()) + { + if (const lock_t *lock= + UT_LIST_GET_FIRST(wait_lock->un_member.tab_lock.table->locks)) + { + ut_ad(!lock->is_waiting()); + print("*** CONFLICTING WITH:\n"); + do + print(*lock); + while ((lock= UT_LIST_GET_NEXT(un_member.tab_lock.locks, lock)) && + !lock->is_waiting()); + } + else + ut_ad("no conflicting table lock found" == 0); + } + else + { + const page_id_t id{wait_lock->un_member.rec_lock.page_id}; + hash_cell_t &cell= *(wait_lock->type_mode & LOCK_PREDICATE + ? lock_sys.prdt_hash : lock_sys.rec_hash). + cell_get(id.fold()); + if (const lock_t *lock= lock_sys_t::get_first(cell, id)) + { + const ulint heap_no= lock_rec_find_set_bit(wait_lock); + if (!lock_rec_get_nth_bit(lock, heap_no)) + lock= lock_rec_get_next_const(heap_no, lock); + ut_ad(!lock->is_waiting()); + print("*** CONFLICTING WITH:\n"); + do + print(*lock); + while ((lock= lock_rec_get_next_const(heap_no, lock)) && + !lock->is_waiting()); + } + else + ut_ad("no conflicting record lock found" == 0); + } + if (next == cycle) + break; + } + snprintf(buf, sizeof buf, rollback_msg, victim_pos); + print(buf); + } - trx_t* trx = m_wait_lock->trx; + ut_ad(victim->state == TRX_STATE_ACTIVE); - print("*** WE ROLL BACK TRANSACTION (1)\n"); + /* victim->lock.was_chosen_as_deadlock_victim must always be set before + releasing waiting locks and reseting trx->lock.wait_lock */ + victim->lock.was_chosen_as_deadlock_victim= true; + DEBUG_SYNC_C("deadlock_report_before_lock_releasing"); + lock_cancel_waiting_and_release<true>(victim->lock.wait_lock); #ifdef WITH_WSREP - if (trx->is_wsrep() && wsrep_thd_is_SR(trx->mysql_thd)) { - wsrep_handle_SR_rollback(m_start->mysql_thd, trx->mysql_thd); - } + if (victim->is_wsrep() && wsrep_thd_is_SR(victim->mysql_thd)) + wsrep_handle_SR_rollback(trx->mysql_thd, victim->mysql_thd); #endif + } - trx_mutex_enter(trx); - - trx->lock.was_chosen_as_deadlock_victim = true; - - lock_cancel_waiting_and_release(trx->lock.wait_lock); - - trx_mutex_exit(trx); +func_exit: + if (current_trx) + lock_sys.wr_unlock(); + return victim; + } } -/** Check if a joining lock request results in a deadlock. -If a deadlock is found, we will resolve the deadlock by -choosing a victim transaction and rolling it back. -We will attempt to resolve all deadlocks. - -@param[in] lock the lock request -@param[in,out] trx transaction requesting the lock - -@return trx if it was chosen as victim -@retval NULL if another victim was chosen, -or there is no deadlock (any more) */ -const trx_t* -DeadlockChecker::check_and_resolve(const lock_t* lock, trx_t* trx) +/** Check if a lock request results in a deadlock. +Resolve a deadlock by choosing a transaction that will be rolled back. +@param trx transaction requesting a lock +@return whether trx must report DB_DEADLOCK */ +static bool Deadlock::check_and_resolve(trx_t *trx) { - ut_ad(lock_mutex_own()); - ut_ad(trx_mutex_own(trx)); - ut_ad(trx->state == TRX_STATE_ACTIVE); - ut_ad(!trx->auto_commit || trx->will_lock); - ut_ad(!srv_read_only_mode); - - if (!innobase_deadlock_detect) { - return(NULL); - } - - /* Release the mutex to obey the latching order. - This is safe, because DeadlockChecker::check_and_resolve() - is invoked when a lock wait is enqueued for the currently - running transaction. Because m_trx is a running transaction - (it is not currently suspended because of a lock wait), - its state can only be changed by this thread, which is - currently associated with the transaction. */ - - trx_mutex_exit(trx); - - const trx_t* victim_trx; - const bool report_waiters = trx->mysql_thd - && thd_need_wait_reports(trx->mysql_thd); - - /* Try and resolve as many deadlocks as possible. */ - do { - DeadlockChecker checker(trx, lock, s_lock_mark_counter, - report_waiters); - - victim_trx = checker.search(); + mysql_mutex_assert_owner(&lock_sys.wait_mutex); - /* Search too deep, we rollback the joining transaction only - if it is possible to rollback. Otherwise we rollback the - transaction that is holding the lock that the joining - transaction wants. */ - if (checker.is_too_deep()) { - - ut_ad(trx == checker.m_start); - ut_ad(trx == victim_trx); - - rollback_print(victim_trx, lock); - - MONITOR_INC(MONITOR_DEADLOCK); - srv_stats.lock_deadlock_count.inc(); - - break; - - } else if (victim_trx != NULL && victim_trx != trx) { - - ut_ad(victim_trx == checker.m_wait_lock->trx); + ut_ad(!trx->mutex_is_owner()); + ut_ad(trx->state == TRX_STATE_ACTIVE); + ut_ad(!srv_read_only_mode); - checker.trx_rollback(); + if (!innodb_deadlock_detect) + return false; - lock_deadlock_found = true; + if (UNIV_LIKELY_NULL(find_cycle(trx)) && report(trx, true) == trx) + return true; - MONITOR_INC(MONITOR_DEADLOCK); - srv_stats.lock_deadlock_count.inc(); - } + if (UNIV_LIKELY(!trx->lock.was_chosen_as_deadlock_victim)) + return false; - } while (victim_trx != NULL && victim_trx != trx); + if (lock_t *wait_lock= trx->lock.wait_lock) + lock_sys_t::cancel<false>(trx, wait_lock); - /* If the joining transaction was selected as the victim. */ - if (victim_trx != NULL) { + lock_sys.deadlock_check(); + return true; +} - print("*** WE ROLL BACK TRANSACTION (2)\n"); -#ifdef WITH_WSREP - if (trx->is_wsrep() && wsrep_thd_is_SR(trx->mysql_thd)) { - wsrep_handle_SR_rollback(trx->mysql_thd, - victim_trx->mysql_thd); - } +/** Check for deadlocks while holding only lock_sys.wait_mutex. */ +TRANSACTIONAL_TARGET +void lock_sys_t::deadlock_check() +{ + ut_ad(!is_writer()); + mysql_mutex_assert_owner(&wait_mutex); + bool acquired= false; +#if !defined NO_ELISION && !defined SUX_LOCK_GENERIC + bool elided= false; #endif - lock_deadlock_found = true; - } - - trx_mutex_enter(trx); - - return(victim_trx); + if (Deadlock::to_be_checked) + { + for (;;) + { + auto i= Deadlock::to_check.begin(); + if (i == Deadlock::to_check.end()) + break; + if (acquired); +#if !defined NO_ELISION && !defined SUX_LOCK_GENERIC + else if (xbegin()) + { + if (latch.is_locked_or_waiting()) + xabort(); + acquired= elided= true; + } +#endif + else + { + acquired= wr_lock_try(); + if (!acquired) + { + acquired= true; + mysql_mutex_unlock(&wait_mutex); + lock_sys.wr_lock(SRW_LOCK_CALL); + mysql_mutex_lock(&wait_mutex); + continue; + } + } + trx_t *trx= *i; + Deadlock::to_check.erase(i); + if (Deadlock::find_cycle(trx)) + Deadlock::report(trx, false); + } + Deadlock::to_be_checked= false; + } + ut_ad(Deadlock::to_check.empty()); +#if !defined NO_ELISION && !defined SUX_LOCK_GENERIC + if (elided) + return; +#endif + if (acquired) + wr_unlock(); } -/*************************************************************//** -Updates the lock table when a page is split and merged to -two pages. */ -UNIV_INTERN -void -lock_update_split_and_merge( +/** Update the locks when a page is split and merged to two pages, +in defragmentation. */ +void lock_update_split_and_merge( const buf_block_t* left_block, /*!< in: left page to which merged */ const rec_t* orig_pred, /*!< in: original predecessor of supremum on the left page before merge*/ const buf_block_t* right_block) /*!< in: right page from which merged */ { - const rec_t* left_next_rec; - - ut_ad(page_is_leaf(left_block->frame)); - ut_ad(page_is_leaf(right_block->frame)); - ut_ad(page_align(orig_pred) == left_block->frame); + ut_ad(page_is_leaf(left_block->page.frame)); + ut_ad(page_is_leaf(right_block->page.frame)); + ut_ad(page_align(orig_pred) == left_block->page.frame); - lock_mutex_enter(); - - left_next_rec = page_rec_get_next_const(orig_pred); - ut_ad(!page_rec_is_metadata(left_next_rec)); - - /* Inherit the locks on the supremum of the left page to the - first record which was moved from the right page */ - lock_rec_inherit_to_gap( - left_block, left_block, - page_rec_get_heap_no(left_next_rec), - PAGE_HEAP_NO_SUPREMUM); - - /* Reset the locks on the supremum of the left page, - releasing waiting transactions */ - lock_rec_reset_and_release_wait(left_block, - PAGE_HEAP_NO_SUPREMUM); - - /* Inherit the locks to the supremum of the left page from the - successor of the infimum on the right page */ - lock_rec_inherit_to_gap(left_block, right_block, - PAGE_HEAP_NO_SUPREMUM, - lock_get_min_heap_no(right_block)); - - lock_mutex_exit(); + const page_id_t l{left_block->page.id()}; + const page_id_t r{right_block->page.id()}; + const rec_t *left_next_rec= page_rec_get_next_const(orig_pred); + if (UNIV_UNLIKELY(!left_next_rec)) + { + ut_ad("corrupted page" == 0); + return; + } + ut_ad(!page_rec_is_metadata(left_next_rec)); + + /* This would likely be too large for a memory transaction. */ + LockMultiGuard g{lock_sys.rec_hash, l, r}; + + /* Inherit the locks on the supremum of the left page to the + first record which was moved from the right page */ + lock_rec_inherit_to_gap(g.cell1(), l, g.cell1(), l, left_block->page.frame, + page_rec_get_heap_no(left_next_rec), + PAGE_HEAP_NO_SUPREMUM); + + /* Reset the locks on the supremum of the left page, + releasing waiting transactions */ + lock_rec_reset_and_release_wait(g.cell1(), l, PAGE_HEAP_NO_SUPREMUM); + + /* Inherit the locks to the supremum of the left page from the + successor of the infimum on the right page */ + lock_rec_inherit_to_gap(g.cell1(), l, g.cell2(), r, left_block->page.frame, + PAGE_HEAP_NO_SUPREMUM, + lock_get_min_heap_no(right_block)); } |