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.
122 lines
3.9 KiB
C
122 lines
3.9 KiB
C
/******************************************************
|
|
The wait array used in synchronization primitives
|
|
|
|
(c) 1995 Innobase Oy
|
|
|
|
Created 9/5/1995 Heikki Tuuri
|
|
*******************************************************/
|
|
|
|
#ifndef sync0arr_h
|
|
#define sync0arr_h
|
|
|
|
#include "univ.i"
|
|
#include "ut0lst.h"
|
|
#include "ut0mem.h"
|
|
#include "os0thread.h"
|
|
|
|
typedef struct sync_cell_struct sync_cell_t;
|
|
typedef struct sync_array_struct sync_array_t;
|
|
|
|
#define SYNC_ARRAY_OS_MUTEX 1
|
|
#define SYNC_ARRAY_MUTEX 2
|
|
|
|
/***********************************************************************
|
|
Creates a synchronization wait array. It is protected by a mutex
|
|
which is automatically reserved when the functions operating on it
|
|
are called. */
|
|
|
|
sync_array_t*
|
|
sync_array_create(
|
|
/*==============*/
|
|
/* out, own: created wait array */
|
|
ulint n_cells, /* in: number of cells in the array
|
|
to create */
|
|
ulint protection); /* in: either SYNC_ARRAY_OS_MUTEX or
|
|
SYNC_ARRAY_MUTEX: determines the type
|
|
of mutex protecting the data structure */
|
|
/**********************************************************************
|
|
Frees the resources in a wait array. */
|
|
|
|
void
|
|
sync_array_free(
|
|
/*============*/
|
|
sync_array_t* arr); /* in, own: sync wait array */
|
|
/**********************************************************************
|
|
Reserves a wait array cell for waiting for an object.
|
|
The event of the cell is reset to nonsignalled state. */
|
|
|
|
void
|
|
sync_array_reserve_cell(
|
|
/*====================*/
|
|
sync_array_t* arr, /* in: wait array */
|
|
void* object, /* in: pointer to the object to wait for */
|
|
ulint type, /* in: lock request type */
|
|
const char* file, /* in: file where requested */
|
|
ulint line, /* in: line where requested */
|
|
ulint* index); /* out: index of the reserved cell */
|
|
/**********************************************************************
|
|
This function should be called when a thread starts to wait on
|
|
a wait array cell. In the debug version this function checks
|
|
if the wait for a semaphore will result in a deadlock, in which
|
|
case prints info and asserts. */
|
|
|
|
void
|
|
sync_array_wait_event(
|
|
/*==================*/
|
|
sync_array_t* arr, /* in: wait array */
|
|
ulint index); /* in: index of the reserved cell */
|
|
/**********************************************************************
|
|
Frees the cell. NOTE! sync_array_wait_event frees the cell
|
|
automatically! */
|
|
|
|
void
|
|
sync_array_free_cell(
|
|
/*=================*/
|
|
sync_array_t* arr, /* in: wait array */
|
|
ulint index); /* in: index of the cell in array */
|
|
/**************************************************************************
|
|
Note that one of the wait objects was signalled. */
|
|
|
|
void
|
|
sync_array_object_signalled(
|
|
/*========================*/
|
|
sync_array_t* arr); /* in: wait array */
|
|
/**************************************************************************
|
|
If the wakeup algorithm does not work perfectly at semaphore relases,
|
|
this function will do the waking (see the comment in mutex_exit). This
|
|
function should be called about every 1 second in the server. */
|
|
|
|
void
|
|
sync_arr_wake_threads_if_sema_free(void);
|
|
/*====================================*/
|
|
/**************************************************************************
|
|
Prints warnings of long semaphore waits to stderr. */
|
|
|
|
ibool
|
|
sync_array_print_long_waits(void);
|
|
/*=============================*/
|
|
/* out: TRUE if fatal semaphore wait threshold
|
|
was exceeded */
|
|
/************************************************************************
|
|
Validates the integrity of the wait array. Checks
|
|
that the number of reserved cells equals the count variable. */
|
|
|
|
void
|
|
sync_array_validate(
|
|
/*================*/
|
|
sync_array_t* arr); /* in: sync wait array */
|
|
/**************************************************************************
|
|
Prints info of the wait array. */
|
|
|
|
void
|
|
sync_array_print_info(
|
|
/*==================*/
|
|
FILE* file, /* in: file where to print */
|
|
sync_array_t* arr); /* in: wait array */
|
|
|
|
|
|
#ifndef UNIV_NONINL
|
|
#include "sync0arr.ic"
|
|
#endif
|
|
|
|
#endif
|