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.
268 lines
8 KiB
C
268 lines
8 KiB
C
/******************************************************
|
|
The interface to the operating system
|
|
synchronization primitives.
|
|
|
|
(c) 1995 Innobase Oy
|
|
|
|
Created 9/6/1995 Heikki Tuuri
|
|
*******************************************************/
|
|
#ifndef os0sync_h
|
|
#define os0sync_h
|
|
|
|
#include "univ.i"
|
|
#include "ut0lst.h"
|
|
|
|
#ifdef __WIN__
|
|
|
|
#define os_fast_mutex_t CRITICAL_SECTION
|
|
|
|
typedef HANDLE os_native_event_t;
|
|
|
|
typedef struct os_event_struct os_event_struct_t;
|
|
typedef os_event_struct_t* os_event_t;
|
|
|
|
struct os_event_struct {
|
|
os_native_event_t handle;
|
|
/* Windows event */
|
|
UT_LIST_NODE_T(os_event_struct_t) os_event_list;
|
|
/* list of all created events */
|
|
};
|
|
#else
|
|
typedef pthread_mutex_t os_fast_mutex_t;
|
|
|
|
typedef struct os_event_struct os_event_struct_t;
|
|
typedef os_event_struct_t* os_event_t;
|
|
|
|
struct os_event_struct {
|
|
os_fast_mutex_t os_mutex; /* this mutex protects the next
|
|
fields */
|
|
ibool is_set; /* this is TRUE when the event is
|
|
in the signaled state, i.e., a thread
|
|
does not stop if it tries to wait for
|
|
this event */
|
|
ib_longlong signal_count; /* this is incremented each time
|
|
the event becomes signaled */
|
|
pthread_cond_t cond_var; /* condition variable is used in
|
|
waiting for the event */
|
|
UT_LIST_NODE_T(os_event_struct_t) os_event_list;
|
|
/* list of all created events */
|
|
};
|
|
#endif
|
|
|
|
typedef struct os_mutex_struct os_mutex_str_t;
|
|
typedef os_mutex_str_t* os_mutex_t;
|
|
|
|
#define OS_SYNC_INFINITE_TIME ((ulint)(-1))
|
|
|
|
#define OS_SYNC_TIME_EXCEEDED 1
|
|
|
|
/* Mutex protecting counts and the event and OS 'slow' mutex lists */
|
|
extern os_mutex_t os_sync_mutex;
|
|
|
|
/* This is incremented by 1 in os_thread_create and decremented by 1 in
|
|
os_thread_exit */
|
|
extern ulint os_thread_count;
|
|
|
|
extern ulint os_event_count;
|
|
extern ulint os_mutex_count;
|
|
extern ulint os_fast_mutex_count;
|
|
|
|
/*************************************************************
|
|
Initializes global event and OS 'slow' mutex lists. */
|
|
|
|
void
|
|
os_sync_init(void);
|
|
/*==============*/
|
|
/*************************************************************
|
|
Frees created events and OS 'slow' mutexes. */
|
|
|
|
void
|
|
os_sync_free(void);
|
|
/*==============*/
|
|
/*************************************************************
|
|
Creates an event semaphore, i.e., a semaphore which may just have two states:
|
|
signaled and nonsignaled. The created event is manual reset: it must be reset
|
|
explicitly by calling sync_os_reset_event. */
|
|
|
|
os_event_t
|
|
os_event_create(
|
|
/*============*/
|
|
/* out: the event handle */
|
|
const char* name); /* in: the name of the event, if NULL
|
|
the event is created without a name */
|
|
#ifdef __WIN__
|
|
/*************************************************************
|
|
Creates an auto-reset event semaphore, i.e., an event which is automatically
|
|
reset when a single thread is released. Works only in Windows. */
|
|
|
|
os_event_t
|
|
os_event_create_auto(
|
|
/*=================*/
|
|
/* out: the event handle */
|
|
const char* name); /* in: the name of the event, if NULL
|
|
the event is created without a name */
|
|
#endif
|
|
/**************************************************************
|
|
Sets an event semaphore to the signaled state: lets waiting threads
|
|
proceed. */
|
|
|
|
void
|
|
os_event_set(
|
|
/*=========*/
|
|
os_event_t event); /* in: event to set */
|
|
/**************************************************************
|
|
Resets an event semaphore to the nonsignaled state. Waiting threads will
|
|
stop to wait for the event.
|
|
The return value should be passed to os_even_wait_low() if it is desired
|
|
that this thread should not wait in case of an intervening call to
|
|
os_event_set() between this os_event_reset() and the
|
|
os_event_wait_low() call. See comments for os_event_wait_low(). */
|
|
|
|
ib_longlong
|
|
os_event_reset(
|
|
/*===========*/
|
|
os_event_t event); /* in: event to reset */
|
|
/**************************************************************
|
|
Frees an event object. */
|
|
|
|
void
|
|
os_event_free(
|
|
/*==========*/
|
|
os_event_t event); /* in: event to free */
|
|
|
|
/**************************************************************
|
|
Waits for an event object until it is in the signaled state. If
|
|
srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS this also exits the
|
|
waiting thread when the event becomes signaled (or immediately if the
|
|
event is already in the signaled state).
|
|
|
|
Typically, if the event has been signalled after the os_event_reset()
|
|
we'll return immediately because event->is_set == TRUE.
|
|
There are, however, situations (e.g.: sync_array code) where we may
|
|
lose this information. For example:
|
|
|
|
thread A calls os_event_reset()
|
|
thread B calls os_event_set() [event->is_set == TRUE]
|
|
thread C calls os_event_reset() [event->is_set == FALSE]
|
|
thread A calls os_event_wait() [infinite wait!]
|
|
thread C calls os_event_wait() [infinite wait!]
|
|
|
|
Where such a scenario is possible, to avoid infinite wait, the
|
|
value returned by os_event_reset() should be passed in as
|
|
reset_sig_count. */
|
|
|
|
#define os_event_wait(event) os_event_wait_low((event), 0)
|
|
|
|
void
|
|
os_event_wait_low(
|
|
/*==============*/
|
|
os_event_t event, /* in: event to wait */
|
|
ib_longlong reset_sig_count);/* in: zero or the value
|
|
returned by previous call of
|
|
os_event_reset(). */
|
|
|
|
/**************************************************************
|
|
Waits for an event object until it is in the signaled state or
|
|
a timeout is exceeded. In Unix the timeout is always infinite. */
|
|
|
|
ulint
|
|
os_event_wait_time(
|
|
/*===============*/
|
|
/* out: 0 if success,
|
|
OS_SYNC_TIME_EXCEEDED if timeout
|
|
was exceeded */
|
|
os_event_t event, /* in: event to wait */
|
|
ulint time); /* in: timeout in microseconds, or
|
|
OS_SYNC_INFINITE_TIME */
|
|
#ifdef __WIN__
|
|
/**************************************************************
|
|
Waits for any event in an OS native event array. Returns if even a single
|
|
one is signaled or becomes signaled. */
|
|
|
|
ulint
|
|
os_event_wait_multiple(
|
|
/*===================*/
|
|
/* out: index of the event
|
|
which was signaled */
|
|
ulint n, /* in: number of events in the
|
|
array */
|
|
os_native_event_t* native_event_array);
|
|
/* in: pointer to an array of event
|
|
handles */
|
|
#endif
|
|
/*************************************************************
|
|
Creates an operating system mutex semaphore. Because these are slow, the
|
|
mutex semaphore of InnoDB itself (mutex_t) should be used where possible. */
|
|
|
|
os_mutex_t
|
|
os_mutex_create(
|
|
/*============*/
|
|
/* out: the mutex handle */
|
|
const char* name); /* in: the name of the mutex, if NULL
|
|
the mutex is created without a name */
|
|
/**************************************************************
|
|
Acquires ownership of a mutex semaphore. */
|
|
|
|
void
|
|
os_mutex_enter(
|
|
/*===========*/
|
|
os_mutex_t mutex); /* in: mutex to acquire */
|
|
/**************************************************************
|
|
Releases ownership of a mutex. */
|
|
|
|
void
|
|
os_mutex_exit(
|
|
/*==========*/
|
|
os_mutex_t mutex); /* in: mutex to release */
|
|
/**************************************************************
|
|
Frees an mutex object. */
|
|
|
|
void
|
|
os_mutex_free(
|
|
/*==========*/
|
|
os_mutex_t mutex); /* in: mutex to free */
|
|
/**************************************************************
|
|
Acquires ownership of a fast mutex. Currently in Windows this is the same
|
|
as os_fast_mutex_lock! */
|
|
UNIV_INLINE
|
|
ulint
|
|
os_fast_mutex_trylock(
|
|
/*==================*/
|
|
/* out: 0 if success, != 0 if
|
|
was reserved by another
|
|
thread */
|
|
os_fast_mutex_t* fast_mutex); /* in: mutex to acquire */
|
|
/**************************************************************
|
|
Releases ownership of a fast mutex. */
|
|
|
|
void
|
|
os_fast_mutex_unlock(
|
|
/*=================*/
|
|
os_fast_mutex_t* fast_mutex); /* in: mutex to release */
|
|
/*************************************************************
|
|
Initializes an operating system fast mutex semaphore. */
|
|
|
|
void
|
|
os_fast_mutex_init(
|
|
/*===============*/
|
|
os_fast_mutex_t* fast_mutex); /* in: fast mutex */
|
|
/**************************************************************
|
|
Acquires ownership of a fast mutex. */
|
|
|
|
void
|
|
os_fast_mutex_lock(
|
|
/*===============*/
|
|
os_fast_mutex_t* fast_mutex); /* in: mutex to acquire */
|
|
/**************************************************************
|
|
Frees an mutex object. */
|
|
|
|
void
|
|
os_fast_mutex_free(
|
|
/*===============*/
|
|
os_fast_mutex_t* fast_mutex); /* in: mutex to free */
|
|
|
|
#ifndef UNIV_NONINL
|
|
#include "os0sync.ic"
|
|
#endif
|
|
|
|
#endif
|