mirror of
https://github.com/MariaDB/server.git
synced 2025-01-19 21:42:35 +01:00
b8b6c7fcf7
Fixes the following bugs: - Bug #33349: possible race condition revolving around data dictionary and repartitioning Introduce retry/sleep logic as a workaround for a transient bug where ::open fails for partitioned tables randomly if we are using one file per table. - Bug #34053: normal users can enable innodb_monitor logging In CREATE TABLE and DROP TABLE check whether the table in question is one of the magic innodb_monitor tables and whether the user has enough rights to mess with it before doing anything else. - Bug #22868: 'Thread thrashing' with > 50 concurrent conns under an upd-intensive workloadw - Bug #29560: InnoDB >= 5.0.30 hangs on adaptive hash rw-lock 'waiting for an X-lock' This is a combination of changes that forward port the scalability fix applied to 5.0 through r1001. It reverts changes r149 and r122 (these were 5.1 specific changes made in lieu of scalability fix of 5.0) Then it applies r1001 to 5.0 which is the original scalability fix. Finally it applies r2082 which fixes an issue with the original fix. - Bug #30930: Add auxiliary function to retrieve THD::thread_id Add thd_get_thread_id() function. Also make check_global_access() function visible to InnoDB under INNODB_COMPATIBILITY_HOOKS #define.
512 lines
13 KiB
Text
512 lines
13 KiB
Text
/******************************************************
|
|
The read-write lock (for threads)
|
|
|
|
(c) 1995 Innobase Oy
|
|
|
|
Created 9/11/1995 Heikki Tuuri
|
|
*******************************************************/
|
|
|
|
/**********************************************************************
|
|
Lock an rw-lock in shared mode for the current thread. If the rw-lock is
|
|
locked in exclusive mode, or there is an exclusive lock request waiting,
|
|
the function spins a preset time (controlled by SYNC_SPIN_ROUNDS),
|
|
waiting for the lock before suspending the thread. */
|
|
|
|
void
|
|
rw_lock_s_lock_spin(
|
|
/*================*/
|
|
rw_lock_t* lock, /* in: pointer to rw-lock */
|
|
ulint pass, /* in: pass value; != 0, if the lock will
|
|
be passed to another thread to unlock */
|
|
const char* file_name,/* in: file name where lock requested */
|
|
ulint line); /* in: line where requested */
|
|
#ifdef UNIV_SYNC_DEBUG
|
|
/**********************************************************************
|
|
Inserts the debug information for an rw-lock. */
|
|
|
|
void
|
|
rw_lock_add_debug_info(
|
|
/*===================*/
|
|
rw_lock_t* lock, /* in: rw-lock */
|
|
ulint pass, /* in: pass value */
|
|
ulint lock_type, /* in: lock type */
|
|
const char* file_name, /* in: file where requested */
|
|
ulint line); /* in: line where requested */
|
|
/**********************************************************************
|
|
Removes a debug information struct for an rw-lock. */
|
|
|
|
void
|
|
rw_lock_remove_debug_info(
|
|
/*======================*/
|
|
rw_lock_t* lock, /* in: rw-lock */
|
|
ulint pass, /* in: pass value */
|
|
ulint lock_type); /* in: lock type */
|
|
#endif /* UNIV_SYNC_DEBUG */
|
|
|
|
/************************************************************************
|
|
Accessor functions for rw lock. */
|
|
UNIV_INLINE
|
|
ulint
|
|
rw_lock_get_waiters(
|
|
/*================*/
|
|
rw_lock_t* lock)
|
|
{
|
|
return(lock->waiters);
|
|
}
|
|
UNIV_INLINE
|
|
void
|
|
rw_lock_set_waiters(
|
|
/*================*/
|
|
rw_lock_t* lock,
|
|
ulint flag)
|
|
{
|
|
lock->waiters = flag;
|
|
}
|
|
UNIV_INLINE
|
|
ulint
|
|
rw_lock_get_writer(
|
|
/*===============*/
|
|
rw_lock_t* lock)
|
|
{
|
|
return(lock->writer);
|
|
}
|
|
UNIV_INLINE
|
|
void
|
|
rw_lock_set_writer(
|
|
/*===============*/
|
|
rw_lock_t* lock,
|
|
ulint flag)
|
|
{
|
|
lock->writer = flag;
|
|
}
|
|
UNIV_INLINE
|
|
ulint
|
|
rw_lock_get_reader_count(
|
|
/*=====================*/
|
|
rw_lock_t* lock)
|
|
{
|
|
return(lock->reader_count);
|
|
}
|
|
UNIV_INLINE
|
|
void
|
|
rw_lock_set_reader_count(
|
|
/*=====================*/
|
|
rw_lock_t* lock,
|
|
ulint count)
|
|
{
|
|
lock->reader_count = count;
|
|
}
|
|
UNIV_INLINE
|
|
mutex_t*
|
|
rw_lock_get_mutex(
|
|
/*==============*/
|
|
rw_lock_t* lock)
|
|
{
|
|
return(&(lock->mutex));
|
|
}
|
|
|
|
/**********************************************************************
|
|
Returns the value of writer_count for the lock. Does not reserve the lock
|
|
mutex, so the caller must be sure it is not changed during the call. */
|
|
UNIV_INLINE
|
|
ulint
|
|
rw_lock_get_x_lock_count(
|
|
/*=====================*/
|
|
/* out: value of writer_count */
|
|
rw_lock_t* lock) /* in: rw-lock */
|
|
{
|
|
return(lock->writer_count);
|
|
}
|
|
|
|
/**********************************************************************
|
|
Low-level function which tries to lock an rw-lock in s-mode. Performs no
|
|
spinning. */
|
|
UNIV_INLINE
|
|
ibool
|
|
rw_lock_s_lock_low(
|
|
/*===============*/
|
|
/* out: TRUE if success */
|
|
rw_lock_t* lock, /* in: pointer to rw-lock */
|
|
ulint pass __attribute__((unused)),
|
|
/* in: pass value; != 0, if the lock will be
|
|
passed to another thread to unlock */
|
|
const char* file_name, /* in: file name where lock requested */
|
|
ulint line) /* in: line where requested */
|
|
{
|
|
ut_ad(mutex_own(rw_lock_get_mutex(lock)));
|
|
|
|
/* Check if the writer field is free */
|
|
|
|
if (UNIV_LIKELY(lock->writer == RW_LOCK_NOT_LOCKED)) {
|
|
/* Set the shared lock by incrementing the reader count */
|
|
lock->reader_count++;
|
|
|
|
#ifdef UNIV_SYNC_DEBUG
|
|
rw_lock_add_debug_info(lock, pass, RW_LOCK_SHARED, file_name,
|
|
line);
|
|
#endif
|
|
lock->last_s_file_name = file_name;
|
|
lock->last_s_line = line;
|
|
|
|
return(TRUE); /* locking succeeded */
|
|
}
|
|
|
|
return(FALSE); /* locking did not succeed */
|
|
}
|
|
|
|
/**********************************************************************
|
|
Low-level function which locks an rw-lock in s-mode when we know that it
|
|
is possible and none else is currently accessing the rw-lock structure.
|
|
Then we can do the locking without reserving the mutex. */
|
|
UNIV_INLINE
|
|
void
|
|
rw_lock_s_lock_direct(
|
|
/*==================*/
|
|
rw_lock_t* lock, /* in: pointer to rw-lock */
|
|
const char* file_name, /* in: file name where requested */
|
|
ulint line) /* in: line where lock requested */
|
|
{
|
|
ut_ad(lock->writer == RW_LOCK_NOT_LOCKED);
|
|
ut_ad(rw_lock_get_reader_count(lock) == 0);
|
|
|
|
/* Set the shared lock by incrementing the reader count */
|
|
lock->reader_count++;
|
|
|
|
lock->last_s_file_name = file_name;
|
|
lock->last_s_line = line;
|
|
|
|
#ifdef UNIV_SYNC_DEBUG
|
|
rw_lock_add_debug_info(lock, 0, RW_LOCK_SHARED, file_name, line);
|
|
#endif
|
|
}
|
|
|
|
/**********************************************************************
|
|
Low-level function which locks an rw-lock in x-mode when we know that it
|
|
is not locked and none else is currently accessing the rw-lock structure.
|
|
Then we can do the locking without reserving the mutex. */
|
|
UNIV_INLINE
|
|
void
|
|
rw_lock_x_lock_direct(
|
|
/*==================*/
|
|
rw_lock_t* lock, /* in: pointer to rw-lock */
|
|
const char* file_name, /* in: file name where requested */
|
|
ulint line) /* in: line where lock requested */
|
|
{
|
|
ut_ad(rw_lock_validate(lock));
|
|
ut_ad(rw_lock_get_reader_count(lock) == 0);
|
|
ut_ad(rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED);
|
|
|
|
rw_lock_set_writer(lock, RW_LOCK_EX);
|
|
lock->writer_thread = os_thread_get_curr_id();
|
|
lock->writer_count++;
|
|
lock->pass = 0;
|
|
|
|
lock->last_x_file_name = file_name;
|
|
lock->last_x_line = line;
|
|
|
|
#ifdef UNIV_SYNC_DEBUG
|
|
rw_lock_add_debug_info(lock, 0, RW_LOCK_EX, file_name, line);
|
|
#endif
|
|
}
|
|
|
|
/**********************************************************************
|
|
NOTE! Use the corresponding macro, not directly this function! Lock an
|
|
rw-lock in shared mode for the current thread. If the rw-lock is locked
|
|
in exclusive mode, or there is an exclusive lock request waiting, the
|
|
function spins a preset time (controlled by SYNC_SPIN_ROUNDS), waiting for
|
|
the lock, before suspending the thread. */
|
|
UNIV_INLINE
|
|
void
|
|
rw_lock_s_lock_func(
|
|
/*================*/
|
|
rw_lock_t* lock, /* in: pointer to rw-lock */
|
|
ulint pass, /* in: pass value; != 0, if the lock will
|
|
be passed to another thread to unlock */
|
|
const char* file_name,/* in: file name where lock requested */
|
|
ulint line) /* in: line where requested */
|
|
{
|
|
/* NOTE: As we do not know the thread ids for threads which have
|
|
s-locked a latch, and s-lockers will be served only after waiting
|
|
x-lock requests have been fulfilled, then if this thread already
|
|
owns an s-lock here, it may end up in a deadlock with another thread
|
|
which requests an x-lock here. Therefore, we will forbid recursive
|
|
s-locking of a latch: the following assert will warn the programmer
|
|
of the possibility of this kind of a deadlock. If we want to implement
|
|
safe recursive s-locking, we should keep in a list the thread ids of
|
|
the threads which have s-locked a latch. This would use some CPU
|
|
time. */
|
|
|
|
#ifdef UNIV_SYNC_DEBUG
|
|
ut_ad(!rw_lock_own(lock, RW_LOCK_SHARED)); /* see NOTE above */
|
|
#endif /* UNIV_SYNC_DEBUG */
|
|
|
|
mutex_enter(rw_lock_get_mutex(lock));
|
|
|
|
if (UNIV_LIKELY(rw_lock_s_lock_low(lock, pass, file_name, line))) {
|
|
mutex_exit(rw_lock_get_mutex(lock));
|
|
|
|
return; /* Success */
|
|
} else {
|
|
/* Did not succeed, try spin wait */
|
|
mutex_exit(rw_lock_get_mutex(lock));
|
|
|
|
rw_lock_s_lock_spin(lock, pass, file_name, line);
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
/**********************************************************************
|
|
NOTE! Use the corresponding macro, not directly this function! Lock an
|
|
rw-lock in shared mode for the current thread if the lock can be acquired
|
|
immediately. */
|
|
UNIV_INLINE
|
|
ibool
|
|
rw_lock_s_lock_func_nowait(
|
|
/*=======================*/
|
|
/* out: TRUE if success */
|
|
rw_lock_t* lock, /* in: pointer to rw-lock */
|
|
const char* file_name,/* in: file name where lock requested */
|
|
ulint line) /* in: line where requested */
|
|
{
|
|
ibool success = FALSE;
|
|
|
|
mutex_enter(rw_lock_get_mutex(lock));
|
|
|
|
if (lock->writer == RW_LOCK_NOT_LOCKED) {
|
|
/* Set the shared lock by incrementing the reader count */
|
|
lock->reader_count++;
|
|
|
|
#ifdef UNIV_SYNC_DEBUG
|
|
rw_lock_add_debug_info(lock, 0, RW_LOCK_SHARED, file_name,
|
|
line);
|
|
#endif
|
|
|
|
lock->last_s_file_name = file_name;
|
|
lock->last_s_line = line;
|
|
|
|
success = TRUE;
|
|
}
|
|
|
|
mutex_exit(rw_lock_get_mutex(lock));
|
|
|
|
return(success);
|
|
}
|
|
|
|
/**********************************************************************
|
|
NOTE! Use the corresponding macro, not directly this function! Lock an
|
|
rw-lock in exclusive mode for the current thread if the lock can be
|
|
obtained immediately. */
|
|
UNIV_INLINE
|
|
ibool
|
|
rw_lock_x_lock_func_nowait(
|
|
/*=======================*/
|
|
/* out: TRUE if success */
|
|
rw_lock_t* lock, /* in: pointer to rw-lock */
|
|
const char* file_name,/* in: file name where lock requested */
|
|
ulint line) /* in: line where requested */
|
|
{
|
|
ibool success = FALSE;
|
|
os_thread_id_t curr_thread = os_thread_get_curr_id();
|
|
mutex_enter(rw_lock_get_mutex(lock));
|
|
|
|
if (UNIV_UNLIKELY(rw_lock_get_reader_count(lock) != 0)) {
|
|
} else if (UNIV_LIKELY(rw_lock_get_writer(lock)
|
|
== RW_LOCK_NOT_LOCKED)) {
|
|
rw_lock_set_writer(lock, RW_LOCK_EX);
|
|
lock->writer_thread = curr_thread;
|
|
lock->pass = 0;
|
|
relock:
|
|
lock->writer_count++;
|
|
|
|
#ifdef UNIV_SYNC_DEBUG
|
|
rw_lock_add_debug_info(lock, 0, RW_LOCK_EX, file_name, line);
|
|
#endif
|
|
|
|
lock->last_x_file_name = file_name;
|
|
lock->last_x_line = line;
|
|
|
|
success = TRUE;
|
|
} else if (rw_lock_get_writer(lock) == RW_LOCK_EX
|
|
&& lock->pass == 0
|
|
&& os_thread_eq(lock->writer_thread, curr_thread)) {
|
|
goto relock;
|
|
}
|
|
|
|
mutex_exit(rw_lock_get_mutex(lock));
|
|
|
|
ut_ad(rw_lock_validate(lock));
|
|
|
|
return(success);
|
|
}
|
|
|
|
/**********************************************************************
|
|
Releases a shared mode lock. */
|
|
UNIV_INLINE
|
|
void
|
|
rw_lock_s_unlock_func(
|
|
/*==================*/
|
|
rw_lock_t* lock /* in: rw-lock */
|
|
#ifdef UNIV_SYNC_DEBUG
|
|
,ulint pass /* in: pass value; != 0, if the lock may have
|
|
been passed to another thread to unlock */
|
|
#endif
|
|
)
|
|
{
|
|
mutex_t* mutex = &(lock->mutex);
|
|
ibool sg = FALSE;
|
|
|
|
/* Acquire the mutex protecting the rw-lock fields */
|
|
mutex_enter(mutex);
|
|
|
|
/* Reset the shared lock by decrementing the reader count */
|
|
|
|
ut_a(lock->reader_count > 0);
|
|
lock->reader_count--;
|
|
|
|
#ifdef UNIV_SYNC_DEBUG
|
|
rw_lock_remove_debug_info(lock, pass, RW_LOCK_SHARED);
|
|
#endif
|
|
|
|
/* If there may be waiters and this was the last s-lock,
|
|
signal the object */
|
|
|
|
if (UNIV_UNLIKELY(lock->waiters)
|
|
&& lock->reader_count == 0) {
|
|
sg = TRUE;
|
|
|
|
rw_lock_set_waiters(lock, 0);
|
|
}
|
|
|
|
mutex_exit(mutex);
|
|
|
|
if (UNIV_UNLIKELY(sg)) {
|
|
#ifdef __WIN__
|
|
os_event_set(lock->wait_ex_event);
|
|
#endif
|
|
os_event_set(lock->event);
|
|
sync_array_object_signalled(sync_primary_wait_array);
|
|
}
|
|
|
|
ut_ad(rw_lock_validate(lock));
|
|
|
|
#ifdef UNIV_SYNC_PERF_STAT
|
|
rw_s_exit_count++;
|
|
#endif
|
|
}
|
|
|
|
/**********************************************************************
|
|
Releases a shared mode lock when we know there are no waiters and none
|
|
else will access the lock during the time this function is executed. */
|
|
UNIV_INLINE
|
|
void
|
|
rw_lock_s_unlock_direct(
|
|
/*====================*/
|
|
rw_lock_t* lock) /* in: rw-lock */
|
|
{
|
|
/* Reset the shared lock by decrementing the reader count */
|
|
|
|
ut_ad(lock->reader_count > 0);
|
|
|
|
lock->reader_count--;
|
|
|
|
#ifdef UNIV_SYNC_DEBUG
|
|
rw_lock_remove_debug_info(lock, 0, RW_LOCK_SHARED);
|
|
#endif
|
|
|
|
ut_ad(!lock->waiters);
|
|
ut_ad(rw_lock_validate(lock));
|
|
#ifdef UNIV_SYNC_PERF_STAT
|
|
rw_s_exit_count++;
|
|
#endif
|
|
}
|
|
|
|
/**********************************************************************
|
|
Releases an exclusive mode lock. */
|
|
UNIV_INLINE
|
|
void
|
|
rw_lock_x_unlock_func(
|
|
/*==================*/
|
|
rw_lock_t* lock /* in: rw-lock */
|
|
#ifdef UNIV_SYNC_DEBUG
|
|
,ulint pass /* in: pass value; != 0, if the lock may have
|
|
been passed to another thread to unlock */
|
|
#endif
|
|
)
|
|
{
|
|
ibool sg = FALSE;
|
|
|
|
/* Acquire the mutex protecting the rw-lock fields */
|
|
mutex_enter(&(lock->mutex));
|
|
|
|
/* Reset the exclusive lock if this thread no longer has an x-mode
|
|
lock */
|
|
|
|
ut_ad(lock->writer_count > 0);
|
|
|
|
lock->writer_count--;
|
|
|
|
if (lock->writer_count == 0) {
|
|
rw_lock_set_writer(lock, RW_LOCK_NOT_LOCKED);
|
|
}
|
|
|
|
#ifdef UNIV_SYNC_DEBUG
|
|
rw_lock_remove_debug_info(lock, pass, RW_LOCK_EX);
|
|
#endif
|
|
|
|
/* If there may be waiters, signal the lock */
|
|
if (UNIV_UNLIKELY(lock->waiters)
|
|
&& lock->writer_count == 0) {
|
|
|
|
sg = TRUE;
|
|
rw_lock_set_waiters(lock, 0);
|
|
}
|
|
|
|
mutex_exit(&(lock->mutex));
|
|
|
|
if (UNIV_UNLIKELY(sg)) {
|
|
#ifdef __WIN__
|
|
os_event_set(lock->wait_ex_event);
|
|
#endif
|
|
os_event_set(lock->event);
|
|
sync_array_object_signalled(sync_primary_wait_array);
|
|
}
|
|
|
|
ut_ad(rw_lock_validate(lock));
|
|
|
|
#ifdef UNIV_SYNC_PERF_STAT
|
|
rw_x_exit_count++;
|
|
#endif
|
|
}
|
|
|
|
/**********************************************************************
|
|
Releases an exclusive mode lock when we know there are no waiters, and
|
|
none else will access the lock durint the time this function is executed. */
|
|
UNIV_INLINE
|
|
void
|
|
rw_lock_x_unlock_direct(
|
|
/*====================*/
|
|
rw_lock_t* lock) /* in: rw-lock */
|
|
{
|
|
/* Reset the exclusive lock if this thread no longer has an x-mode
|
|
lock */
|
|
|
|
ut_ad(lock->writer_count > 0);
|
|
|
|
lock->writer_count--;
|
|
|
|
if (lock->writer_count == 0) {
|
|
rw_lock_set_writer(lock, RW_LOCK_NOT_LOCKED);
|
|
}
|
|
|
|
#ifdef UNIV_SYNC_DEBUG
|
|
rw_lock_remove_debug_info(lock, 0, RW_LOCK_EX);
|
|
#endif
|
|
|
|
ut_ad(!lock->waiters);
|
|
ut_ad(rw_lock_validate(lock));
|
|
|
|
#ifdef UNIV_SYNC_PERF_STAT
|
|
rw_x_exit_count++;
|
|
#endif
|
|
}
|