1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

WL#2360 Performance schema

Browse Source 
Part IV: sql instrumentation
This commit is contained in:
Marc Alff 2010-01-06 22:42:07 -07:00
parent 4b559b912f
commit 3d91522561
133 changed files with 5198 additions and 2295 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
client/client_priv.h
View File

@ -101,7 +101,7 @@ enum options_client
/**
First mysql version supporting the performance schema.
*/
#define FIRST_PERFORMANCE_SCHEMA_VERSION 50600
#define FIRST_PERFORMANCE_SCHEMA_VERSION 50599
/**
Name of the performance schema database.

14
libmysqld/lib_sql.cc
View File

@ -501,7 +501,19 @@ int init_embedded_server(int argc, char **argv, char **groups)
*/
logger.init_base();
if (init_common_variables("my", *argcp, *argvp, (const char **)groups))
orig_argc= *argcp;
orig_argv= *argvp;
load_defaults("my", (const char **)groups, argcp, argvp);
defaults_argc= *argcp;
defaults_argv= *argvp;
remaining_argc= argc;
remaining_argv= argv;
/* Must be initialized early for comparison of options name */
system_charset_info= &my_charset_utf8_general_ci;
sys_var_init();
if (init_common_variables())
{
mysql_server_end();
return 1;

20
mysql-test/include/have_perfschema.inc Normal file
View File

@ -0,0 +1,20 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
if (!`SELECT count(*) FROM information_schema.engines WHERE
(support = 'YES' OR support = 'DEFAULT') AND
engine = 'PERFORMANCE_SCHEMA'`){
skip Need performance schema compiled in;
}

18
mysql-test/suite/sys_vars/r/all_vars.result
View File

@ -1,12 +1,14 @@
create table t1 (test_name text);
create table t2 (variable_name text);
load data infile "MYSQLTEST_VARDIR/tmp/sys_vars.all_vars.txt" into table t1;
select variable_name as `There should be *no* variables listed below:`
from information_schema.global_variables
left join t1 on variable_name=test_name where
test_name is null
union
select variable_name from information_schema.session_variables
left join t1 on variable_name=test_name where
test_name is null;
insert into t2 select variable_name from information_schema.global_variables;
insert into t2 select variable_name from information_schema.session_variables;
update t2 set variable_name= replace(variable_name, "PERFORMANCE_SCHEMA_", "PFS_");
select variable_name as `There should be *no* long test name listed below:` from t2
where length(variable_name) > 50;
There should be *no* long test name listed below:
select variable_name as `There should be *no* variables listed below:` from t2
left join t1 on variable_name=test_name where test_name is null;
There should be *no* variables listed below:
drop table t1;
drop table t2;

23
mysql-test/suite/sys_vars/r/performance_schema_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema;
@@global.performance_schema
1
select @@session.performance_schema;
ERROR HY000: Variable 'performance_schema' is a GLOBAL variable
show global variables like 'performance_schema';
Variable_name Value
performance_schema ON
show session variables like 'performance_schema';
Variable_name Value
performance_schema ON
select * from information_schema.global_variables
where variable_name='performance_schema';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA ON
select * from information_schema.session_variables
where variable_name='performance_schema';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA ON
set global performance_schema=1;
ERROR HY000: Variable 'performance_schema' is a read only variable
set session performance_schema=1;
ERROR HY000: Variable 'performance_schema' is a read only variable

23
mysql-test/suite/sys_vars/r/pfs_events_waits_history_long_size_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema_events_waits_history_long_size;
@@global.performance_schema_events_waits_history_long_size
15000
select @@session.performance_schema_events_waits_history_long_size;
ERROR HY000: Variable 'performance_schema_events_waits_history_long_size' is a GLOBAL variable
show global variables like 'performance_schema_events_waits_history_long_size';
Variable_name Value
performance_schema_events_waits_history_long_size 15000
show session variables like 'performance_schema_events_waits_history_long_size';
Variable_name Value
performance_schema_events_waits_history_long_size 15000
select * from information_schema.global_variables
where variable_name='performance_schema_events_waits_history_long_size';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_EVENTS_WAITS_HISTORY_LONG_SIZE 15000
select * from information_schema.session_variables
where variable_name='performance_schema_events_waits_history_long_size';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_EVENTS_WAITS_HISTORY_LONG_SIZE 15000
set global performance_schema_events_waits_history_long_size=1;
ERROR HY000: Variable 'performance_schema_events_waits_history_long_size' is a read only variable
set session performance_schema_events_waits_history_long_size=1;
ERROR HY000: Variable 'performance_schema_events_waits_history_long_size' is a read only variable

23
mysql-test/suite/sys_vars/r/pfs_events_waits_history_size_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema_events_waits_history_size;
@@global.performance_schema_events_waits_history_size
15
select @@session.performance_schema_events_waits_history_size;
ERROR HY000: Variable 'performance_schema_events_waits_history_size' is a GLOBAL variable
show global variables like 'performance_schema_events_waits_history_size';
Variable_name Value
performance_schema_events_waits_history_size 15
show session variables like 'performance_schema_events_waits_history_size';
Variable_name Value
performance_schema_events_waits_history_size 15
select * from information_schema.global_variables
where variable_name='performance_schema_events_waits_history_size';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_EVENTS_WAITS_HISTORY_SIZE 15
select * from information_schema.session_variables
where variable_name='performance_schema_events_waits_history_size';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_EVENTS_WAITS_HISTORY_SIZE 15
set global performance_schema_events_waits_history_size=1;
ERROR HY000: Variable 'performance_schema_events_waits_history_size' is a read only variable
set session performance_schema_events_waits_history_size=1;
ERROR HY000: Variable 'performance_schema_events_waits_history_size' is a read only variable

23
mysql-test/suite/sys_vars/r/pfs_max_cond_classes_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema_max_cond_classes;
@@global.performance_schema_max_cond_classes
123
select @@session.performance_schema_max_cond_classes;
ERROR HY000: Variable 'performance_schema_max_cond_classes' is a GLOBAL variable
show global variables like 'performance_schema_max_cond_classes';
Variable_name Value
performance_schema_max_cond_classes 123
show session variables like 'performance_schema_max_cond_classes';
Variable_name Value
performance_schema_max_cond_classes 123
select * from information_schema.global_variables
where variable_name='performance_schema_max_cond_classes';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_COND_CLASSES 123
select * from information_schema.session_variables
where variable_name='performance_schema_max_cond_classes';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_COND_CLASSES 123
set global performance_schema_max_cond_classes=1;
ERROR HY000: Variable 'performance_schema_max_cond_classes' is a read only variable
set session performance_schema_max_cond_classes=1;
ERROR HY000: Variable 'performance_schema_max_cond_classes' is a read only variable

23
mysql-test/suite/sys_vars/r/pfs_max_cond_instances_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema_max_cond_instances;
@@global.performance_schema_max_cond_instances
123
select @@session.performance_schema_max_cond_instances;
ERROR HY000: Variable 'performance_schema_max_cond_instances' is a GLOBAL variable
show global variables like 'performance_schema_max_cond_instances';
Variable_name Value
performance_schema_max_cond_instances 123
show session variables like 'performance_schema_max_cond_instances';
Variable_name Value
performance_schema_max_cond_instances 123
select * from information_schema.global_variables
where variable_name='performance_schema_max_cond_instances';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_COND_INSTANCES 123
select * from information_schema.session_variables
where variable_name='performance_schema_max_cond_instances';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_COND_INSTANCES 123
set global performance_schema_max_cond_instances=1;
ERROR HY000: Variable 'performance_schema_max_cond_instances' is a read only variable
set session performance_schema_max_cond_instances=1;
ERROR HY000: Variable 'performance_schema_max_cond_instances' is a read only variable

23
mysql-test/suite/sys_vars/r/pfs_max_file_classes_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema_max_file_classes;
@@global.performance_schema_max_file_classes
123
select @@session.performance_schema_max_file_classes;
ERROR HY000: Variable 'performance_schema_max_file_classes' is a GLOBAL variable
show global variables like 'performance_schema_max_file_classes';
Variable_name Value
performance_schema_max_file_classes 123
show session variables like 'performance_schema_max_file_classes';
Variable_name Value
performance_schema_max_file_classes 123
select * from information_schema.global_variables
where variable_name='performance_schema_max_file_classes';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_FILE_CLASSES 123
select * from information_schema.session_variables
where variable_name='performance_schema_max_file_classes';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_FILE_CLASSES 123
set global performance_schema_max_file_classes=1;
ERROR HY000: Variable 'performance_schema_max_file_classes' is a read only variable
set session performance_schema_max_file_classes=1;
ERROR HY000: Variable 'performance_schema_max_file_classes' is a read only variable

23
mysql-test/suite/sys_vars/r/pfs_max_file_handles_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema_max_file_handles;
@@global.performance_schema_max_file_handles
123
select @@session.performance_schema_max_file_handles;
ERROR HY000: Variable 'performance_schema_max_file_handles' is a GLOBAL variable
show global variables like 'performance_schema_max_file_handles';
Variable_name Value
performance_schema_max_file_handles 123
show session variables like 'performance_schema_max_file_handles';
Variable_name Value
performance_schema_max_file_handles 123
select * from information_schema.global_variables
where variable_name='performance_schema_max_file_handles';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_FILE_HANDLES 123
select * from information_schema.session_variables
where variable_name='performance_schema_max_file_handles';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_FILE_HANDLES 123
set global performance_schema_max_file_handles=1;
ERROR HY000: Variable 'performance_schema_max_file_handles' is a read only variable
set session performance_schema_max_file_handles=1;
ERROR HY000: Variable 'performance_schema_max_file_handles' is a read only variable

23
mysql-test/suite/sys_vars/r/pfs_max_file_instances_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema_max_file_instances;
@@global.performance_schema_max_file_instances
123
select @@session.performance_schema_max_file_instances;
ERROR HY000: Variable 'performance_schema_max_file_instances' is a GLOBAL variable
show global variables like 'performance_schema_max_file_instances';
Variable_name Value
performance_schema_max_file_instances 123
show session variables like 'performance_schema_max_file_instances';
Variable_name Value
performance_schema_max_file_instances 123
select * from information_schema.global_variables
where variable_name='performance_schema_max_file_instances';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_FILE_INSTANCES 123
select * from information_schema.session_variables
where variable_name='performance_schema_max_file_instances';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_FILE_INSTANCES 123
set global performance_schema_max_file_instances=1;
ERROR HY000: Variable 'performance_schema_max_file_instances' is a read only variable
set session performance_schema_max_file_instances=1;
ERROR HY000: Variable 'performance_schema_max_file_instances' is a read only variable

23
mysql-test/suite/sys_vars/r/pfs_max_mutex_classes_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema_max_mutex_classes;
@@global.performance_schema_max_mutex_classes
123
select @@session.performance_schema_max_mutex_classes;
ERROR HY000: Variable 'performance_schema_max_mutex_classes' is a GLOBAL variable
show global variables like 'performance_schema_max_mutex_classes';
Variable_name Value
performance_schema_max_mutex_classes 123
show session variables like 'performance_schema_max_mutex_classes';
Variable_name Value
performance_schema_max_mutex_classes 123
select * from information_schema.global_variables
where variable_name='performance_schema_max_mutex_classes';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_MUTEX_CLASSES 123
select * from information_schema.session_variables
where variable_name='performance_schema_max_mutex_classes';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_MUTEX_CLASSES 123
set global performance_schema_max_mutex_classes=1;
ERROR HY000: Variable 'performance_schema_max_mutex_classes' is a read only variable
set session performance_schema_max_mutex_classes=1;
ERROR HY000: Variable 'performance_schema_max_mutex_classes' is a read only variable

23
mysql-test/suite/sys_vars/r/pfs_max_mutex_instances_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema_max_mutex_instances;
@@global.performance_schema_max_mutex_instances
123
select @@session.performance_schema_max_mutex_instances;
ERROR HY000: Variable 'performance_schema_max_mutex_instances' is a GLOBAL variable
show global variables like 'performance_schema_max_mutex_instances';
Variable_name Value
performance_schema_max_mutex_instances 123
show session variables like 'performance_schema_max_mutex_instances';
Variable_name Value
performance_schema_max_mutex_instances 123
select * from information_schema.global_variables
where variable_name='performance_schema_max_mutex_instances';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_MUTEX_INSTANCES 123
select * from information_schema.session_variables
where variable_name='performance_schema_max_mutex_instances';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_MUTEX_INSTANCES 123
set global performance_schema_max_mutex_instances=1;
ERROR HY000: Variable 'performance_schema_max_mutex_instances' is a read only variable
set session performance_schema_max_mutex_instances=1;
ERROR HY000: Variable 'performance_schema_max_mutex_instances' is a read only variable

23
mysql-test/suite/sys_vars/r/pfs_max_rwlock_classes_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema_max_rwlock_classes;
@@global.performance_schema_max_rwlock_classes
123
select @@session.performance_schema_max_rwlock_classes;
ERROR HY000: Variable 'performance_schema_max_rwlock_classes' is a GLOBAL variable
show global variables like 'performance_schema_max_rwlock_classes';
Variable_name Value
performance_schema_max_rwlock_classes 123
show session variables like 'performance_schema_max_rwlock_classes';
Variable_name Value
performance_schema_max_rwlock_classes 123
select * from information_schema.global_variables
where variable_name='performance_schema_max_rwlock_classes';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_RWLOCK_CLASSES 123
select * from information_schema.session_variables
where variable_name='performance_schema_max_rwlock_classes';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_RWLOCK_CLASSES 123
set global performance_schema_max_rwlock_classes=1;
ERROR HY000: Variable 'performance_schema_max_rwlock_classes' is a read only variable
set session performance_schema_max_rwlock_classes=1;
ERROR HY000: Variable 'performance_schema_max_rwlock_classes' is a read only variable

23
mysql-test/suite/sys_vars/r/pfs_max_rwlock_instances_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema_max_rwlock_instances;
@@global.performance_schema_max_rwlock_instances
123
select @@session.performance_schema_max_rwlock_instances;
ERROR HY000: Variable 'performance_schema_max_rwlock_instances' is a GLOBAL variable
show global variables like 'performance_schema_max_rwlock_instances';
Variable_name Value
performance_schema_max_rwlock_instances 123
show session variables like 'performance_schema_max_rwlock_instances';
Variable_name Value
performance_schema_max_rwlock_instances 123
select * from information_schema.global_variables
where variable_name='performance_schema_max_rwlock_instances';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_RWLOCK_INSTANCES 123
select * from information_schema.session_variables
where variable_name='performance_schema_max_rwlock_instances';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_RWLOCK_INSTANCES 123
set global performance_schema_max_rwlock_instances=1;
ERROR HY000: Variable 'performance_schema_max_rwlock_instances' is a read only variable
set session performance_schema_max_rwlock_instances=1;
ERROR HY000: Variable 'performance_schema_max_rwlock_instances' is a read only variable

23
mysql-test/suite/sys_vars/r/pfs_max_table_handles_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema_max_table_handles;
@@global.performance_schema_max_table_handles
123
select @@session.performance_schema_max_table_handles;
ERROR HY000: Variable 'performance_schema_max_table_handles' is a GLOBAL variable
show global variables like 'performance_schema_max_table_handles';
Variable_name Value
performance_schema_max_table_handles 123
show session variables like 'performance_schema_max_table_handles';
Variable_name Value
performance_schema_max_table_handles 123
select * from information_schema.global_variables
where variable_name='performance_schema_max_table_handles';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_TABLE_HANDLES 123
select * from information_schema.session_variables
where variable_name='performance_schema_max_table_handles';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_TABLE_HANDLES 123
set global performance_schema_max_table_handles=1;
ERROR HY000: Variable 'performance_schema_max_table_handles' is a read only variable
set session performance_schema_max_table_handles=1;
ERROR HY000: Variable 'performance_schema_max_table_handles' is a read only variable

23
mysql-test/suite/sys_vars/r/pfs_max_table_instances_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema_max_table_instances;
@@global.performance_schema_max_table_instances
123
select @@session.performance_schema_max_table_instances;
ERROR HY000: Variable 'performance_schema_max_table_instances' is a GLOBAL variable
show global variables like 'performance_schema_max_table_instances';
Variable_name Value
performance_schema_max_table_instances 123
show session variables like 'performance_schema_max_table_instances';
Variable_name Value
performance_schema_max_table_instances 123
select * from information_schema.global_variables
where variable_name='performance_schema_max_table_instances';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_TABLE_INSTANCES 123
select * from information_schema.session_variables
where variable_name='performance_schema_max_table_instances';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_TABLE_INSTANCES 123
set global performance_schema_max_table_instances=1;
ERROR HY000: Variable 'performance_schema_max_table_instances' is a read only variable
set session performance_schema_max_table_instances=1;
ERROR HY000: Variable 'performance_schema_max_table_instances' is a read only variable

23
mysql-test/suite/sys_vars/r/pfs_max_thread_classes_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema_max_thread_classes;
@@global.performance_schema_max_thread_classes
123
select @@session.performance_schema_max_thread_classes;
ERROR HY000: Variable 'performance_schema_max_thread_classes' is a GLOBAL variable
show global variables like 'performance_schema_max_thread_classes';
Variable_name Value
performance_schema_max_thread_classes 123
show session variables like 'performance_schema_max_thread_classes';
Variable_name Value
performance_schema_max_thread_classes 123
select * from information_schema.global_variables
where variable_name='performance_schema_max_thread_classes';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_THREAD_CLASSES 123
select * from information_schema.session_variables
where variable_name='performance_schema_max_thread_classes';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_THREAD_CLASSES 123
set global performance_schema_max_thread_classes=1;
ERROR HY000: Variable 'performance_schema_max_thread_classes' is a read only variable
set session performance_schema_max_thread_classes=1;
ERROR HY000: Variable 'performance_schema_max_thread_classes' is a read only variable

23
mysql-test/suite/sys_vars/r/pfs_max_thread_instances_basic.result Normal file
View File

@ -0,0 +1,23 @@
select @@global.performance_schema_max_thread_instances;
@@global.performance_schema_max_thread_instances
123
select @@session.performance_schema_max_thread_instances;
ERROR HY000: Variable 'performance_schema_max_thread_instances' is a GLOBAL variable
show global variables like 'performance_schema_max_thread_instances';
Variable_name Value
performance_schema_max_thread_instances 123
show session variables like 'performance_schema_max_thread_instances';
Variable_name Value
performance_schema_max_thread_instances 123
select * from information_schema.global_variables
where variable_name='performance_schema_max_thread_instances';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_THREAD_INSTANCES 123
select * from information_schema.session_variables
where variable_name='performance_schema_max_thread_instances';
VARIABLE_NAME VARIABLE_VALUE
PERFORMANCE_SCHEMA_MAX_THREAD_INSTANCES 123
set global performance_schema_max_thread_instances=1;
ERROR HY000: Variable 'performance_schema_max_thread_instances' is a read only variable
set session performance_schema_max_thread_instances=1;
ERROR HY000: Variable 'performance_schema_max_thread_instances' is a read only variable

41
mysql-test/suite/sys_vars/t/all_vars.test
View File

@ -1,3 +1,18 @@
# Copyright (C) 2009-2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
#
@ -20,16 +35,26 @@ perl;
EOF
create table t1 (test_name text);
create table t2 (variable_name text);
--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
eval load data infile "$MYSQLTEST_VARDIR/tmp/sys_vars.all_vars.txt" into table t1;
select variable_name as `There should be *no* variables listed below:`
from information_schema.global_variables
left join t1 on variable_name=test_name where
test_name is null
union
select variable_name from information_schema.session_variables
left join t1 on variable_name=test_name where
test_name is null;
insert into t2 select variable_name from information_schema.global_variables;
insert into t2 select variable_name from information_schema.session_variables;
# Performance schema variables are too long for files named
# 'mysql-test/suite/sys_vars/t/' ...
# ... 'performance_schema_events_waits_history_long_size_basic-master.opt'
# to fit in the tar source distribution (limit in old tar)
# Renaming the tests to aliases below.
update t2 set variable_name= replace(variable_name, "PERFORMANCE_SCHEMA_", "PFS_");
select variable_name as `There should be *no* long test name listed below:` from t2
where length(variable_name) > 50;
select variable_name as `There should be *no* variables listed below:` from t2
left join t1 on variable_name=test_name where test_name is null;
drop table t1;
drop table t2;

1
mysql-test/suite/sys_vars/t/performance_schema_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema

47
mysql-test/suite/sys_vars/t/performance_schema_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema;
show global variables like 'performance_schema';
show session variables like 'performance_schema';
select * from information_schema.global_variables
where variable_name='performance_schema';
select * from information_schema.session_variables
where variable_name='performance_schema';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema=1;

1
mysql-test/suite/sys_vars/t/pfs_events_waits_history_long_size_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema --loose-performance-schema-events-waits-history-long-size=15000

47
mysql-test/suite/sys_vars/t/pfs_events_waits_history_long_size_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema_events_waits_history_long_size;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema_events_waits_history_long_size;
show global variables like 'performance_schema_events_waits_history_long_size';
show session variables like 'performance_schema_events_waits_history_long_size';
select * from information_schema.global_variables
where variable_name='performance_schema_events_waits_history_long_size';
select * from information_schema.session_variables
where variable_name='performance_schema_events_waits_history_long_size';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema_events_waits_history_long_size=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema_events_waits_history_long_size=1;

1
mysql-test/suite/sys_vars/t/pfs_events_waits_history_size_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema --loose-performance-schema-events-waits-history-size=15

47
mysql-test/suite/sys_vars/t/pfs_events_waits_history_size_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema_events_waits_history_size;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema_events_waits_history_size;
show global variables like 'performance_schema_events_waits_history_size';
show session variables like 'performance_schema_events_waits_history_size';
select * from information_schema.global_variables
where variable_name='performance_schema_events_waits_history_size';
select * from information_schema.session_variables
where variable_name='performance_schema_events_waits_history_size';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema_events_waits_history_size=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema_events_waits_history_size=1;

1
mysql-test/suite/sys_vars/t/pfs_max_cond_classes_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema --loose-performance-schema-max-cond-classes=123

47
mysql-test/suite/sys_vars/t/pfs_max_cond_classes_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema_max_cond_classes;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema_max_cond_classes;
show global variables like 'performance_schema_max_cond_classes';
show session variables like 'performance_schema_max_cond_classes';
select * from information_schema.global_variables
where variable_name='performance_schema_max_cond_classes';
select * from information_schema.session_variables
where variable_name='performance_schema_max_cond_classes';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema_max_cond_classes=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema_max_cond_classes=1;

1
mysql-test/suite/sys_vars/t/pfs_max_cond_instances_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema --loose-performance-schema-max-cond-instances=123

47
mysql-test/suite/sys_vars/t/pfs_max_cond_instances_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema_max_cond_instances;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema_max_cond_instances;
show global variables like 'performance_schema_max_cond_instances';
show session variables like 'performance_schema_max_cond_instances';
select * from information_schema.global_variables
where variable_name='performance_schema_max_cond_instances';
select * from information_schema.session_variables
where variable_name='performance_schema_max_cond_instances';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema_max_cond_instances=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema_max_cond_instances=1;

1
mysql-test/suite/sys_vars/t/pfs_max_file_classes_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema --loose-performance-schema-max-file-classes=123

47
mysql-test/suite/sys_vars/t/pfs_max_file_classes_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema_max_file_classes;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema_max_file_classes;
show global variables like 'performance_schema_max_file_classes';
show session variables like 'performance_schema_max_file_classes';
select * from information_schema.global_variables
where variable_name='performance_schema_max_file_classes';
select * from information_schema.session_variables
where variable_name='performance_schema_max_file_classes';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema_max_file_classes=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema_max_file_classes=1;

1
mysql-test/suite/sys_vars/t/pfs_max_file_handles_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema --loose-performance-schema-max-file-handles=123

47
mysql-test/suite/sys_vars/t/pfs_max_file_handles_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema_max_file_handles;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema_max_file_handles;
show global variables like 'performance_schema_max_file_handles';
show session variables like 'performance_schema_max_file_handles';
select * from information_schema.global_variables
where variable_name='performance_schema_max_file_handles';
select * from information_schema.session_variables
where variable_name='performance_schema_max_file_handles';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema_max_file_handles=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema_max_file_handles=1;

1
mysql-test/suite/sys_vars/t/pfs_max_file_instances_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema --loose-performance-schema-max-file-instances=123

47
mysql-test/suite/sys_vars/t/pfs_max_file_instances_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema_max_file_instances;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema_max_file_instances;
show global variables like 'performance_schema_max_file_instances';
show session variables like 'performance_schema_max_file_instances';
select * from information_schema.global_variables
where variable_name='performance_schema_max_file_instances';
select * from information_schema.session_variables
where variable_name='performance_schema_max_file_instances';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema_max_file_instances=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema_max_file_instances=1;

1
mysql-test/suite/sys_vars/t/pfs_max_mutex_classes_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema --loose-performance-schema-max-mutex-classes=123

47
mysql-test/suite/sys_vars/t/pfs_max_mutex_classes_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema_max_mutex_classes;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema_max_mutex_classes;
show global variables like 'performance_schema_max_mutex_classes';
show session variables like 'performance_schema_max_mutex_classes';
select * from information_schema.global_variables
where variable_name='performance_schema_max_mutex_classes';
select * from information_schema.session_variables
where variable_name='performance_schema_max_mutex_classes';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema_max_mutex_classes=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema_max_mutex_classes=1;

1
mysql-test/suite/sys_vars/t/pfs_max_mutex_instances_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema --loose-performance-schema-max-mutex-instances=123

47
mysql-test/suite/sys_vars/t/pfs_max_mutex_instances_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema_max_mutex_instances;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema_max_mutex_instances;
show global variables like 'performance_schema_max_mutex_instances';
show session variables like 'performance_schema_max_mutex_instances';
select * from information_schema.global_variables
where variable_name='performance_schema_max_mutex_instances';
select * from information_schema.session_variables
where variable_name='performance_schema_max_mutex_instances';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema_max_mutex_instances=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema_max_mutex_instances=1;

1
mysql-test/suite/sys_vars/t/pfs_max_rwlock_classes_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema --loose-performance-schema-max-rwlock-classes=123

47
mysql-test/suite/sys_vars/t/pfs_max_rwlock_classes_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema_max_rwlock_classes;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema_max_rwlock_classes;
show global variables like 'performance_schema_max_rwlock_classes';
show session variables like 'performance_schema_max_rwlock_classes';
select * from information_schema.global_variables
where variable_name='performance_schema_max_rwlock_classes';
select * from information_schema.session_variables
where variable_name='performance_schema_max_rwlock_classes';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema_max_rwlock_classes=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema_max_rwlock_classes=1;

1
mysql-test/suite/sys_vars/t/pfs_max_rwlock_instances_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema --loose-performance-schema-max-rwlock-instances=123

47
mysql-test/suite/sys_vars/t/pfs_max_rwlock_instances_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema_max_rwlock_instances;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema_max_rwlock_instances;
show global variables like 'performance_schema_max_rwlock_instances';
show session variables like 'performance_schema_max_rwlock_instances';
select * from information_schema.global_variables
where variable_name='performance_schema_max_rwlock_instances';
select * from information_schema.session_variables
where variable_name='performance_schema_max_rwlock_instances';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema_max_rwlock_instances=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema_max_rwlock_instances=1;

1
mysql-test/suite/sys_vars/t/pfs_max_table_handles_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema --loose-performance-schema-max-table-handles=123

47
mysql-test/suite/sys_vars/t/pfs_max_table_handles_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema_max_table_handles;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema_max_table_handles;
show global variables like 'performance_schema_max_table_handles';
show session variables like 'performance_schema_max_table_handles';
select * from information_schema.global_variables
where variable_name='performance_schema_max_table_handles';
select * from information_schema.session_variables
where variable_name='performance_schema_max_table_handles';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema_max_table_handles=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema_max_table_handles=1;

1
mysql-test/suite/sys_vars/t/pfs_max_table_instances_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema --loose-performance-schema-max-table-instances=123

47
mysql-test/suite/sys_vars/t/pfs_max_table_instances_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema_max_table_instances;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema_max_table_instances;
show global variables like 'performance_schema_max_table_instances';
show session variables like 'performance_schema_max_table_instances';
select * from information_schema.global_variables
where variable_name='performance_schema_max_table_instances';
select * from information_schema.session_variables
where variable_name='performance_schema_max_table_instances';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema_max_table_instances=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema_max_table_instances=1;

1
mysql-test/suite/sys_vars/t/pfs_max_thread_classes_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema --loose-performance-schema-max-thread-classes=123

47
mysql-test/suite/sys_vars/t/pfs_max_thread_classes_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema_max_thread_classes;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema_max_thread_classes;
show global variables like 'performance_schema_max_thread_classes';
show session variables like 'performance_schema_max_thread_classes';
select * from information_schema.global_variables
where variable_name='performance_schema_max_thread_classes';
select * from information_schema.session_variables
where variable_name='performance_schema_max_thread_classes';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema_max_thread_classes=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema_max_thread_classes=1;

1
mysql-test/suite/sys_vars/t/pfs_max_thread_instances_basic-master.opt Normal file
View File

@ -0,0 +1 @@
--loose-enable-performance-schema --loose-performance-schema-max-thread-instances=123

47
mysql-test/suite/sys_vars/t/pfs_max_thread_instances_basic.test Normal file
View File

@ -0,0 +1,47 @@
# Copyright (C) 2010 Sun Microsystems, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--source include/not_embedded.inc
--source include/have_perfschema.inc
#
# Only global
#
select @@global.performance_schema_max_thread_instances;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
select @@session.performance_schema_max_thread_instances;
show global variables like 'performance_schema_max_thread_instances';
show session variables like 'performance_schema_max_thread_instances';
select * from information_schema.global_variables
where variable_name='performance_schema_max_thread_instances';
select * from information_schema.session_variables
where variable_name='performance_schema_max_thread_instances';
#
# Read-only
#
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set global performance_schema_max_thread_instances=1;
--error ER_INCORRECT_GLOBAL_LOCAL_VAR
set session performance_schema_max_thread_instances=1;

5
mysys/my_init.c
View File

@ -600,7 +600,7 @@ PSI_mutex_key key_BITMAP_mutex, key_IO_CACHE_append_buffer_lock,
key_THR_LOCK_isam, key_THR_LOCK_lock, key_THR_LOCK_malloc,
key_THR_LOCK_mutex, key_THR_LOCK_myisam, key_THR_LOCK_net,
key_THR_LOCK_open, key_THR_LOCK_threads, key_THR_LOCK_time,
key_TMPDIR_mutex;
key_TMPDIR_mutex, key_THR_LOCK_myisam_mmap;
static PSI_mutex_info all_mysys_mutexes[]=
{
@ -630,7 +630,8 @@ static PSI_mutex_info all_mysys_mutexes[]=
{ &key_THR_LOCK_open, "THR_LOCK_open", PSI_FLAG_GLOBAL},
{ &key_THR_LOCK_threads, "THR_LOCK_threads", PSI_FLAG_GLOBAL},
{ &key_THR_LOCK_time, "THR_LOCK_time", PSI_FLAG_GLOBAL},
{ &key_TMPDIR_mutex, "TMPDIR_mutex", PSI_FLAG_GLOBAL}
{ &key_TMPDIR_mutex, "TMPDIR_mutex", PSI_FLAG_GLOBAL},
{ &key_THR_LOCK_myisam_mmap, "THR_LOCK_myisam_mmap", PSI_FLAG_GLOBAL}
};
PSI_cond_key key_COND_alarm, key_IO_CACHE_SHARE_cond,

4
mysys/my_thr_init.c
View File

@ -24,8 +24,8 @@
#ifdef THREAD
pthread_key(struct st_my_thread_var*, THR_KEY_mysys);
mysql_mutex_t THR_LOCK_malloc,THR_LOCK_open,
THR_LOCK_lock,THR_LOCK_isam,THR_LOCK_myisam,THR_LOCK_heap,
mysql_mutex_t THR_LOCK_malloc, THR_LOCK_open,
THR_LOCK_lock, THR_LOCK_isam, THR_LOCK_myisam, THR_LOCK_heap,
THR_LOCK_net, THR_LOCK_charset, THR_LOCK_threads, THR_LOCK_time,
THR_LOCK_myisam_mmap;

2
mysys/mysys_priv.h
View File

@ -47,7 +47,7 @@ extern PSI_mutex_key key_BITMAP_mutex, key_IO_CACHE_append_buffer_lock,
key_THR_LOCK_isam, key_THR_LOCK_lock, key_THR_LOCK_malloc,
key_THR_LOCK_mutex, key_THR_LOCK_myisam, key_THR_LOCK_net,
key_THR_LOCK_open, key_THR_LOCK_threads, key_THR_LOCK_time,
key_TMPDIR_mutex;
key_TMPDIR_mutex, key_THR_LOCK_myisam_mmap;
extern PSI_cond_key key_COND_alarm, key_IO_CACHE_SHARE_cond,
key_IO_CACHE_SHARE_cond_writer, key_my_thread_var_suspend,

2
sql/authors.h
View File

@ -39,7 +39,7 @@ struct show_table_authors_st {
struct show_table_authors_st show_table_authors[]= {
{ "Brian (Krow) Aker", "Seattle, WA, USA",
"Architecture, archive, federated, bunch of little stuff :)" },
{ "Marc Alff", "Denver, CO, USA", "Signal, Resignal" },
{ "Marc Alff", "Denver, CO, USA", "Signal, Resignal, Performance schema" },
{ "Venu Anuganti", "", "Client/server protocol (4.1)" },
{ "David Axmark", "Uppsala, Sweden",
"Small stuff long time ago, Monty ripped it out!" },

30
sql/derror.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2000-2005 MySQL AB
/* Copyright (C) 2000-2005 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -107,10 +107,10 @@ bool read_texts(const char *file_name, const char *language,
funktpos=0;
convert_dirname(lang_path, language, NullS);
(void) my_load_path(lang_path, lang_path, lc_messages_dir);
if ((file=my_open(fn_format(name,file_name,
lang_path, "", 4),
O_RDONLY | O_SHARE | O_BINARY,
MYF(0))) < 0)
if ((file= mysql_file_open(key_file_ERRMSG,
fn_format(name, file_name, lang_path, "", 4),
O_RDONLY | O_SHARE | O_BINARY,
MYF(0))) < 0)
{
/*
Trying pre-5.4 sematics of the --language parameter.
@ -118,16 +118,18 @@ bool read_texts(const char *file_name, const char *language,
--language=/path/to/english/
*/
if ((file= my_open(fn_format(name, file_name, lc_messages_dir, "", 4),
O_RDONLY | O_SHARE | O_BINARY,
MYF(0))) < 0)
if ((file= mysql_file_open(key_file_ERRMSG,
fn_format(name, file_name, lc_messages_dir, "", 4),
O_RDONLY | O_SHARE | O_BINARY,
MYF(0))) < 0)
goto err;
sql_print_error("An old style --language value with language specific part detected: %s", lc_messages_dir);
sql_print_error("Use --lc-messages-dir without language specific part instead.");
}
funktpos=1;
if (my_read(file,(uchar*) head,32,MYF(MY_NABP))) goto err;
if (mysql_file_read(file, (uchar*) head, 32, MYF(MY_NABP)))
goto err;
if (head[0] != (uchar) 254 || head[1] != (uchar) 254 ||
head[2] != 2 || head[3] != 1)
goto err; /* purecov: inspected */
@ -143,7 +145,7 @@ Error message file '%s' had only %d error messages,\n\
but it should contain at least %d error messages.\n\
Check that the above file is the right version for this program!",
name,count,error_messages);
(void) my_close(file,MYF(MY_WME));
(void) mysql_file_close(file, MYF(MY_WME));
DBUG_RETURN(1);
}
@ -156,21 +158,21 @@ Check that the above file is the right version for this program!",
}
buff= (uchar*) (*point + count);
if (my_read(file, buff, (size_t) count*2,MYF(MY_NABP)))
if (mysql_file_read(file, buff, (size_t) count*2, MYF(MY_NABP)))
goto err;
for (i=0, pos= buff ; i< count ; i++)
{
(*point)[i]= (char*) buff+uint2korr(pos);
pos+=2;
}
if (my_read(file, buff, length, MYF(MY_NABP)))
if (mysql_file_read(file, buff, length, MYF(MY_NABP)))
goto err;
for (i=1 ; i < textcount ; i++)
{
point[i]= *point +uint2korr(head+10+i+i);
}
(void) my_close(file,MYF(0));
(void) mysql_file_close(file, MYF(0));
DBUG_RETURN(0);
err:
@ -187,7 +189,7 @@ err:
}
sql_print_error(errmsg, name);
if (file != FERR)
(void) my_close(file,MYF(MY_WME));
(void) mysql_file_close(file, MYF(MY_WME));
DBUG_RETURN(1);
} /* read_texts */

11
sql/des_key_file.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2001-2003, 2005 MySQL AB
/* Copyright (C) 2001-2003, 2005 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -43,8 +43,9 @@ load_des_key_file(const char *file_name)
DBUG_ENTER("load_des_key_file");
DBUG_PRINT("enter",("name: %s",file_name));
pthread_mutex_lock(&LOCK_des_key_file);
if ((file=my_open(file_name,O_RDONLY | O_BINARY ,MYF(MY_WME))) < 0 ||
mysql_mutex_lock(&LOCK_des_key_file);
if ((file= mysql_file_open(key_file_des_key_file, file_name,
O_RDONLY | O_BINARY, MYF(MY_WME))) < 0 ||
init_io_cache(&io, file, IO_SIZE*2, READ_CACHE, 0, 0, MYF(MY_WME)))
goto error;
@ -93,10 +94,10 @@ load_des_key_file(const char *file_name)
error:
if (file >= 0)
{
my_close(file,MYF(0));
mysql_file_close(file, MYF(0));
end_io_cache(&io);
}
pthread_mutex_unlock(&LOCK_des_key_file);
mysql_mutex_unlock(&LOCK_des_key_file);
DBUG_RETURN(result);
}
#endif /* HAVE_OPENSSL */

27
sql/discover.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2004 MySQL AB
/* Copyright (C) 2004 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -57,15 +57,16 @@ int readfrm(const char *name, uchar **frmdata, size_t *len)
*frmdata= NULL; // In case of errors
*len= 0;
error= 1;
if ((file=my_open(fn_format(index_file,name,"",reg_ext,
MY_UNPACK_FILENAME|MY_APPEND_EXT),
O_RDONLY | O_SHARE,
MYF(0))) < 0)
if ((file= mysql_file_open(key_file_frm,
fn_format(index_file, name, "", reg_ext,
MY_UNPACK_FILENAME|MY_APPEND_EXT),
O_RDONLY | O_SHARE,
MYF(0))) < 0)
goto err_end;
// Get length of file
error= 2;
if (my_fstat(file, &state, MYF(0)))
if (mysql_file_fstat(file, &state, MYF(0)))
goto err;
read_len= state.st_size;
@ -82,7 +83,7 @@ int readfrm(const char *name, uchar **frmdata, size_t *len)
err:
if (file > 0)
(void) my_close(file,MYF(MY_WME));
(void) mysql_file_close(file, MYF(MY_WME));
err_end: /* Here when no file */
DBUG_RETURN (error);
@ -112,13 +113,15 @@ int writefrm(const char *name, const uchar *frmdata, size_t len)
DBUG_PRINT("enter",("name: '%s' len: %lu ",name, (ulong) len));
error= 0;
if ((file=my_create(fn_format(index_file,name,"",reg_ext,
MY_UNPACK_FILENAME|MY_APPEND_EXT),
CREATE_MODE,O_RDWR | O_TRUNC,MYF(MY_WME))) >= 0)
if ((file= mysql_file_create(key_file_frm,
fn_format(index_file, name, "", reg_ext,
MY_UNPACK_FILENAME | MY_APPEND_EXT),
CREATE_MODE, O_RDWR | O_TRUNC,
MYF(MY_WME))) >= 0)
{
if (my_write(file, frmdata, len,MYF(MY_WME | MY_NABP)))
if (mysql_file_write(file, frmdata, len, MYF(MY_WME | MY_NABP)))
error= 2;
(void) my_close(file,MYF(0));
(void) mysql_file_close(file, MYF(0));
}
DBUG_RETURN(error);
} /* writefrm */

5
sql/event_data_objects.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2004-2006 MySQL AB
/* Copyright (C) 2004-2006 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -1402,8 +1402,7 @@ Event_job_data::execute(THD *thd, bool drop)
}
#endif
if (check_access(thd, EVENT_ACL, dbname.str,
0, 0, 0, is_schema_db(dbname.str)))
if (check_access(thd, EVENT_ACL, dbname.str, NULL, NULL, 0, 0))
{
/*
This aspect of behavior is defined in the worklog,

22
sql/event_queue.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2004-2006 MySQL AB
/* Copyright (C) 2004-2006 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -94,16 +94,16 @@ Event_queue::Event_queue()
mutex_queue_data_attempting_lock(FALSE),
waiting_on_cond(FALSE)
{
pthread_mutex_init(&LOCK_event_queue, MY_MUTEX_INIT_FAST);
pthread_cond_init(&COND_queue_state, NULL);
mysql_mutex_init(key_LOCK_event_queue, &LOCK_event_queue, MY_MUTEX_INIT_FAST);
mysql_cond_init(key_COND_queue_state, &COND_queue_state, NULL);
}
Event_queue::~Event_queue()
{
deinit_queue();
pthread_mutex_destroy(&LOCK_event_queue);
pthread_cond_destroy(&COND_queue_state);
mysql_mutex_destroy(&LOCK_event_queue);
mysql_cond_destroy(&COND_queue_state);
}
@ -210,7 +210,7 @@ Event_queue::create_event(THD *thd, Event_queue_element *new_element,
LOCK_QUEUE_DATA();
*created= (queue_insert_safe(&queue, (uchar *) new_element) == FALSE);
dbug_dump_queue(thd->query_start());
pthread_cond_broadcast(&COND_queue_state);
mysql_cond_broadcast(&COND_queue_state);
UNLOCK_QUEUE_DATA();
DBUG_RETURN(!*created);
@ -258,7 +258,7 @@ Event_queue::update_event(THD *thd, LEX_STRING dbname, LEX_STRING name,
{
DBUG_PRINT("info", ("new event in the queue: 0x%lx", (long) new_element));
queue_insert_safe(&queue, (uchar *) new_element);
pthread_cond_broadcast(&COND_queue_state);
mysql_cond_broadcast(&COND_queue_state);
}
dbug_dump_queue(thd->query_start());
@ -669,7 +669,7 @@ Event_queue::lock_data(const char *func, uint line)
mutex_last_attempted_lock_in_func= func;
mutex_last_attempted_lock_at_line= line;
mutex_queue_data_attempting_lock= TRUE;
pthread_mutex_lock(&LOCK_event_queue);
mysql_mutex_lock(&LOCK_event_queue);
mutex_last_attempted_lock_in_func= "";
mutex_last_attempted_lock_at_line= 0;
mutex_queue_data_attempting_lock= FALSE;
@ -700,7 +700,7 @@ Event_queue::unlock_data(const char *func, uint line)
mutex_last_unlocked_at_line= line;
mutex_queue_data_locked= FALSE;
mutex_last_unlocked_in_func= func;
pthread_mutex_unlock(&LOCK_event_queue);
mysql_mutex_unlock(&LOCK_event_queue);
DBUG_VOID_RETURN;
}
@ -731,9 +731,9 @@ Event_queue::cond_wait(THD *thd, struct timespec *abstime, const char* msg,
DBUG_PRINT("info", ("pthread_cond_%swait", abstime? "timed":""));
if (!abstime)
pthread_cond_wait(&COND_queue_state, &LOCK_event_queue);
mysql_cond_wait(&COND_queue_state, &LOCK_event_queue);
else
pthread_cond_timedwait(&COND_queue_state, &LOCK_event_queue, abstime);
mysql_cond_timedwait(&COND_queue_state, &LOCK_event_queue, abstime);
mutex_last_locked_in_func= func;
mutex_last_locked_at_line= line;

11
sql/event_queue.h
View File

@ -1,6 +1,6 @@
#ifndef _EVENT_QUEUE_H_
#define _EVENT_QUEUE_H_
/* Copyright (C) 2004-2006 MySQL AB
/* Copyright (C) 2004-2006 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -25,6 +25,11 @@
Queue of events awaiting execution.
*/
#ifdef HAVE_PSI_INTERFACE
extern PSI_mutex_key key_LOCK_event_queue;
extern PSI_cond_key key_COND_queue_state;
#endif /* HAVE_PSI_INTERFACE */
class Event_basic;
class Event_queue_element;
class Event_queue_element_for_exec;
@ -101,8 +106,8 @@ private:
dbug_dump_queue(time_t now);
/* LOCK_event_queue is the mutex which protects the access to the queue. */
pthread_mutex_t LOCK_event_queue;
pthread_cond_t COND_queue_state;
mysql_mutex_t LOCK_event_queue;
mysql_cond_t COND_queue_state;
/* The sorted queue with the Event_queue_element objects */
QUEUE queue;

42
sql/event_scheduler.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2004-2006 MySQL AB
/* Copyright (C) 2004-2006 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -163,7 +163,7 @@ deinit_event_thread(THD *thd)
/*
Performs pre- pthread_create() initialisation of THD. Do this
Performs pre- mysql_thread_create() initialisation of THD. Do this
in the thread that will pass THD to the child thread. In the
child thread call post_init_event_thread().
@ -227,6 +227,9 @@ event_scheduler_thread(void *arg)
bool res;
thd->thread_stack= (char *)&thd; // remember where our stack is
mysql_thread_set_psi_id(thd->thread_id);
res= post_init_event_thread(thd);
DBUG_ENTER("event_scheduler_thread");
@ -259,6 +262,8 @@ event_worker_thread(void *arg)
thd= event->thd;
mysql_thread_set_psi_id(thd->thread_id);
Event_worker_thread worker_thread;
worker_thread.run(thd, event);
@ -335,16 +340,17 @@ Event_scheduler::Event_scheduler(Event_queue *queue_arg)
waiting_on_cond(FALSE),
started_events(0)
{
pthread_mutex_init(&LOCK_scheduler_state, MY_MUTEX_INIT_FAST);
pthread_cond_init(&COND_state, NULL);
mysql_mutex_init(key_event_scheduler_LOCK_scheduler_state,
&LOCK_scheduler_state, MY_MUTEX_INIT_FAST);
mysql_cond_init(key_event_scheduler_COND_state, &COND_state, NULL);
}
Event_scheduler::~Event_scheduler()
{
stop(); /* does nothing if not running */
pthread_mutex_destroy(&LOCK_scheduler_state);
pthread_cond_destroy(&COND_state);
mysql_mutex_destroy(&LOCK_scheduler_state);
mysql_cond_destroy(&COND_state);
}
@ -403,8 +409,9 @@ Event_scheduler::start()
DBUG_PRINT("info", ("Setting state go RUNNING"));
state= RUNNING;
DBUG_PRINT("info", ("Forking new thread for scheduler. THD: 0x%lx", (long) new_thd));
if (pthread_create(&th, &connection_attrib, event_scheduler_thread,
(void*)scheduler_param_value))
if (mysql_thread_create(key_thread_event_scheduler,
&th, &connection_attrib, event_scheduler_thread,
(void*)scheduler_param_value))
{
DBUG_PRINT("error", ("cannot create a new thread"));
state= INITIALIZED;
@ -487,7 +494,7 @@ Event_scheduler::run(THD *thd)
scheduler_thd= NULL;
state= INITIALIZED;
DBUG_PRINT("info", ("Signalling back to the stopper COND_state"));
pthread_cond_signal(&COND_state);
mysql_cond_signal(&COND_state);
UNLOCK_DATA();
DBUG_RETURN(res);
@ -531,8 +538,9 @@ Event_scheduler::execute_top(Event_queue_element_for_exec *event_name)
reasonable level.
*/
/* Major failure */
if ((res= pthread_create(&th, &connection_attrib, event_worker_thread,
event_name)))
if ((res= mysql_thread_create(key_thread_event_worker,
&th, &connection_attrib, event_worker_thread,
event_name)))
goto error;
++started_events;
@ -632,13 +640,13 @@ Event_scheduler::stop()
DBUG_PRINT("info", ("Scheduler thread has id %lu",
scheduler_thd->thread_id));
/* Lock from delete */
pthread_mutex_lock(&scheduler_thd->LOCK_thd_data);
mysql_mutex_lock(&scheduler_thd->LOCK_thd_data);
/* This will wake up the thread if it waits on Queue's conditional */
sql_print_information("Event Scheduler: Killing the scheduler thread, "
"thread id %lu",
scheduler_thd->thread_id);
scheduler_thd->awake(THD::KILL_CONNECTION);
pthread_mutex_unlock(&scheduler_thd->LOCK_thd_data);
mysql_mutex_unlock(&scheduler_thd->LOCK_thd_data);
/* thd could be 0x0, when shutting down */
sql_print_information("Event Scheduler: "
@ -693,7 +701,7 @@ Event_scheduler::lock_data(const char *func, uint line)
{
DBUG_ENTER("Event_scheduler::lock_data");
DBUG_PRINT("enter", ("func=%s line=%u", func, line));
pthread_mutex_lock(&LOCK_scheduler_state);
mysql_mutex_lock(&LOCK_scheduler_state);
mutex_last_locked_in_func= func;
mutex_last_locked_at_line= line;
mutex_scheduler_data_locked= TRUE;
@ -719,7 +727,7 @@ Event_scheduler::unlock_data(const char *func, uint line)
mutex_last_unlocked_at_line= line;
mutex_scheduler_data_locked= FALSE;
mutex_last_unlocked_in_func= func;
pthread_mutex_unlock(&LOCK_scheduler_state);
mysql_mutex_unlock(&LOCK_scheduler_state);
DBUG_VOID_RETURN;
}
@ -750,9 +758,9 @@ Event_scheduler::cond_wait(THD *thd, struct timespec *abstime, const char* msg,
DBUG_PRINT("info", ("pthread_cond_%swait", abstime? "timed":""));
if (!abstime)
pthread_cond_wait(&COND_state, &LOCK_scheduler_state);
mysql_cond_wait(&COND_state, &LOCK_scheduler_state);
else
pthread_cond_timedwait(&COND_state, &LOCK_scheduler_state, abstime);
mysql_cond_timedwait(&COND_state, &LOCK_scheduler_state, abstime);
if (thd)
{
/*

6
sql/event_scheduler.h
View File

@ -1,6 +1,6 @@
#ifndef _EVENT_SCHEDULER_H_
#define _EVENT_SCHEDULER_H_
/* Copyright (C) 2004-2006 MySQL AB
/* Copyright (C) 2004-2006 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -115,7 +115,7 @@ private:
cond_wait(THD *thd, struct timespec *abstime, const char* msg,
const char *func, uint line);
pthread_mutex_t LOCK_scheduler_state;
mysql_mutex_t LOCK_scheduler_state;
enum enum_state
{
@ -129,7 +129,7 @@ private:
THD *scheduler_thd;
pthread_cond_t COND_state;
mysql_cond_t COND_state;
Event_queue *queue;

98
sql/events.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2004-2006 MySQL AB
/* Copyright (C) 2004-2006 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -68,7 +68,7 @@ Event_queue *Events::event_queue;
Event_scheduler *Events::scheduler;
Event_db_repository *Events::db_repository;
uint Events::opt_event_scheduler= Events::EVENTS_OFF;
pthread_mutex_t Events::LOCK_event_metadata;
mysql_mutex_t Events::LOCK_event_metadata;
bool Events::check_system_tables_error= FALSE;
@ -319,8 +319,7 @@ Events::create_event(THD *thd, Event_parse_data *parse_data,
/* At create, one of them must be set */
DBUG_ASSERT(parse_data->expression || parse_data->execute_at);
if (check_access(thd, EVENT_ACL, parse_data->dbname.str, 0, 0, 0,
is_schema_db(parse_data->dbname.str)))
if (check_access(thd, EVENT_ACL, parse_data->dbname.str, NULL, NULL, 0, 0))
DBUG_RETURN(TRUE);
if (check_db_dir_existence(parse_data->dbname.str))
@ -338,7 +337,7 @@ Events::create_event(THD *thd, Event_parse_data *parse_data,
if (thd->current_stmt_binlog_row_based)
thd->clear_current_stmt_binlog_row_based();
pthread_mutex_lock(&LOCK_event_metadata);
mysql_mutex_lock(&LOCK_event_metadata);
/* On error conditions my_error() is called so no need to handle here */
if (!(ret= db_repository->create_event(thd, parse_data, if_not_exists)))
@ -383,7 +382,7 @@ Events::create_event(THD *thd, Event_parse_data *parse_data,
ret= write_bin_log(thd, TRUE, log_query.c_ptr(), log_query.length());
}
}
pthread_mutex_unlock(&LOCK_event_metadata);
mysql_mutex_unlock(&LOCK_event_metadata);
DBUG_RETURN(ret);
}
@ -430,8 +429,7 @@ Events::update_event(THD *thd, Event_parse_data *parse_data,
if (parse_data->check_parse_data(thd) || parse_data->do_not_create)
DBUG_RETURN(TRUE);
if (check_access(thd, EVENT_ACL, parse_data->dbname.str, 0, 0, 0,
is_schema_db(parse_data->dbname.str)))
if (check_access(thd, EVENT_ACL, parse_data->dbname.str, NULL, NULL, 0, 0))
DBUG_RETURN(TRUE);
if (new_dbname) /* It's a rename */
@ -452,8 +450,7 @@ Events::update_event(THD *thd, Event_parse_data *parse_data,
to tell the user that a database doesn't exist if they can not
access it.
*/
if (check_access(thd, EVENT_ACL, new_dbname->str, 0, 0, 0,
is_schema_db(new_dbname->str)))
if (check_access(thd, EVENT_ACL, new_dbname->str, NULL, NULL, 0, 0))
DBUG_RETURN(TRUE);
/* Check that the target database exists */
@ -471,7 +468,7 @@ Events::update_event(THD *thd, Event_parse_data *parse_data,
if (thd->current_stmt_binlog_row_based)
thd->clear_current_stmt_binlog_row_based();
pthread_mutex_lock(&LOCK_event_metadata);
mysql_mutex_lock(&LOCK_event_metadata);
/* On error conditions my_error() is called so no need to handle here */
if (!(ret= db_repository->update_event(thd, parse_data,
@ -504,7 +501,7 @@ Events::update_event(THD *thd, Event_parse_data *parse_data,
ret= write_bin_log(thd, TRUE, thd->query(), thd->query_length());
}
}
pthread_mutex_unlock(&LOCK_event_metadata);
mysql_mutex_unlock(&LOCK_event_metadata);
DBUG_RETURN(ret);
}
@ -557,8 +554,7 @@ Events::drop_event(THD *thd, LEX_STRING dbname, LEX_STRING name, bool if_exists)
if (check_if_system_tables_error())
DBUG_RETURN(TRUE);
if (check_access(thd, EVENT_ACL, dbname.str, 0, 0, 0,
is_schema_db(dbname.str)))
if (check_access(thd, EVENT_ACL, dbname.str, NULL, NULL, 0, 0))
DBUG_RETURN(TRUE);
/*
@ -568,7 +564,7 @@ Events::drop_event(THD *thd, LEX_STRING dbname, LEX_STRING name, bool if_exists)
if (thd->current_stmt_binlog_row_based)
thd->clear_current_stmt_binlog_row_based();
pthread_mutex_lock(&LOCK_event_metadata);
mysql_mutex_lock(&LOCK_event_metadata);
/* On error conditions my_error() is called so no need to handle here */
if (!(ret= db_repository->drop_event(thd, dbname, name, if_exists)))
{
@ -578,7 +574,7 @@ Events::drop_event(THD *thd, LEX_STRING dbname, LEX_STRING name, bool if_exists)
DBUG_ASSERT(thd->query() && thd->query_length());
ret= write_bin_log(thd, TRUE, thd->query(), thd->query_length());
}
pthread_mutex_unlock(&LOCK_event_metadata);
mysql_mutex_unlock(&LOCK_event_metadata);
DBUG_RETURN(ret);
}
@ -607,11 +603,11 @@ Events::drop_schema_events(THD *thd, char *db)
are damaged, as intended.
*/
pthread_mutex_lock(&LOCK_event_metadata);
mysql_mutex_lock(&LOCK_event_metadata);
if (event_queue)
event_queue->drop_schema_events(thd, db_lex);
db_repository->drop_schema_events(thd, db_lex);
pthread_mutex_unlock(&LOCK_event_metadata);
mysql_mutex_unlock(&LOCK_event_metadata);
DBUG_VOID_RETURN;
}
@ -714,8 +710,7 @@ Events::show_create_event(THD *thd, LEX_STRING dbname, LEX_STRING name)
if (check_if_system_tables_error())
DBUG_RETURN(TRUE);
if (check_access(thd, EVENT_ACL, dbname.str, 0, 0, 0,
is_schema_db(dbname.str)))
if (check_access(thd, EVENT_ACL, dbname.str, NULL, NULL, 0, 0))
DBUG_RETURN(TRUE);
/*
@ -773,8 +768,9 @@ Events::fill_schema_events(THD *thd, TABLE_LIST *tables, COND * /* cond */)
if (thd->lex->sql_command == SQLCOM_SHOW_EVENTS)
{
DBUG_ASSERT(thd->lex->select_lex.db);
if (!is_schema_db(thd->lex->select_lex.db) && // There is no events in I_S
check_access(thd, EVENT_ACL, thd->lex->select_lex.db, 0, 0, 0, 0))
if (!is_infoschema_db(thd->lex->select_lex.db) && // There is no events in I_S
check_access(thd, EVENT_ACL, thd->lex->select_lex.db,
NULL, NULL, 0, 0))
DBUG_RETURN(1);
db= thd->lex->select_lex.db;
}
@ -934,6 +930,51 @@ Events::deinit()
DBUG_VOID_RETURN;
}
#ifdef HAVE_PSI_INTERFACE
PSI_mutex_key key_LOCK_event_metadata, key_LOCK_event_queue,
key_event_scheduler_LOCK_scheduler_state;
static PSI_mutex_info all_events_mutexes[]=
{
{ &key_LOCK_event_metadata, "LOCK_event_metadata", PSI_FLAG_GLOBAL},
{ &key_LOCK_event_queue, "LOCK_event_queue", PSI_FLAG_GLOBAL},
{ &key_event_scheduler_LOCK_scheduler_state, "Event_scheduler::LOCK_scheduler_state", PSI_FLAG_GLOBAL}
};
PSI_cond_key key_event_scheduler_COND_state, key_COND_queue_state;
static PSI_cond_info all_events_conds[]=
{
{ &key_event_scheduler_COND_state, "Event_scheduler::COND_state", PSI_FLAG_GLOBAL},
{ &key_COND_queue_state, "COND_queue_state", PSI_FLAG_GLOBAL},
};
PSI_thread_key key_thread_event_scheduler, key_thread_event_worker;
static PSI_thread_info all_events_threads[]=
{
{ &key_thread_event_scheduler, "event_scheduler", PSI_FLAG_GLOBAL},
{ &key_thread_event_worker, "event_worker", 0}
};
static void init_events_psi_keys(void)
{
const char* category= "sql";
int count;
if (PSI_server == NULL)
return;
count= array_elements(all_events_mutexes);
PSI_server->register_mutex(category, all_events_mutexes, count);
count= array_elements(all_events_conds);
PSI_server->register_cond(category, all_events_conds, count);
count= array_elements(all_events_threads);
PSI_server->register_thread(category, all_events_threads, count);
}
#endif /* HAVE_PSI_INTERFACE */
/**
Inits Events mutexes
@ -946,7 +987,12 @@ Events::deinit()
void
Events::init_mutexes()
{
pthread_mutex_init(&LOCK_event_metadata, MY_MUTEX_INIT_FAST);
#ifdef HAVE_PSI_INTERFACE
init_events_psi_keys();
#endif
mysql_mutex_init(key_LOCK_event_metadata,
&LOCK_event_metadata, MY_MUTEX_INIT_FAST);
}
@ -960,7 +1006,7 @@ Events::init_mutexes()
void
Events::destroy_mutexes()
{
pthread_mutex_destroy(&LOCK_event_metadata);
mysql_mutex_destroy(&LOCK_event_metadata);
}
@ -982,7 +1028,7 @@ Events::dump_internal_status()
puts("LLA = Last Locked At LUA = Last Unlocked At");
puts("WOC = Waiting On Condition DL = Data Locked");
pthread_mutex_lock(&LOCK_event_metadata);
mysql_mutex_lock(&LOCK_event_metadata);
if (opt_event_scheduler == EVENTS_DISABLED)
puts("The Event Scheduler is disabled");
else
@ -991,7 +1037,7 @@ Events::dump_internal_status()
event_queue->dump_internal_status();
}
pthread_mutex_unlock(&LOCK_event_metadata);
mysql_mutex_unlock(&LOCK_event_metadata);
DBUG_VOID_RETURN;
}

11
sql/events.h
View File

@ -1,6 +1,6 @@
#ifndef _EVENT_H_
#define _EVENT_H_
/* Copyright (C) 2004-2006 MySQL AB
/* Copyright (C) 2004-2006 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -25,6 +25,13 @@
A public interface of Events_Scheduler module.
*/
#ifdef HAVE_PSI_INTERFACE
extern PSI_mutex_key key_LOCK_event_metadata,
key_event_scheduler_LOCK_scheduler_state;
extern PSI_cond_key key_event_scheduler_COND_state;
extern PSI_thread_key key_thread_event_scheduler, key_thread_event_worker;
#endif /* HAVE_PSI_INTERFACE */
class Event_parse_data;
class Event_db_repository;
class Event_queue;
@ -77,7 +84,7 @@ public:
*/
enum enum_opt_event_scheduler { EVENTS_OFF, EVENTS_ON, EVENTS_DISABLED };
static uint opt_event_scheduler;
static pthread_mutex_t LOCK_event_metadata;
static mysql_mutex_t LOCK_event_metadata;
static bool check_if_system_tables_error();
static bool start();
static bool stop();

7
sql/filesort.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2000-2006 MySQL AB
/* Copyright (C) 2000-2006 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -1119,8 +1119,9 @@ uint read_to_buffer(IO_CACHE *fromfile, BUFFPEK *buffpek,
if ((count=(uint) min((ha_rows) buffpek->max_keys,buffpek->count)))
{
if (my_pread(fromfile->file,(uchar*) buffpek->base,
(length= rec_length*count),buffpek->file_pos,MYF_RW))
if (mysql_file_pread(fromfile->file, (uchar*) buffpek->base,
(length= rec_length*count),
buffpek->file_pos, MYF_RW))
return((uint) -1); /* purecov: inspected */
buffpek->key=buffpek->base;
buffpek->file_pos+= length; /* New filepos */

295
sql/ha_ndbcluster.cc
View File

@ -264,7 +264,7 @@ Ndb_cluster_connection* g_ndb_cluster_connection= NULL;
uchar g_node_id_map[max_ndb_nodes];
/// Handler synchronization
pthread_mutex_t ndbcluster_mutex;
mysql_mutex_t ndbcluster_mutex;
/// Table lock handling
HASH ndbcluster_open_tables;
@ -281,9 +281,9 @@ static int ndb_get_table_statistics(ha_ndbcluster*, bool, Ndb*, const NDBTAB *,
// Util thread variables
pthread_t ndb_util_thread;
int ndb_util_thread_running= 0;
pthread_mutex_t LOCK_ndb_util_thread;
pthread_cond_t COND_ndb_util_thread;
pthread_cond_t COND_ndb_util_ready;
mysql_mutex_t LOCK_ndb_util_thread;
mysql_cond_t COND_ndb_util_thread;
mysql_cond_t COND_ndb_util_ready;
pthread_handler_t ndb_util_thread_func(void *arg);
/**
@ -4778,11 +4778,11 @@ int ha_ndbcluster::external_lock(THD *thd, int lock_type)
thd_ndb->changed_tables.push_back(m_share, &thd->transaction.mem_root);
}
pthread_mutex_lock(&m_share->mutex);
mysql_mutex_lock(&m_share->mutex);
DBUG_PRINT("info", ("Invalidating commit_count"));
m_share->commit_count= 0;
m_share->commit_count_lock++;
pthread_mutex_unlock(&m_share->mutex);
mysql_mutex_unlock(&m_share->mutex);
}
if (!--thd_ndb->lock_count)
@ -4943,12 +4943,12 @@ static int ndbcluster_commit(handlerton *hton, THD *thd, bool all)
List_iterator_fast<NDB_SHARE> it(thd_ndb->changed_tables);
while ((share= it++))
{
pthread_mutex_lock(&share->mutex);
mysql_mutex_lock(&share->mutex);
DBUG_PRINT("info", ("Invalidate commit_count for %s, share->commit_count: %lu",
share->table_name, (ulong) share->commit_count));
share->commit_count= 0;
share->commit_count_lock++;
pthread_mutex_unlock(&share->mutex);
mysql_mutex_unlock(&share->mutex);
}
thd_ndb->changed_tables.empty();
@ -5622,7 +5622,7 @@ int ha_ndbcluster::create(const char *name,
if (!my_errno)
{
NDB_SHARE *share= 0;
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
/*
First make sure we get a "fresh" share here, not an old trailing one...
*/
@ -5647,7 +5647,7 @@ int ha_ndbcluster::create(const char *name,
DBUG_PRINT("NDB_SHARE", ("%s binlog create use_count: %u",
share->key, share->use_count));
}
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
while (!IS_TMP_PREFIX(m_tabname))
{
@ -6286,7 +6286,7 @@ retry_temporary_error1:
/* the drop table failed for some reason, drop the share anyways */
if (share)
{
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
if (share->state != NSS_DROPPED)
{
/*
@ -6302,7 +6302,7 @@ retry_temporary_error1:
DBUG_PRINT("NDB_SHARE", ("%s temporary free use_count: %u",
share->key, share->use_count));
free_share(&share, TRUE);
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
}
#endif
DBUG_RETURN(res);
@ -6343,7 +6343,7 @@ retry_temporary_error1:
if (share)
{
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
if (share->state != NSS_DROPPED)
{
/*
@ -6359,7 +6359,7 @@ retry_temporary_error1:
DBUG_PRINT("NDB_SHARE", ("%s temporary free use_count: %u",
share->key, share->use_count));
free_share(&share, TRUE);
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
}
#endif
DBUG_RETURN(0);
@ -7451,7 +7451,7 @@ int ndbcluster_find_files(handlerton *hton, THD *thd,
/* Call back after cluster connect */
static int connect_callback()
{
pthread_mutex_lock(&LOCK_ndb_util_thread);
mysql_mutex_lock(&LOCK_ndb_util_thread);
update_status_variables(g_ndb_cluster_connection);
uint node_id, i= 0;
@ -7460,13 +7460,92 @@ static int connect_callback()
while ((node_id= g_ndb_cluster_connection->get_next_node(node_iter)))
g_node_id_map[node_id]= i++;
pthread_cond_signal(&COND_ndb_util_thread);
pthread_mutex_unlock(&LOCK_ndb_util_thread);
mysql_cond_signal(&COND_ndb_util_thread);
mysql_mutex_unlock(&LOCK_ndb_util_thread);
return 0;
}
extern int ndb_dictionary_is_mysqld;
extern pthread_mutex_t LOCK_plugin;
extern mysql_mutex_t LOCK_plugin;
#ifdef HAVE_PSI_INTERFACE
#ifdef HAVE_NDB_BINLOG
PSI_mutex_key key_injector_mutex, key_ndb_schema_share_mutex,
key_ndb_schema_object_mutex;
#endif /* HAVE_NDB_BINLOG */
PSI_mutex_key key_NDB_SHARE_mutex, key_ndbcluster_mutex,
key_LOCK_ndb_util_thread;
static PSI_mutex_info all_ndbcluster_mutexes[]=
{
#ifdef HAVE_NDB_BINLOG
{& key_injector_mutex, "injector_mutex", PSI_FLAG_GLOBAL},
{& key_ndb_schema_share_mutex, "ndb_schema_share_mutex", PSI_FLAG_GLOBAL},
{& key_ndb_schema_object_mutex, "ndb_schema_object_mutex", PSI_FLAG_GLOBAL},
#endif /* HAVE_NDB_BINLOG */
{& key_NDB_SHARE_mutex, "NDB_SHARE::mutex", PSI_FLAG_GLOBAL},
{& key_ndbcluster_mutex, "ndbcluster_mutex", PSI_FLAG_GLOBAL},
{& key_LOCK_ndb_util_thread, "LOCK_ndb_util_thread", PSI_FLAG_GLOBAL}
};
#ifdef HAVE_NDB_BINLOG
PSI_cond_key key_injector_cond;
#endif /* HAVE_NDB_BINLOG */
PSI_cond_key key_COND_ndb_util_thread, key_COND_ndb_util_ready;
static PSI_cond_info all_ndbcluster_conds[]=
{
#ifdef HAVE_NDB_BINLOG
{& key_injector_cond, "injector_cond", PSI_FLAG_GLOBAL},
#endif /* HAVE_NDB_BINLOG */
{& key_COND_ndb_util_thread, "COND_ndb_util_thread", PSI_FLAG_GLOBAL},
{& key_COND_ndb_util_ready, "COND_ndb_util_ready", PSI_FLAG_GLOBAL}
};
#ifdef HAVE_NDB_BINLOG
PSI_thread_key key_thread_ndb_binlog;
#endif /* HAVE_NDB_BINLOG */
PSI_thread_key key_thread_ndb_util;
static PSI_thread_info all_ndbcluster_threads[]=
{
#ifdef HAVE_NDB_BINLOG
{ &key_thread_ndb_binlog, "ndb_binlog", PSI_FLAG_GLOBAL},
#endif /* HAVE_NDB_BINLOG */
{ &key_thread_ndb_util, "ndb_util", PSI_FLAG_GLOBAL}
};
PSI_file_key key_file_ndb;
static PSI_file_info all_ndbcluster_files[]=
{
{ &key_file_ndb, "ndb", 0}
};
void init_ndbcluster_psi_keys()
{
const char* category= "ndbcluster";
int count;
if (PSI_server == NULL)
return;
count= array_elements(all_ndbcluster_mutexes);
PSI_server->register_mutex(category, all_ndbcluster_mutexes, count);
count= array_elements(all_ndbcluster_conds);
PSI_server->register_cond(category, all_ndbcluster_conds, count);
count= array_elements(all_ndbcluster_threads);
PSI_server->register_thread(category, all_ndbcluster_threads, count);
count= array_elements(all_ndbcluster_files);
PSI_server->register_file(category, all_ndbcluster_files, count);
}
#endif /* HAVE_PSI_INTERFACE */
static int ndbcluster_init(void *p)
{
@ -7476,17 +7555,23 @@ static int ndbcluster_init(void *p)
if (ndbcluster_inited)
DBUG_RETURN(FALSE);
#ifdef HAVE_PSI_INTERFACE
init_ndbcluster_psi_keys();
#endif
/*
Below we create new THD's. They'll need LOCK_plugin, but it's taken now by
plugin initialization code. Release it to avoid deadlocks. It's safe, as
there're no threads that may concurrently access plugin control structures.
*/
pthread_mutex_unlock(&LOCK_plugin);
mysql_mutex_unlock(&LOCK_plugin);
pthread_mutex_init(&ndbcluster_mutex,MY_MUTEX_INIT_FAST);
pthread_mutex_init(&LOCK_ndb_util_thread, MY_MUTEX_INIT_FAST);
pthread_cond_init(&COND_ndb_util_thread, NULL);
pthread_cond_init(&COND_ndb_util_ready, NULL);
mysql_mutex_init(key_ndbcluster_mutex,
&ndbcluster_mutex, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_LOCK_ndb_util_thread,
&LOCK_ndb_util_thread, MY_MUTEX_INIT_FAST);
mysql_cond_init(key_COND_ndb_util_thread, &COND_ndb_util_thread, NULL);
mysql_cond_init(key_COND_ndb_util_ready, &COND_ndb_util_ready, NULL);
ndb_util_thread_running= -1;
ndbcluster_terminating= 0;
ndb_dictionary_is_mysqld= 1;
@ -7608,35 +7693,36 @@ static int ndbcluster_init(void *p)
// Create utility thread
pthread_t tmp;
if (pthread_create(&tmp, &connection_attrib, ndb_util_thread_func, 0))
if (mysql_thread_create(key_thread_ndb_util,
&tmp, &connection_attrib, ndb_util_thread_func, 0))
{
DBUG_PRINT("error", ("Could not create ndb utility thread"));
my_hash_free(&ndbcluster_open_tables);
pthread_mutex_destroy(&ndbcluster_mutex);
pthread_mutex_destroy(&LOCK_ndb_util_thread);
pthread_cond_destroy(&COND_ndb_util_thread);
pthread_cond_destroy(&COND_ndb_util_ready);
mysql_mutex_destroy(&ndbcluster_mutex);
mysql_mutex_destroy(&LOCK_ndb_util_thread);
mysql_cond_destroy(&COND_ndb_util_thread);
mysql_cond_destroy(&COND_ndb_util_ready);
goto ndbcluster_init_error;
}
/* Wait for the util thread to start */
pthread_mutex_lock(&LOCK_ndb_util_thread);
mysql_mutex_lock(&LOCK_ndb_util_thread);
while (ndb_util_thread_running < 0)
pthread_cond_wait(&COND_ndb_util_ready, &LOCK_ndb_util_thread);
pthread_mutex_unlock(&LOCK_ndb_util_thread);
mysql_cond_wait(&COND_ndb_util_ready, &LOCK_ndb_util_thread);
mysql_mutex_unlock(&LOCK_ndb_util_thread);
if (!ndb_util_thread_running)
{
DBUG_PRINT("error", ("ndb utility thread exited prematurely"));
my_hash_free(&ndbcluster_open_tables);
pthread_mutex_destroy(&ndbcluster_mutex);
pthread_mutex_destroy(&LOCK_ndb_util_thread);
pthread_cond_destroy(&COND_ndb_util_thread);
pthread_cond_destroy(&COND_ndb_util_ready);
mysql_mutex_destroy(&ndbcluster_mutex);
mysql_mutex_destroy(&LOCK_ndb_util_thread);
mysql_cond_destroy(&COND_ndb_util_thread);
mysql_cond_destroy(&COND_ndb_util_ready);
goto ndbcluster_init_error;
}
pthread_mutex_lock(&LOCK_plugin);
mysql_mutex_lock(&LOCK_plugin);
ndbcluster_inited= 1;
DBUG_RETURN(FALSE);
@ -7650,7 +7736,7 @@ ndbcluster_init_error:
g_ndb_cluster_connection= NULL;
ndbcluster_hton->state= SHOW_OPTION_DISABLED; // If we couldn't use handler
pthread_mutex_lock(&LOCK_plugin);
mysql_mutex_lock(&LOCK_plugin);
DBUG_RETURN(TRUE);
}
@ -7693,17 +7779,17 @@ static int ndbcluster_end(handlerton *hton, ha_panic_function type)
/* wait for util thread to finish */
sql_print_information("Stopping Cluster Utility thread");
pthread_mutex_lock(&LOCK_ndb_util_thread);
mysql_mutex_lock(&LOCK_ndb_util_thread);
ndbcluster_terminating= 1;
pthread_cond_signal(&COND_ndb_util_thread);
mysql_cond_signal(&COND_ndb_util_thread);
while (ndb_util_thread_running > 0)
pthread_cond_wait(&COND_ndb_util_ready, &LOCK_ndb_util_thread);
pthread_mutex_unlock(&LOCK_ndb_util_thread);
mysql_cond_wait(&COND_ndb_util_ready, &LOCK_ndb_util_thread);
mysql_mutex_unlock(&LOCK_ndb_util_thread);
#ifdef HAVE_NDB_BINLOG
{
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
while (ndbcluster_open_tables.records)
{
NDB_SHARE *share=
@ -7714,7 +7800,7 @@ static int ndbcluster_end(handlerton *hton, ha_panic_function type)
#endif
ndbcluster_real_free_share(&share);
}
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
}
#endif
my_hash_free(&ndbcluster_open_tables);
@ -7743,10 +7829,10 @@ static int ndbcluster_end(handlerton *hton, ha_panic_function type)
// cleanup ndb interface
ndb_end_internal();
pthread_mutex_destroy(&ndbcluster_mutex);
pthread_mutex_destroy(&LOCK_ndb_util_thread);
pthread_cond_destroy(&COND_ndb_util_thread);
pthread_cond_destroy(&COND_ndb_util_ready);
mysql_mutex_destroy(&ndbcluster_mutex);
mysql_mutex_destroy(&LOCK_ndb_util_thread);
mysql_cond_destroy(&COND_ndb_util_thread);
mysql_cond_destroy(&COND_ndb_util_ready);
DBUG_RETURN(0);
}
@ -8049,12 +8135,12 @@ uint ndb_get_commitcount(THD *thd, char *dbname, char *tabname,
build_table_filename(name, sizeof(name) - 1,
dbname, tabname, "", 0);
DBUG_PRINT("enter", ("name: %s", name));
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
if (!(share=(NDB_SHARE*) my_hash_search(&ndbcluster_open_tables,
(uchar*) name,
strlen(name))))
{
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
DBUG_PRINT("info", ("Table %s not found in ndbcluster_open_tables", name));
DBUG_RETURN(1);
}
@ -8062,9 +8148,9 @@ uint ndb_get_commitcount(THD *thd, char *dbname, char *tabname,
share->use_count++;
DBUG_PRINT("NDB_SHARE", ("%s temporary use_count: %u",
share->key, share->use_count));
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
pthread_mutex_lock(&share->mutex);
mysql_mutex_lock(&share->mutex);
if (opt_ndb_cache_check_time > 0)
{
if (share->commit_count != 0)
@ -8075,7 +8161,7 @@ uint ndb_get_commitcount(THD *thd, char *dbname, char *tabname,
#endif
DBUG_PRINT("info", ("Getting commit_count: %s from share",
llstr(share->commit_count, buff)));
pthread_mutex_unlock(&share->mutex);
mysql_mutex_unlock(&share->mutex);
/* ndb_share reference temporary free */
DBUG_PRINT("NDB_SHARE", ("%s temporary free use_count: %u",
share->key, share->use_count));
@ -8092,7 +8178,7 @@ uint ndb_get_commitcount(THD *thd, char *dbname, char *tabname,
ERR_RETURN(ndb->getNdbError());
}
uint lock= share->commit_count_lock;
pthread_mutex_unlock(&share->mutex);
mysql_mutex_unlock(&share->mutex);
struct Ndb_statistics stat;
{
@ -8108,7 +8194,7 @@ uint ndb_get_commitcount(THD *thd, char *dbname, char *tabname,
}
}
pthread_mutex_lock(&share->mutex);
mysql_mutex_lock(&share->mutex);
if (share->commit_count_lock == lock)
{
#ifndef DBUG_OFF
@ -8124,7 +8210,7 @@ uint ndb_get_commitcount(THD *thd, char *dbname, char *tabname,
DBUG_PRINT("info", ("Discarding commit_count, comit_count_lock changed"));
*commit_count= 0;
}
pthread_mutex_unlock(&share->mutex);
mysql_mutex_unlock(&share->mutex);
/* ndb_share reference temporary free */
DBUG_PRINT("NDB_SHARE", ("%s temporary free use_count: %u",
share->key, share->use_count));
@ -8340,7 +8426,7 @@ static void print_ndbcluster_open_tables()
to avoid segmentation faults. There is a risk that the memory for
this trailing share leaks.
Must be called with previous pthread_mutex_lock(&ndbcluster_mutex)
Must be called with previous mysql_mutex_lock(&ndbcluster_mutex)
*/
int handle_trailing_share(NDB_SHARE *share)
{
@ -8352,7 +8438,7 @@ int handle_trailing_share(NDB_SHARE *share)
++share->use_count;
DBUG_PRINT("NDB_SHARE", ("%s temporary use_count: %u",
share->key, share->use_count));
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
TABLE_LIST table_list;
bzero((char*) &table_list,sizeof(table_list));
@ -8361,7 +8447,7 @@ int handle_trailing_share(NDB_SHARE *share)
mysql_mutex_assert_owner(&LOCK_open);
close_cached_tables(thd, &table_list, TRUE, FALSE, FALSE);
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
/* ndb_share reference temporary free */
DBUG_PRINT("NDB_SHARE", ("%s temporary free use_count: %u",
share->key, share->use_count));
@ -8452,7 +8538,7 @@ int handle_trailing_share(NDB_SHARE *share)
static int rename_share(NDB_SHARE *share, const char *new_key)
{
NDB_SHARE *tmp;
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
uint new_length= (uint) strlen(new_key);
DBUG_PRINT("rename_share", ("old_key: %s old__length: %d",
share->key, share->key_length));
@ -8490,7 +8576,7 @@ static int rename_share(NDB_SHARE *share, const char *new_key)
share->key));
}
dbug_print_open_tables();
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
return -1;
}
dbug_print_open_tables();
@ -8515,7 +8601,7 @@ static int rename_share(NDB_SHARE *share, const char *new_key)
share->old_names= old_key;
// ToDo free old_names after ALTER EVENT
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
return 0;
}
#endif
@ -8526,12 +8612,12 @@ static int rename_share(NDB_SHARE *share, const char *new_key)
*/
NDB_SHARE *ndbcluster_get_share(NDB_SHARE *share)
{
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
share->use_count++;
dbug_print_open_tables();
dbug_print_share("ndbcluster_get_share:", share);
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
return share;
}
@ -8548,7 +8634,7 @@ NDB_SHARE *ndbcluster_get_share(NDB_SHARE *share)
create_if_not_exists == FALSE:
returns 0 if share does not exist
have_lock == TRUE, pthread_mutex_lock(&ndbcluster_mutex) already taken
have_lock == TRUE, mysql_mutex_lock(&ndbcluster_mutex) already taken
*/
NDB_SHARE *ndbcluster_get_share(const char *key, TABLE *table,
@ -8561,7 +8647,7 @@ NDB_SHARE *ndbcluster_get_share(const char *key, TABLE *table,
DBUG_PRINT("enter", ("key: '%s'", key));
if (!have_lock)
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
if (!(share= (NDB_SHARE*) my_hash_search(&ndbcluster_open_tables,
(uchar*) key,
length)))
@ -8570,7 +8656,7 @@ NDB_SHARE *ndbcluster_get_share(const char *key, TABLE *table,
{
DBUG_PRINT("error", ("get_share: %s does not exist", key));
if (!have_lock)
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
DBUG_RETURN(0);
}
if ((share= (NDB_SHARE*) my_malloc(sizeof(*share),
@ -8592,11 +8678,11 @@ NDB_SHARE *ndbcluster_get_share(const char *key, TABLE *table,
my_free((uchar*) share, 0);
*root_ptr= old_root;
if (!have_lock)
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
DBUG_RETURN(0);
}
thr_lock_init(&share->lock);
pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_NDB_SHARE_mutex, &share->mutex, MY_MUTEX_INIT_FAST);
share->commit_count= 0;
share->commit_count_lock= 0;
share->db= share->key + length + 1;
@ -8610,7 +8696,7 @@ NDB_SHARE *ndbcluster_get_share(const char *key, TABLE *table,
ndbcluster_real_free_share(&share);
*root_ptr= old_root;
if (!have_lock)
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
DBUG_RETURN(0);
}
#endif
@ -8620,7 +8706,7 @@ NDB_SHARE *ndbcluster_get_share(const char *key, TABLE *table,
{
DBUG_PRINT("error", ("get_share: failed to alloc share"));
if (!have_lock)
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
my_error(ER_OUTOFMEMORY, MYF(0), sizeof(*share));
DBUG_RETURN(0);
}
@ -8630,7 +8716,7 @@ NDB_SHARE *ndbcluster_get_share(const char *key, TABLE *table,
dbug_print_open_tables();
dbug_print_share("ndbcluster_get_share:", share);
if (!have_lock)
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
DBUG_RETURN(share);
}
@ -8642,7 +8728,7 @@ void ndbcluster_real_free_share(NDB_SHARE **share)
my_hash_delete(&ndbcluster_open_tables, (uchar*) *share);
thr_lock_delete(&(*share)->lock);
pthread_mutex_destroy(&(*share)->mutex);
mysql_mutex_destroy(&(*share)->mutex);
#ifdef HAVE_NDB_BINLOG
if ((*share)->table)
@ -8671,7 +8757,7 @@ void ndbcluster_real_free_share(NDB_SHARE **share)
void ndbcluster_free_share(NDB_SHARE **share, bool have_lock)
{
if (!have_lock)
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
if ((*share)->util_lock == current_thd)
(*share)->util_lock= 0;
if (!--(*share)->use_count)
@ -8684,7 +8770,7 @@ void ndbcluster_free_share(NDB_SHARE **share, bool have_lock)
dbug_print_share("ndbcluster_free_share:", *share);
}
if (!have_lock)
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
}
@ -8844,11 +8930,12 @@ int ha_ndbcluster::write_ndb_file(const char *name)
(void)strxnmov(path, FN_REFLEN-1,
mysql_data_home,"/",name,ha_ndb_ext,NullS);
if ((file=my_create(path, CREATE_MODE,O_RDWR | O_TRUNC,MYF(MY_WME))) >= 0)
if ((file= mysql_file_create(key_file_ndb, path, CREATE_MODE,
O_RDWR | O_TRUNC, MYF(MY_WME))) >= 0)
{
// It's an empty file
error=0;
my_close(file,MYF(0));
mysql_file_close(file, MYF(0));
}
DBUG_RETURN(error);
}
@ -9401,7 +9488,7 @@ pthread_handler_t ndb_util_thread_func(void *arg __attribute__((unused)))
DBUG_ENTER("ndb_util_thread");
DBUG_PRINT("enter", ("cache_check_time: %lu", opt_ndb_cache_check_time));
pthread_mutex_lock(&LOCK_ndb_util_thread);
mysql_mutex_lock(&LOCK_ndb_util_thread);
thd= new THD; /* note that contructor of THD uses DBUG_ */
if (thd == NULL)
@ -9434,45 +9521,45 @@ pthread_handler_t ndb_util_thread_func(void *arg __attribute__((unused)))
/* Signal successful initialization */
ndb_util_thread_running= 1;
pthread_cond_signal(&COND_ndb_util_ready);
pthread_mutex_unlock(&LOCK_ndb_util_thread);
mysql_cond_signal(&COND_ndb_util_ready);
mysql_mutex_unlock(&LOCK_ndb_util_thread);
/*
wait for mysql server to start
*/
pthread_mutex_lock(&LOCK_server_started);
mysql_mutex_lock(&LOCK_server_started);
while (!mysqld_server_started)
{
set_timespec(abstime, 1);
pthread_cond_timedwait(&COND_server_started, &LOCK_server_started,
&abstime);
mysql_cond_timedwait(&COND_server_started, &LOCK_server_started,
&abstime);
if (ndbcluster_terminating)
{
pthread_mutex_unlock(&LOCK_server_started);
pthread_mutex_lock(&LOCK_ndb_util_thread);
mysql_mutex_unlock(&LOCK_server_started);
mysql_mutex_lock(&LOCK_ndb_util_thread);
goto ndb_util_thread_end;
}
}
pthread_mutex_unlock(&LOCK_server_started);
mysql_mutex_unlock(&LOCK_server_started);
/*
Wait for cluster to start
*/
pthread_mutex_lock(&LOCK_ndb_util_thread);
mysql_mutex_lock(&LOCK_ndb_util_thread);
while (!ndb_cluster_node_id && (ndbcluster_hton->slot != ~(uint)0))
{
/* ndb not connected yet */
pthread_cond_wait(&COND_ndb_util_thread, &LOCK_ndb_util_thread);
mysql_cond_wait(&COND_ndb_util_thread, &LOCK_ndb_util_thread);
if (ndbcluster_terminating)
goto ndb_util_thread_end;
}
pthread_mutex_unlock(&LOCK_ndb_util_thread);
mysql_mutex_unlock(&LOCK_ndb_util_thread);
/* Get thd_ndb for this thread */
if (!(thd_ndb= ha_ndbcluster::seize_thd_ndb()))
{
sql_print_error("Could not allocate Thd_ndb object");
pthread_mutex_lock(&LOCK_ndb_util_thread);
mysql_mutex_lock(&LOCK_ndb_util_thread);
goto ndb_util_thread_end;
}
set_thd_ndb(thd, thd_ndb);
@ -9493,14 +9580,14 @@ pthread_handler_t ndb_util_thread_func(void *arg __attribute__((unused)))
set_timespec(abstime, 0);
for (;;)
{
pthread_mutex_lock(&LOCK_ndb_util_thread);
mysql_mutex_lock(&LOCK_ndb_util_thread);
if (!ndbcluster_terminating)
pthread_cond_timedwait(&COND_ndb_util_thread,
&LOCK_ndb_util_thread,
&abstime);
mysql_cond_timedwait(&COND_ndb_util_thread,
&LOCK_ndb_util_thread,
&abstime);
if (ndbcluster_terminating) /* Shutting down server */
goto ndb_util_thread_end;
pthread_mutex_unlock(&LOCK_ndb_util_thread);
mysql_mutex_unlock(&LOCK_ndb_util_thread);
#ifdef NDB_EXTRA_DEBUG_UTIL_THREAD
DBUG_PRINT("ndb_util_thread", ("Started, opt_ndb_cache_check_time: %lu",
opt_ndb_cache_check_time));
@ -9525,7 +9612,7 @@ pthread_handler_t ndb_util_thread_func(void *arg __attribute__((unused)))
/* Lock mutex and fill list with pointers to all open tables */
NDB_SHARE *share;
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
uint i, open_count, record_count= ndbcluster_open_tables.records;
if (share_list_size < record_count)
{
@ -9534,7 +9621,7 @@ pthread_handler_t ndb_util_thread_func(void *arg __attribute__((unused)))
{
sql_print_warning("ndb util thread: malloc failure, "
"query cache not maintained properly");
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
goto next; // At least do not crash
}
delete [] share_list;
@ -9561,7 +9648,7 @@ pthread_handler_t ndb_util_thread_func(void *arg __attribute__((unused)))
/* Store pointer to table */
share_list[open_count++]= share;
}
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
/* Iterate through the open files list */
for (i= 0; i < open_count; i++)
@ -9586,9 +9673,9 @@ pthread_handler_t ndb_util_thread_func(void *arg __attribute__((unused)))
struct Ndb_statistics stat;
uint lock;
pthread_mutex_lock(&share->mutex);
mysql_mutex_lock(&share->mutex);
lock= share->commit_count_lock;
pthread_mutex_unlock(&share->mutex);
mysql_mutex_unlock(&share->mutex);
{
/* Contact NDB to get commit count for table */
Ndb* ndb= thd_ndb->ndb;
@ -9619,10 +9706,10 @@ pthread_handler_t ndb_util_thread_func(void *arg __attribute__((unused)))
}
}
loop_next:
pthread_mutex_lock(&share->mutex);
mysql_mutex_lock(&share->mutex);
if (share->commit_count_lock == lock)
share->commit_count= stat.commit_count;
pthread_mutex_unlock(&share->mutex);
mysql_mutex_unlock(&share->mutex);
/* ndb_share reference temporary free */
DBUG_PRINT("NDB_SHARE", ("%s temporary free use_count: %u",
@ -9652,7 +9739,7 @@ next:
}
}
pthread_mutex_lock(&LOCK_ndb_util_thread);
mysql_mutex_lock(&LOCK_ndb_util_thread);
ndb_util_thread_end:
net_end(&thd->net);
@ -9664,8 +9751,8 @@ ndb_util_thread_fail:
/* signal termination */
ndb_util_thread_running= 0;
pthread_cond_signal(&COND_ndb_util_ready);
pthread_mutex_unlock(&LOCK_ndb_util_thread);
mysql_cond_signal(&COND_ndb_util_ready);
mysql_mutex_unlock(&LOCK_ndb_util_thread);
DBUG_PRINT("exit", ("ndb_util_thread"));
DBUG_LEAVE; // Must match DBUG_ENTER()

22
sql/ha_ndbcluster.h
View File

@ -1,7 +1,7 @@
#ifndef HA_NDBCLUSTER_INCLUDED
#define HA_NDBCLUSTER_INCLUDED
/* Copyright (C) 2000-2003 MySQL AB
/* Copyright (C) 2000-2003 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -35,6 +35,10 @@
#define NDB_HIDDEN_PRIMARY_KEY_LENGTH 8
#ifdef HAVE_PSI_INTERFACE
extern PSI_file_key key_file_ndb;
#endif /* HAVE_PSI_INTERFACE */
class Ndb; // Forward declaration
class NdbOperation; // Forward declaration
@ -102,7 +106,7 @@ typedef struct st_ndbcluster_share {
NDB_SHARE_STATE state;
MEM_ROOT mem_root;
THR_LOCK lock;
pthread_mutex_t mutex;
mysql_mutex_t mutex;
char *key;
uint key_length;
THD *util_lock;
@ -131,9 +135,9 @@ NDB_SHARE_STATE
get_ndb_share_state(NDB_SHARE *share)
{
NDB_SHARE_STATE state;
pthread_mutex_lock(&share->mutex);
mysql_mutex_lock(&share->mutex);
state= share->state;
pthread_mutex_unlock(&share->mutex);
mysql_mutex_unlock(&share->mutex);
return state;
}
@ -141,19 +145,19 @@ inline
void
set_ndb_share_state(NDB_SHARE *share, NDB_SHARE_STATE state)
{
pthread_mutex_lock(&share->mutex);
mysql_mutex_lock(&share->mutex);
share->state= state;
pthread_mutex_unlock(&share->mutex);
mysql_mutex_unlock(&share->mutex);
}
struct Ndb_tuple_id_range_guard {
Ndb_tuple_id_range_guard(NDB_SHARE* _share) :
share(_share),
range(share->tuple_id_range) {
pthread_mutex_lock(&share->mutex);
mysql_mutex_lock(&share->mutex);
}
~Ndb_tuple_id_range_guard() {
pthread_mutex_unlock(&share->mutex);
mysql_mutex_unlock(&share->mutex);
}
NDB_SHARE* share;
Ndb::TupleIdRange& range;
@ -578,6 +582,6 @@ static const char ndbcluster_hton_name[]= "ndbcluster";
static const int ndbcluster_hton_name_length=sizeof(ndbcluster_hton_name)-1;
extern int ndbcluster_terminating;
extern int ndb_util_thread_running;
extern pthread_cond_t COND_ndb_util_ready;
extern mysql_cond_t COND_ndb_util_ready;
#endif /* HA_NDBCLUSTER_INCLUDED */

262
sql/ha_ndbcluster_binlog.cc
View File

@ -79,7 +79,7 @@ THD *injector_thd= 0;
to enable ndb injector thread receiving events.
Must therefore always be used with a surrounding
pthread_mutex_lock(&injector_mutex), when doing create/dropEventOperation
mysql_mutex_lock(&injector_mutex), when doing create/dropEventOperation
*/
static Ndb *injector_ndb= 0;
static Ndb *schema_ndb= 0;
@ -106,8 +106,8 @@ static int ndbcluster_binlog_terminating= 0;
and injector thread
*/
pthread_t ndb_binlog_thread;
pthread_mutex_t injector_mutex;
pthread_cond_t injector_cond;
mysql_mutex_t injector_mutex;
mysql_cond_t injector_cond;
/* NDB Injector thread (used for binlog creation) */
static ulonglong ndb_latest_applied_binlog_epoch= 0;
@ -116,7 +116,7 @@ static ulonglong ndb_latest_received_binlog_epoch= 0;
NDB_SHARE *ndb_apply_status_share= 0;
NDB_SHARE *ndb_schema_share= 0;
pthread_mutex_t ndb_schema_share_mutex;
mysql_mutex_t ndb_schema_share_mutex;
extern my_bool opt_log_slave_updates;
static my_bool g_ndb_log_slave_updates;
@ -124,7 +124,7 @@ static my_bool g_ndb_log_slave_updates;
/* Schema object distribution handling */
HASH ndb_schema_objects;
typedef struct st_ndb_schema_object {
pthread_mutex_t mutex;
mysql_mutex_t mutex;
char *key;
uint key_length;
uint use_count;
@ -641,28 +641,28 @@ static int ndbcluster_binlog_end(THD *thd)
however be a likely case as the ndbcluster_binlog_end is supposed to
be called before ndb_cluster_end().
*/
pthread_mutex_lock(&LOCK_ndb_util_thread);
mysql_mutex_lock(&LOCK_ndb_util_thread);
/* Ensure mutex are not freed if ndb_cluster_end is running at same time */
ndb_util_thread_running++;
ndbcluster_terminating= 1;
pthread_cond_signal(&COND_ndb_util_thread);
mysql_cond_signal(&COND_ndb_util_thread);
while (ndb_util_thread_running > 1)
pthread_cond_wait(&COND_ndb_util_ready, &LOCK_ndb_util_thread);
mysql_cond_wait(&COND_ndb_util_ready, &LOCK_ndb_util_thread);
ndb_util_thread_running--;
pthread_mutex_unlock(&LOCK_ndb_util_thread);
mysql_mutex_unlock(&LOCK_ndb_util_thread);
}
/* wait for injector thread to finish */
ndbcluster_binlog_terminating= 1;
pthread_mutex_lock(&injector_mutex);
pthread_cond_signal(&injector_cond);
mysql_mutex_lock(&injector_mutex);
mysql_cond_signal(&injector_cond);
while (ndb_binlog_thread_running > 0)
pthread_cond_wait(&injector_cond, &injector_mutex);
pthread_mutex_unlock(&injector_mutex);
mysql_cond_wait(&injector_cond, &injector_mutex);
mysql_mutex_unlock(&injector_mutex);
pthread_mutex_destroy(&injector_mutex);
pthread_cond_destroy(&injector_cond);
pthread_mutex_destroy(&ndb_schema_share_mutex);
mysql_mutex_destroy(&injector_mutex);
mysql_cond_destroy(&injector_cond);
mysql_mutex_destroy(&ndb_schema_share_mutex);
#endif
DBUG_RETURN(0);
@ -742,14 +742,14 @@ void ndbcluster_binlog_init_handlerton()
*/
static NDB_SHARE *ndbcluster_check_ndb_apply_status_share()
{
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
void *share= my_hash_search(&ndbcluster_open_tables,
(uchar*) NDB_APPLY_TABLE_FILE,
sizeof(NDB_APPLY_TABLE_FILE) - 1);
DBUG_PRINT("info",("ndbcluster_check_ndb_apply_status_share %s 0x%lx",
NDB_APPLY_TABLE_FILE, (long) share));
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
return (NDB_SHARE*) share;
}
@ -760,14 +760,14 @@ static NDB_SHARE *ndbcluster_check_ndb_apply_status_share()
*/
static NDB_SHARE *ndbcluster_check_ndb_schema_share()
{
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
void *share= my_hash_search(&ndbcluster_open_tables,
(uchar*) NDB_SCHEMA_TABLE_FILE,
sizeof(NDB_SCHEMA_TABLE_FILE) - 1);
DBUG_PRINT("info",("ndbcluster_check_ndb_schema_share %s 0x%lx",
NDB_SCHEMA_TABLE_FILE, (long) share));
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
return (NDB_SHARE*) share;
}
@ -802,7 +802,7 @@ static int ndbcluster_create_ndb_apply_status_table(THD *thd)
{
build_table_filename(buf, sizeof(buf) - 1,
NDB_REP_DB, NDB_APPLY_TABLE, reg_ext, 0);
my_delete(buf, MYF(0));
mysql_file_delete(key_file_frm, buf, MYF(0));
}
/*
@ -860,7 +860,7 @@ static int ndbcluster_create_schema_table(THD *thd)
{
build_table_filename(buf, sizeof(buf) - 1,
NDB_REP_DB, NDB_SCHEMA_TABLE, reg_ext, 0);
my_delete(buf, MYF(0));
mysql_file_delete(key_file_frm, buf, MYF(0));
}
/*
@ -928,7 +928,7 @@ int ndbcluster_setup_binlog_table_shares(THD *thd)
close_cached_tables(NULL, NULL, TRUE, FALSE, FALSE);
mysql_mutex_unlock(&LOCK_open);
/* Signal injector thread that all is setup */
pthread_cond_signal(&injector_cond);
mysql_cond_signal(&injector_cond);
}
return 0;
}
@ -1239,12 +1239,12 @@ static void ndb_report_waiting(const char *key,
{
ulonglong ndb_latest_epoch= 0;
const char *proc_info= "<no info>";
pthread_mutex_lock(&injector_mutex);
mysql_mutex_lock(&injector_mutex);
if (injector_ndb)
ndb_latest_epoch= injector_ndb->getLatestGCI();
if (injector_thd)
proc_info= injector_thd->proc_info;
pthread_mutex_unlock(&injector_mutex);
mysql_mutex_unlock(&injector_mutex);
sql_print_information("NDB %s:"
" waiting max %u sec for %s %s."
" epochs: (%u,%u,%u)"
@ -1357,15 +1357,15 @@ int ndbcluster_log_schema_op(THD *thd, NDB_SHARE *share,
bitmap_set_all(&schema_subscribers);
/* begin protect ndb_schema_share */
pthread_mutex_lock(&ndb_schema_share_mutex);
mysql_mutex_lock(&ndb_schema_share_mutex);
if (ndb_schema_share == 0)
{
pthread_mutex_unlock(&ndb_schema_share_mutex);
mysql_mutex_unlock(&ndb_schema_share_mutex);
if (ndb_schema_object)
ndb_free_schema_object(&ndb_schema_object, FALSE);
DBUG_RETURN(0);
}
(void) pthread_mutex_lock(&ndb_schema_share->mutex);
mysql_mutex_lock(&ndb_schema_share->mutex);
for (i= 0; i < no_storage_nodes; i++)
{
MY_BITMAP *table_subscribers= &ndb_schema_share->subscriber_bitmap[i];
@ -1376,8 +1376,8 @@ int ndbcluster_log_schema_op(THD *thd, NDB_SHARE *share,
updated= 1;
}
}
(void) pthread_mutex_unlock(&ndb_schema_share->mutex);
pthread_mutex_unlock(&ndb_schema_share_mutex);
mysql_mutex_unlock(&ndb_schema_share->mutex);
mysql_mutex_unlock(&ndb_schema_share_mutex);
/* end protect ndb_schema_share */
if (updated)
@ -1397,10 +1397,10 @@ int ndbcluster_log_schema_op(THD *thd, NDB_SHARE *share,
if (ndb_schema_object)
{
(void) pthread_mutex_lock(&ndb_schema_object->mutex);
mysql_mutex_lock(&ndb_schema_object->mutex);
memcpy(ndb_schema_object->slock, schema_subscribers.bitmap,
sizeof(ndb_schema_object->slock));
(void) pthread_mutex_unlock(&ndb_schema_object->mutex);
mysql_mutex_unlock(&ndb_schema_object->mutex);
}
DBUG_DUMP("schema_subscribers", (uchar*)schema_subscribers.bitmap,
@ -1566,7 +1566,7 @@ end:
dict->forceGCPWait();
int max_timeout= DEFAULT_SYNC_TIMEOUT;
(void) pthread_mutex_lock(&ndb_schema_object->mutex);
mysql_mutex_lock(&ndb_schema_object->mutex);
if (have_lock_open)
{
mysql_mutex_assert_owner(&LOCK_open);
@ -1578,20 +1578,20 @@ end:
int i;
int no_storage_nodes= g_ndb_cluster_connection->no_db_nodes();
set_timespec(abstime, 1);
int ret= pthread_cond_timedwait(&injector_cond,
&ndb_schema_object->mutex,
&abstime);
int ret= mysql_cond_timedwait(&injector_cond,
&ndb_schema_object->mutex,
&abstime);
if (thd->killed)
break;
/* begin protect ndb_schema_share */
pthread_mutex_lock(&ndb_schema_share_mutex);
mysql_mutex_lock(&ndb_schema_share_mutex);
if (ndb_schema_share == 0)
{
pthread_mutex_unlock(&ndb_schema_share_mutex);
mysql_mutex_unlock(&ndb_schema_share_mutex);
break;
}
(void) pthread_mutex_lock(&ndb_schema_share->mutex);
mysql_mutex_lock(&ndb_schema_share->mutex);
for (i= 0; i < no_storage_nodes; i++)
{
/* remove any unsubscribed from schema_subscribers */
@ -1599,8 +1599,8 @@ end:
if (!bitmap_is_clear_all(tmp))
bitmap_intersect(&schema_subscribers, tmp);
}
(void) pthread_mutex_unlock(&ndb_schema_share->mutex);
pthread_mutex_unlock(&ndb_schema_share_mutex);
mysql_mutex_unlock(&ndb_schema_share->mutex);
mysql_mutex_unlock(&ndb_schema_share_mutex);
/* end protect ndb_schema_share */
/* remove any unsubscribed from ndb_schema_object->slock */
@ -1631,7 +1631,7 @@ end:
{
mysql_mutex_lock(&LOCK_open);
}
(void) pthread_mutex_unlock(&ndb_schema_object->mutex);
mysql_mutex_unlock(&ndb_schema_object->mutex);
}
if (ndb_schema_object)
@ -1761,11 +1761,11 @@ ndb_handle_schema_change(THD *thd, Ndb *ndb, NdbEventOperation *pOp,
if (is_online_alter_table)
{
/* Signal ha_ndbcluster::alter_table that drop is done */
(void) pthread_cond_signal(&injector_cond);
mysql_cond_signal(&injector_cond);
DBUG_RETURN(0);
}
(void) pthread_mutex_lock(&share->mutex);
mysql_mutex_lock(&share->mutex);
if (is_rename_table && !is_remote_change)
{
DBUG_PRINT("info", ("Detected name change of table %s.%s",
@ -1801,10 +1801,10 @@ ndb_handle_schema_change(THD *thd, Ndb *ndb, NdbEventOperation *pOp,
// either just us or drop table handling as well
/* Signal ha_ndbcluster::delete/rename_table that drop is done */
(void) pthread_mutex_unlock(&share->mutex);
(void) pthread_cond_signal(&injector_cond);
mysql_mutex_unlock(&share->mutex);
mysql_cond_signal(&injector_cond);
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
/* ndb_share reference binlog free */
DBUG_PRINT("NDB_SHARE", ("%s binlog free use_count: %u",
share->key, share->use_count));
@ -1830,14 +1830,14 @@ ndb_handle_schema_change(THD *thd, Ndb *ndb, NdbEventOperation *pOp,
}
else
share= 0;
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
pOp->setCustomData(0);
pthread_mutex_lock(&injector_mutex);
mysql_mutex_lock(&injector_mutex);
ndb->dropEventOperation(pOp);
pOp= 0;
pthread_mutex_unlock(&injector_mutex);
mysql_mutex_unlock(&injector_mutex);
if (do_close_cached_tables)
{
@ -2072,7 +2072,7 @@ ndb_binlog_thread_handle_schema_event(THD *thd, Ndb *ndb,
"read only on reconnect.");
/* begin protect ndb_schema_share */
pthread_mutex_lock(&ndb_schema_share_mutex);
mysql_mutex_lock(&ndb_schema_share_mutex);
/* ndb_share reference binlog extra free */
DBUG_PRINT("NDB_SHARE", ("%s binlog extra free use_count: %u",
ndb_schema_share->key,
@ -2080,7 +2080,7 @@ ndb_binlog_thread_handle_schema_event(THD *thd, Ndb *ndb,
free_share(&ndb_schema_share);
ndb_schema_share= 0;
ndb_binlog_tables_inited= 0;
pthread_mutex_unlock(&ndb_schema_share_mutex);
mysql_mutex_unlock(&ndb_schema_share_mutex);
/* end protect ndb_schema_share */
close_cached_tables(NULL, NULL, FALSE, FALSE, FALSE);
@ -2092,7 +2092,7 @@ ndb_binlog_thread_handle_schema_event(THD *thd, Ndb *ndb,
{
uint8 node_id= g_node_id_map[pOp->getNdbdNodeId()];
DBUG_ASSERT(node_id != 0xFF);
(void) pthread_mutex_lock(&tmp_share->mutex);
mysql_mutex_lock(&tmp_share->mutex);
bitmap_clear_all(&tmp_share->subscriber_bitmap[node_id]);
DBUG_PRINT("info",("NODE_FAILURE UNSUBSCRIBE[%d]", node_id));
if (opt_ndb_extra_logging)
@ -2103,8 +2103,8 @@ ndb_binlog_thread_handle_schema_event(THD *thd, Ndb *ndb,
tmp_share->subscriber_bitmap[node_id].bitmap[1],
tmp_share->subscriber_bitmap[node_id].bitmap[0]);
}
(void) pthread_mutex_unlock(&tmp_share->mutex);
(void) pthread_cond_signal(&injector_cond);
mysql_mutex_unlock(&tmp_share->mutex);
mysql_cond_signal(&injector_cond);
break;
}
case NDBEVENT::TE_SUBSCRIBE:
@ -2112,7 +2112,7 @@ ndb_binlog_thread_handle_schema_event(THD *thd, Ndb *ndb,
uint8 node_id= g_node_id_map[pOp->getNdbdNodeId()];
uint8 req_id= pOp->getReqNodeId();
DBUG_ASSERT(req_id != 0 && node_id != 0xFF);
(void) pthread_mutex_lock(&tmp_share->mutex);
mysql_mutex_lock(&tmp_share->mutex);
bitmap_set_bit(&tmp_share->subscriber_bitmap[node_id], req_id);
DBUG_PRINT("info",("SUBSCRIBE[%d] %d", node_id, req_id));
if (opt_ndb_extra_logging)
@ -2124,8 +2124,8 @@ ndb_binlog_thread_handle_schema_event(THD *thd, Ndb *ndb,
tmp_share->subscriber_bitmap[node_id].bitmap[1],
tmp_share->subscriber_bitmap[node_id].bitmap[0]);
}
(void) pthread_mutex_unlock(&tmp_share->mutex);
(void) pthread_cond_signal(&injector_cond);
mysql_mutex_unlock(&tmp_share->mutex);
mysql_cond_signal(&injector_cond);
break;
}
case NDBEVENT::TE_UNSUBSCRIBE:
@ -2133,7 +2133,7 @@ ndb_binlog_thread_handle_schema_event(THD *thd, Ndb *ndb,
uint8 node_id= g_node_id_map[pOp->getNdbdNodeId()];
uint8 req_id= pOp->getReqNodeId();
DBUG_ASSERT(req_id != 0 && node_id != 0xFF);
(void) pthread_mutex_lock(&tmp_share->mutex);
mysql_mutex_lock(&tmp_share->mutex);
bitmap_clear_bit(&tmp_share->subscriber_bitmap[node_id], req_id);
DBUG_PRINT("info",("UNSUBSCRIBE[%d] %d", node_id, req_id));
if (opt_ndb_extra_logging)
@ -2145,8 +2145,8 @@ ndb_binlog_thread_handle_schema_event(THD *thd, Ndb *ndb,
tmp_share->subscriber_bitmap[node_id].bitmap[1],
tmp_share->subscriber_bitmap[node_id].bitmap[0]);
}
(void) pthread_mutex_unlock(&tmp_share->mutex);
(void) pthread_cond_signal(&injector_cond);
mysql_mutex_unlock(&tmp_share->mutex);
mysql_cond_signal(&injector_cond);
break;
}
default:
@ -2186,22 +2186,22 @@ ndb_binlog_thread_handle_schema_event_post_epoch(THD *thd,
build_table_filename(key, sizeof(key) - 1, schema->db, schema->name, "", 0);
if (schema_type == SOT_CLEAR_SLOCK)
{
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
NDB_SCHEMA_OBJECT *ndb_schema_object=
(NDB_SCHEMA_OBJECT*) my_hash_search(&ndb_schema_objects,
(uchar*) key, strlen(key));
if (ndb_schema_object)
{
pthread_mutex_lock(&ndb_schema_object->mutex);
mysql_mutex_lock(&ndb_schema_object->mutex);
memcpy(ndb_schema_object->slock, schema->slock,
sizeof(ndb_schema_object->slock));
DBUG_DUMP("ndb_schema_object->slock_bitmap.bitmap",
(uchar*)ndb_schema_object->slock_bitmap.bitmap,
no_bytes_in_map(&ndb_schema_object->slock_bitmap));
pthread_mutex_unlock(&ndb_schema_object->mutex);
pthread_cond_signal(&injector_cond);
mysql_mutex_unlock(&ndb_schema_object->mutex);
mysql_cond_signal(&injector_cond);
}
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
continue;
}
/* ndb_share reference temporary, free below */
@ -2462,27 +2462,29 @@ int ndbcluster_binlog_start()
DBUG_RETURN(-1);
}
pthread_mutex_init(&injector_mutex, MY_MUTEX_INIT_FAST);
pthread_cond_init(&injector_cond, NULL);
pthread_mutex_init(&ndb_schema_share_mutex, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_injector_mutex, &injector_mutex, MY_MUTEX_INIT_FAST);
mysql_cond_init(key_injector_cond, &injector_cond, NULL);
mysql_mutex_init(key_ndb_schema_share_mutex,
&ndb_schema_share_mutex, MY_MUTEX_INIT_FAST);
/* Create injector thread */
if (pthread_create(&ndb_binlog_thread, &connection_attrib,
ndb_binlog_thread_func, 0))
if (mysql_thread_create(key_thread_ndb_binlog,
&ndb_binlog_thread, &connection_attrib,
ndb_binlog_thread_func, 0))
{
DBUG_PRINT("error", ("Could not create ndb injector thread"));
pthread_cond_destroy(&injector_cond);
pthread_mutex_destroy(&injector_mutex);
mysql_cond_destroy(&injector_cond);
mysql_mutex_destroy(&injector_mutex);
DBUG_RETURN(-1);
}
ndbcluster_binlog_inited= 1;
/* Wait for the injector thread to start */
pthread_mutex_lock(&injector_mutex);
mysql_mutex_lock(&injector_mutex);
while (!ndb_binlog_thread_running)
pthread_cond_wait(&injector_cond, &injector_mutex);
pthread_mutex_unlock(&injector_mutex);
mysql_cond_wait(&injector_cond, &injector_mutex);
mysql_mutex_unlock(&injector_mutex);
if (ndb_binlog_thread_running < 0)
DBUG_RETURN(-1);
@ -2572,7 +2574,7 @@ int ndbcluster_create_binlog_setup(Ndb *ndb, const char *key,
DBUG_ASSERT(! IS_NDB_BLOB_PREFIX(table_name));
DBUG_ASSERT(strlen(key) == key_len);
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
/* Handle any trailing share */
NDB_SHARE *share= (NDB_SHARE*) my_hash_search(&ndbcluster_open_tables,
@ -2584,7 +2586,7 @@ int ndbcluster_create_binlog_setup(Ndb *ndb, const char *key,
share->op != 0 ||
share->op_old != 0)
{
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
DBUG_RETURN(0); // replication already setup, or should not
}
}
@ -2594,7 +2596,7 @@ int ndbcluster_create_binlog_setup(Ndb *ndb, const char *key,
if (share->op || share->op_old)
{
my_errno= HA_ERR_TABLE_EXIST;
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
DBUG_RETURN(1);
}
if (!share_may_exist || share->connect_count !=
@ -2637,10 +2639,10 @@ int ndbcluster_create_binlog_setup(Ndb *ndb, const char *key,
if (!do_event_op)
{
share->flags|= NSF_NO_BINLOG;
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
DBUG_RETURN(0);
}
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
while (share && !IS_TMP_PREFIX(table_name))
{
@ -2933,14 +2935,14 @@ ndbcluster_create_event_ops(NDB_SHARE *share, const NDBTAB *ndbtab,
int retry_sleep= 100;
while (1)
{
pthread_mutex_lock(&injector_mutex);
mysql_mutex_lock(&injector_mutex);
Ndb *ndb= injector_ndb;
if (do_ndb_schema_share)
ndb= schema_ndb;
if (ndb == 0)
{
pthread_mutex_unlock(&injector_mutex);
mysql_mutex_unlock(&injector_mutex);
DBUG_RETURN(-1);
}
@ -2965,7 +2967,7 @@ ndbcluster_create_event_ops(NDB_SHARE *share, const NDBTAB *ndbtab,
ndb->getNdbError().code,
ndb->getNdbError().message,
"NDB");
pthread_mutex_unlock(&injector_mutex);
mysql_mutex_unlock(&injector_mutex);
DBUG_RETURN(-1);
}
@ -3015,7 +3017,7 @@ ndbcluster_create_event_ops(NDB_SHARE *share, const NDBTAB *ndbtab,
op->getNdbError().message,
"NDB");
ndb->dropEventOperation(op);
pthread_mutex_unlock(&injector_mutex);
mysql_mutex_unlock(&injector_mutex);
DBUG_RETURN(-1);
}
}
@ -3057,7 +3059,7 @@ ndbcluster_create_event_ops(NDB_SHARE *share, const NDBTAB *ndbtab,
op->getNdbError().code, op->getNdbError().message);
}
ndb->dropEventOperation(op);
pthread_mutex_unlock(&injector_mutex);
mysql_mutex_unlock(&injector_mutex);
if (retries)
{
my_sleep(retry_sleep);
@ -3065,7 +3067,7 @@ ndbcluster_create_event_ops(NDB_SHARE *share, const NDBTAB *ndbtab,
}
DBUG_RETURN(-1);
}
pthread_mutex_unlock(&injector_mutex);
mysql_mutex_unlock(&injector_mutex);
break;
}
@ -3079,7 +3081,7 @@ ndbcluster_create_event_ops(NDB_SHARE *share, const NDBTAB *ndbtab,
ndb_apply_status_share= get_share(share);
DBUG_PRINT("NDB_SHARE", ("%s binlog extra use_count: %u",
share->key, share->use_count));
(void) pthread_cond_signal(&injector_cond);
mysql_cond_signal(&injector_cond);
}
else if (do_ndb_schema_share)
{
@ -3087,7 +3089,7 @@ ndbcluster_create_event_ops(NDB_SHARE *share, const NDBTAB *ndbtab,
ndb_schema_share= get_share(share);
DBUG_PRINT("NDB_SHARE", ("%s binlog extra use_count: %u",
share->key, share->use_count));
(void) pthread_cond_signal(&injector_cond);
mysql_cond_signal(&injector_cond);
}
DBUG_PRINT("info",("%s share->op: 0x%lx share->use_count: %u",
@ -3158,7 +3160,7 @@ ndbcluster_handle_drop_table(Ndb *ndb, const char *event_name,
#define SYNC_DROP_
#ifdef SYNC_DROP_
thd->proc_info= "Syncing ndb table schema operation and binlog";
(void) pthread_mutex_lock(&share->mutex);
mysql_mutex_lock(&share->mutex);
mysql_mutex_assert_owner(&LOCK_open);
mysql_mutex_unlock(&LOCK_open);
int max_timeout= DEFAULT_SYNC_TIMEOUT;
@ -3166,9 +3168,9 @@ ndbcluster_handle_drop_table(Ndb *ndb, const char *event_name,
{
struct timespec abstime;
set_timespec(abstime, 1);
int ret= pthread_cond_timedwait(&injector_cond,
&share->mutex,
&abstime);
int ret= mysql_cond_timedwait(&injector_cond,
&share->mutex,
&abstime);
if (thd->killed ||
share->op == 0)
break;
@ -3187,12 +3189,12 @@ ndbcluster_handle_drop_table(Ndb *ndb, const char *event_name,
}
}
mysql_mutex_lock(&LOCK_open);
(void) pthread_mutex_unlock(&share->mutex);
mysql_mutex_unlock(&share->mutex);
#else
(void) pthread_mutex_lock(&share->mutex);
mysql_mutex_lock(&share->mutex);
share->op_old= share->op;
share->op= 0;
(void) pthread_mutex_unlock(&share->mutex);
mysql_mutex_unlock(&share->mutex);
#endif
thd->proc_info= save_proc_info;
@ -3560,7 +3562,7 @@ static NDB_SCHEMA_OBJECT *ndb_get_schema_object(const char *key,
DBUG_PRINT("enter", ("key: '%s'", key));
if (!have_lock)
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
while (!(ndb_schema_object=
(NDB_SCHEMA_OBJECT*) my_hash_search(&ndb_schema_objects,
(uchar*) key,
@ -3586,7 +3588,7 @@ static NDB_SCHEMA_OBJECT *ndb_get_schema_object(const char *key,
my_free((uchar*) ndb_schema_object, 0);
break;
}
pthread_mutex_init(&ndb_schema_object->mutex, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_ndb_schema_object_mutex, &ndb_schema_object->mutex, MY_MUTEX_INIT_FAST);
bitmap_init(&ndb_schema_object->slock_bitmap, ndb_schema_object->slock,
sizeof(ndb_schema_object->slock)*8, FALSE);
bitmap_clear_all(&ndb_schema_object->slock_bitmap);
@ -3598,7 +3600,7 @@ static NDB_SCHEMA_OBJECT *ndb_get_schema_object(const char *key,
DBUG_PRINT("info", ("use_count: %d", ndb_schema_object->use_count));
}
if (!have_lock)
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
DBUG_RETURN(ndb_schema_object);
}
@ -3609,12 +3611,12 @@ static void ndb_free_schema_object(NDB_SCHEMA_OBJECT **ndb_schema_object,
DBUG_ENTER("ndb_free_schema_object");
DBUG_PRINT("enter", ("key: '%s'", (*ndb_schema_object)->key));
if (!have_lock)
pthread_mutex_lock(&ndbcluster_mutex);
mysql_mutex_lock(&ndbcluster_mutex);
if (!--(*ndb_schema_object)->use_count)
{
DBUG_PRINT("info", ("use_count: %d", (*ndb_schema_object)->use_count));
my_hash_delete(&ndb_schema_objects, (uchar*) *ndb_schema_object);
pthread_mutex_destroy(&(*ndb_schema_object)->mutex);
mysql_mutex_destroy(&(*ndb_schema_object)->mutex);
my_free((uchar*) *ndb_schema_object, MYF(0));
*ndb_schema_object= 0;
}
@ -3623,7 +3625,7 @@ static void ndb_free_schema_object(NDB_SCHEMA_OBJECT **ndb_schema_object,
DBUG_PRINT("info", ("use_count: %d", (*ndb_schema_object)->use_count));
}
if (!have_lock)
pthread_mutex_unlock(&ndbcluster_mutex);
mysql_mutex_unlock(&ndbcluster_mutex);
DBUG_VOID_RETURN;
}
@ -3644,7 +3646,7 @@ pthread_handler_t ndb_binlog_thread_func(void *arg)
Timer main_timer;
#endif
pthread_mutex_lock(&injector_mutex);
mysql_mutex_lock(&injector_mutex);
/*
Set up the Thread
*/
@ -3661,14 +3663,16 @@ pthread_handler_t ndb_binlog_thread_func(void *arg)
thd->thread_id= thread_id++;
pthread_mutex_unlock(&LOCK_thread_count);
mysql_thread_set_psi_id(thd->thread_id);
thd->thread_stack= (char*) &thd; /* remember where our stack is */
if (thd->store_globals())
{
thd->cleanup();
delete thd;
ndb_binlog_thread_running= -1;
pthread_mutex_unlock(&injector_mutex);
pthread_cond_signal(&injector_cond);
mysql_mutex_unlock(&injector_mutex);
mysql_cond_signal(&injector_cond);
DBUG_LEAVE; // Must match DBUG_ENTER()
my_thread_end();
@ -3703,8 +3707,8 @@ pthread_handler_t ndb_binlog_thread_func(void *arg)
{
sql_print_error("NDB Binlog: Getting Schema Ndb object failed");
ndb_binlog_thread_running= -1;
pthread_mutex_unlock(&injector_mutex);
pthread_cond_signal(&injector_cond);
mysql_mutex_unlock(&injector_mutex);
mysql_cond_signal(&injector_cond);
goto err;
}
@ -3714,8 +3718,8 @@ pthread_handler_t ndb_binlog_thread_func(void *arg)
{
sql_print_error("NDB Binlog: Getting Ndb object failed");
ndb_binlog_thread_running= -1;
pthread_mutex_unlock(&injector_mutex);
pthread_cond_signal(&injector_cond);
mysql_mutex_unlock(&injector_mutex);
mysql_cond_signal(&injector_cond);
goto err;
}
@ -3728,7 +3732,7 @@ pthread_handler_t ndb_binlog_thread_func(void *arg)
Used by both sql client thread and binlog thread to interact
with the storage
pthread_mutex_lock(&injector_mutex);
mysql_mutex_lock(&injector_mutex);
*/
injector_thd= thd;
injector_ndb= i_ndb;
@ -3743,27 +3747,27 @@ pthread_handler_t ndb_binlog_thread_func(void *arg)
/* Thread start up completed */
ndb_binlog_thread_running= 1;
pthread_mutex_unlock(&injector_mutex);
pthread_cond_signal(&injector_cond);
mysql_mutex_unlock(&injector_mutex);
mysql_cond_signal(&injector_cond);
/*
wait for mysql server to start (so that the binlog is started
and thus can receive the first GAP event)
*/
pthread_mutex_lock(&LOCK_server_started);
mysql_mutex_lock(&LOCK_server_started);
while (!mysqld_server_started)
{
struct timespec abstime;
set_timespec(abstime, 1);
pthread_cond_timedwait(&COND_server_started, &LOCK_server_started,
&abstime);
mysql_cond_timedwait(&COND_server_started, &LOCK_server_started,
&abstime);
if (ndbcluster_terminating)
{
pthread_mutex_unlock(&LOCK_server_started);
mysql_mutex_unlock(&LOCK_server_started);
goto err;
}
}
pthread_mutex_unlock(&LOCK_server_started);
mysql_mutex_unlock(&LOCK_server_started);
restart:
/*
Main NDB Injector loop
@ -3806,21 +3810,21 @@ restart:
{
thd->proc_info= "Waiting for ndbcluster to start";
pthread_mutex_lock(&injector_mutex);
mysql_mutex_lock(&injector_mutex);
while (!ndb_schema_share ||
(ndb_binlog_running && !ndb_apply_status_share))
{
/* ndb not connected yet */
struct timespec abstime;
set_timespec(abstime, 1);
pthread_cond_timedwait(&injector_cond, &injector_mutex, &abstime);
mysql_cond_timedwait(&injector_cond, &injector_mutex, &abstime);
if (ndbcluster_binlog_terminating)
{
pthread_mutex_unlock(&injector_mutex);
mysql_mutex_unlock(&injector_mutex);
goto err;
}
}
pthread_mutex_unlock(&injector_mutex);
mysql_mutex_unlock(&injector_mutex);
if (thd_ndb == NULL)
{
@ -4291,13 +4295,13 @@ err:
DBUG_PRINT("info",("Shutting down cluster binlog thread"));
thd->proc_info= "Shutting down";
close_thread_tables(thd);
pthread_mutex_lock(&injector_mutex);
mysql_mutex_lock(&injector_mutex);
/* don't mess with the injector_ndb anymore from other threads */
injector_thd= 0;
injector_ndb= 0;
p_latest_trans_gci= 0;
schema_ndb= 0;
pthread_mutex_unlock(&injector_mutex);
mysql_mutex_unlock(&injector_mutex);
thd->db= 0; // as not to try to free memory
if (ndb_apply_status_share)
@ -4312,7 +4316,7 @@ err:
if (ndb_schema_share)
{
/* begin protect ndb_schema_share */
pthread_mutex_lock(&ndb_schema_share_mutex);
mysql_mutex_lock(&ndb_schema_share_mutex);
/* ndb_share reference binlog extra free */
DBUG_PRINT("NDB_SHARE", ("%s binlog extra free use_count: %u",
ndb_schema_share->key,
@ -4320,7 +4324,7 @@ err:
free_share(&ndb_schema_share);
ndb_schema_share= 0;
ndb_binlog_tables_inited= 0;
pthread_mutex_unlock(&ndb_schema_share_mutex);
mysql_mutex_unlock(&ndb_schema_share_mutex);
/* end protect ndb_schema_share */
}
@ -4380,7 +4384,7 @@ err:
ndb_binlog_thread_running= -1;
ndb_binlog_running= FALSE;
(void) pthread_cond_signal(&injector_cond);
mysql_cond_signal(&injector_cond);
DBUG_PRINT("exit", ("ndb_binlog_thread"));
@ -4399,12 +4403,12 @@ ndbcluster_show_status_binlog(THD* thd, stat_print_fn *stat_print,
ulonglong ndb_latest_epoch= 0;
DBUG_ENTER("ndbcluster_show_status_binlog");
pthread_mutex_lock(&injector_mutex);
mysql_mutex_lock(&injector_mutex);
if (injector_ndb)
{
char buff1[22],buff2[22],buff3[22],buff4[22],buff5[22];
ndb_latest_epoch= injector_ndb->getLatestGCI();
pthread_mutex_unlock(&injector_mutex);
mysql_mutex_unlock(&injector_mutex);
buflen=
snprintf(buf, sizeof(buf),
@ -4424,7 +4428,7 @@ ndbcluster_show_status_binlog(THD* thd, stat_print_fn *stat_print,
DBUG_RETURN(TRUE);
}
else
pthread_mutex_unlock(&injector_mutex);
mysql_mutex_unlock(&injector_mutex);
DBUG_RETURN(FALSE);
}

20
sql/ha_ndbcluster_binlog.h
View File

@ -1,7 +1,7 @@
#ifndef HA_NDBCLUSTER_BINLOG_INCLUDED
#define HA_NDBCLUSTER_BINLOG_INCLUDED
/* Copyright (C) 2000-2003 MySQL AB
/* Copyright (C) 2000-2003 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -104,16 +104,24 @@ private:
};
#ifdef HAVE_NDB_BINLOG
#ifdef HAVE_PSI_INTERFACE
extern PSI_mutex_key key_injector_mutex, key_ndb_schema_share_mutex,
key_ndb_schema_object_mutex;
extern PSI_cond_key key_injector_cond;
extern PSI_thread_key key_thread_ndb_binlog;
#endif /* HAVE_PSI_INTERFACE */
extern pthread_t ndb_binlog_thread;
extern pthread_mutex_t injector_mutex;
extern pthread_cond_t injector_cond;
extern mysql_mutex_t injector_mutex;
extern mysql_cond_t injector_cond;
extern unsigned char g_node_id_map[max_ndb_nodes];
extern pthread_t ndb_util_thread;
extern pthread_mutex_t LOCK_ndb_util_thread;
extern pthread_cond_t COND_ndb_util_thread;
extern mysql_mutex_t LOCK_ndb_util_thread;
extern mysql_cond_t COND_ndb_util_thread;
extern int ndbcluster_util_inited;
extern pthread_mutex_t ndbcluster_mutex;
extern mysql_mutex_t ndbcluster_mutex;
extern HASH ndbcluster_open_tables;
extern Ndb_cluster_connection* g_ndb_cluster_connection;
extern long ndb_number_of_storage_nodes;

60
sql/ha_partition.cc
View File

@ -500,9 +500,9 @@ int ha_partition::create_handler_files(const char *path,
strxmov(name, path, ha_par_ext, NullS);
strxmov(old_name, old_path, ha_par_ext, NullS);
if ((action_flag == CHF_DELETE_FLAG &&
my_delete(name, MYF(MY_WME))) ||
mysql_file_delete(key_file_partition, name, MYF(MY_WME))) ||
(action_flag == CHF_RENAME_FLAG &&
my_rename(old_name, name, MYF(MY_WME))))
mysql_file_rename(key_file_partition, old_name, name, MYF(MY_WME))))
{
DBUG_RETURN(TRUE);
}
@ -2205,12 +2205,13 @@ bool ha_partition::create_handler_file(const char *name)
to be used at open, delete_table and rename_table
*/
fn_format(file_name, name, "", ha_par_ext, MY_APPEND_EXT);
if ((file= my_create(file_name, CREATE_MODE, O_RDWR | O_TRUNC,
MYF(MY_WME))) >= 0)
if ((file= mysql_file_create(key_file_partition,
file_name, CREATE_MODE, O_RDWR | O_TRUNC,
MYF(MY_WME))) >= 0)
{
result= my_write(file, (uchar *) file_buffer, tot_len_byte,
MYF(MY_WME | MY_NABP)) != 0;
(void) my_close(file, MYF(0));
result= mysql_file_write(file, (uchar *) file_buffer, tot_len_byte,
MYF(MY_WME | MY_NABP)) != 0;
(void) mysql_file_close(file, MYF(0));
}
else
result= TRUE;
@ -2387,17 +2388,18 @@ bool ha_partition::get_from_handler_file(const char *name, MEM_ROOT *mem_root)
DBUG_RETURN(FALSE);
fn_format(buff, name, "", ha_par_ext, MY_APPEND_EXT);
/* Following could be done with my_stat to read in whole file */
if ((file= my_open(buff, O_RDONLY | O_SHARE, MYF(0))) < 0)
/* Following could be done with mysql_file_stat to read in whole file */
if ((file= mysql_file_open(key_file_partition,
buff, O_RDONLY | O_SHARE, MYF(0))) < 0)
DBUG_RETURN(TRUE);
if (my_read(file, (uchar *) & buff[0], 8, MYF(MY_NABP)))
if (mysql_file_read(file, (uchar *) &buff[0], 8, MYF(MY_NABP)))
goto err1;
len_words= uint4korr(buff);
len_bytes= 4 * len_words;
if (!(file_buffer= (char*) my_malloc(len_bytes, MYF(0))))
goto err1;
my_seek(file, 0, MY_SEEK_SET, MYF(0));
if (my_read(file, (uchar *) file_buffer, len_bytes, MYF(MY_NABP)))
mysql_file_seek(file, 0, MY_SEEK_SET, MYF(0));
if (mysql_file_read(file, (uchar *) file_buffer, len_bytes, MYF(MY_NABP)))
goto err2;
chksum= 0;
@ -2418,7 +2420,7 @@ bool ha_partition::get_from_handler_file(const char *name, MEM_ROOT *mem_root)
if (len_words != (tot_partition_words + tot_name_words + 4))
goto err3;
name_buffer_ptr= file_buffer + 16 + 4 * tot_partition_words;
(void) my_close(file, MYF(0));
(void) mysql_file_close(file, MYF(0));
m_file_buffer= file_buffer; // Will be freed in clear_handler_file()
m_name_buffer_ptr= name_buffer_ptr;
@ -2443,7 +2445,7 @@ err3:
err2:
my_free(file_buffer, MYF(0));
err1:
(void) my_close(file, MYF(0));
(void) mysql_file_close(file, MYF(0));
DBUG_RETURN(TRUE);
}
@ -2606,7 +2608,7 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
for the same table.
*/
if (is_not_tmp_table)
pthread_mutex_lock(&table_share->mutex);
mysql_mutex_lock(&table_share->mutex);
if (!table_share->ha_data)
{
HA_DATA_PARTITION *ha_data;
@ -2617,7 +2619,7 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
if (!ha_data)
{
if (is_not_tmp_table)
pthread_mutex_unlock(&table_share->mutex);
mysql_mutex_unlock(&table_share->mutex);
goto err_handler;
}
DBUG_PRINT("info", ("table_share->ha_data 0x%p", ha_data));
@ -2626,7 +2628,7 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
pthread_mutex_init(&ha_data->mutex, MY_MUTEX_INIT_FAST);
}
if (is_not_tmp_table)
pthread_mutex_unlock(&table_share->mutex);
mysql_mutex_unlock(&table_share->mutex);
/*
Some handlers update statistics as part of the open call. This will in
some cases corrupt the statistics of the partition handler and thus
@ -6633,7 +6635,7 @@ int ha_partition::indexes_are_disabled(void)
#ifdef NOT_USED
static HASH partition_open_tables;
static pthread_mutex_t partition_mutex;
static mysql_mutex_t partition_mutex;
static int partition_init= 0;
@ -6671,17 +6673,17 @@ static PARTITION_SHARE *get_share(const char *table_name, TABLE *table)
if (!partition_init)
{
/* Hijack a mutex for init'ing the storage engine */
pthread_mutex_lock(&LOCK_mysql_create_db);
mysql_mutex_lock(&LOCK_mysql_create_db);
if (!partition_init)
{
partition_init++;
pthread_mutex_init(&partition_mutex, MY_MUTEX_INIT_FAST);
mysql_mutex_init(INSTRUMENT_ME, &partition_mutex, MY_MUTEX_INIT_FAST);
(void) hash_init(&partition_open_tables, system_charset_info, 32, 0, 0,
(hash_get_key) partition_get_key, 0, 0);
}
pthread_mutex_unlock(&LOCK_mysql_create_db);
mysql_mutex_unlock(&LOCK_mysql_create_db);
}
pthread_mutex_lock(&partition_mutex);
mysql_mutex_lock(&partition_mutex);
length= (uint) strlen(table_name);
if (!(share= (PARTITION_SHARE *) hash_search(&partition_open_tables,
@ -6692,7 +6694,7 @@ static PARTITION_SHARE *get_share(const char *table_name, TABLE *table)
&share, (uint) sizeof(*share),
&tmp_name, (uint) length + 1, NullS)))
{
pthread_mutex_unlock(&partition_mutex);
mysql_mutex_unlock(&partition_mutex);
return NULL;
}
@ -6703,15 +6705,15 @@ static PARTITION_SHARE *get_share(const char *table_name, TABLE *table)
if (my_hash_insert(&partition_open_tables, (uchar *) share))
goto error;
thr_lock_init(&share->lock);
pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST);
mysql_mutex_init(INSTRUMENT_ME, &share->mutex, MY_MUTEX_INIT_FAST);
}
share->use_count++;
pthread_mutex_unlock(&partition_mutex);
mysql_mutex_unlock(&partition_mutex);
return share;
error:
pthread_mutex_unlock(&partition_mutex);
mysql_mutex_unlock(&partition_mutex);
my_free((uchar*) share, MYF(0));
return NULL;
@ -6726,15 +6728,15 @@ error:
static int free_share(PARTITION_SHARE *share)
{
pthread_mutex_lock(&partition_mutex);
mysql_mutex_lock(&partition_mutex);
if (!--share->use_count)
{
hash_delete(&partition_open_tables, (uchar *) share);
thr_lock_delete(&share->lock);
pthread_mutex_destroy(&share->mutex);
mysql_mutex_destroy(&share->mutex);
my_free((uchar*) share, MYF(0));
}
pthread_mutex_unlock(&partition_mutex);
mysql_mutex_unlock(&partition_mutex);
return 0;
}

6
sql/ha_partition.h
View File

@ -36,7 +36,7 @@ typedef struct st_partition_share
{
char *table_name;
uint table_name_length, use_count;
pthread_mutex_t mutex;
mysql_mutex_t mutex;
THR_LOCK lock;
} PARTITION_SHARE;
#endif
@ -933,7 +933,7 @@ private:
if(table_share->tmp_table == NO_TMP_TABLE)
{
auto_increment_lock= TRUE;
pthread_mutex_lock(&table_share->mutex);
mysql_mutex_lock(&table_share->mutex);
}
}
virtual void unlock_auto_increment()
@ -946,7 +946,7 @@ private:
*/
if(auto_increment_lock && !auto_increment_safe_stmt_log_lock)
{
pthread_mutex_unlock(&table_share->mutex);
mysql_mutex_unlock(&table_share->mutex);
auto_increment_lock= FALSE;
}
}

38
sql/handler.cc
View File

@ -1,4 +1,4 @@
/* Copyright 2000-2008 MySQL AB, 2008 Sun Microsystems, Inc.
/* Copyright 2000-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -1682,7 +1682,7 @@ bool mysql_xa_recover(THD *thd)
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
DBUG_RETURN(1);
pthread_mutex_lock(&LOCK_xid_cache);
mysql_mutex_lock(&LOCK_xid_cache);
while ((xs= (XID_STATE*) my_hash_element(&xid_cache, i++)))
{
if (xs->xa_state==XA_PREPARED)
@ -1695,13 +1695,13 @@ bool mysql_xa_recover(THD *thd)
&my_charset_bin);
if (protocol->write())
{
pthread_mutex_unlock(&LOCK_xid_cache);
mysql_mutex_unlock(&LOCK_xid_cache);
DBUG_RETURN(1);
}
}
}
pthread_mutex_unlock(&LOCK_xid_cache);
mysql_mutex_unlock(&LOCK_xid_cache);
my_eof(thd);
DBUG_RETURN(0);
}
@ -2104,6 +2104,10 @@ THD *handler::ha_thd(void) const
return (table && table->in_use) ? table->in_use : current_thd;
}
PSI_table_share *handler::ha_table_share_psi(const TABLE_SHARE *share) const
{
return share->m_psi;
}
/** @brief
Open database-handler.
@ -2993,7 +2997,8 @@ static bool update_frm_version(TABLE *table)
strxmov(path, table->s->normalized_path.str, reg_ext, NullS);
if ((file= my_open(path, O_RDWR|O_BINARY, MYF(MY_WME))) >= 0)
if ((file= mysql_file_open(key_file_frm,
path, O_RDWR|O_BINARY, MYF(MY_WME))) >= 0)
{
uchar version[4];
char *key= table->s->table_cache_key.str;
@ -3003,7 +3008,7 @@ static bool update_frm_version(TABLE *table)
int4store(version, MYSQL_VERSION_ID);
if ((result= my_pwrite(file,(uchar*) version,4,51L,MYF_RW)))
if ((result= mysql_file_pwrite(file, (uchar*) version, 4, 51L, MYF_RW)))
goto err;
for (entry=(TABLE*) my_hash_first(&open_cache,(uchar*) key,key_length, &state);
@ -3013,7 +3018,7 @@ static bool update_frm_version(TABLE *table)
}
err:
if (file >= 0)
(void) my_close(file,MYF(MY_WME));
(void) mysql_file_close(file, MYF(MY_WME));
DBUG_RETURN(result);
}
@ -3060,7 +3065,7 @@ int handler::delete_table(const char *name)
for (const char **ext=bas_ext(); *ext ; ext++)
{
fn_format(buff, name, "", *ext, MY_UNPACK_FILENAME|MY_APPEND_EXT);
if (my_delete_with_symlink(buff, MYF(0)))
if (mysql_file_delete_with_symlink(key_file_misc, buff, MYF(0)))
{
if (my_errno != ENOENT)
{
@ -3717,12 +3722,12 @@ int ha_init_key_cache(const char *name, KEY_CACHE *key_cache)
if (!key_cache->key_cache_inited)
{
pthread_mutex_lock(&LOCK_global_system_variables);
mysql_mutex_lock(&LOCK_global_system_variables);
size_t tmp_buff_size= (size_t) key_cache->param_buff_size;
uint tmp_block_size= (uint) key_cache->param_block_size;
uint division_limit= key_cache->param_division_limit;
uint age_threshold= key_cache->param_age_threshold;
pthread_mutex_unlock(&LOCK_global_system_variables);
mysql_mutex_unlock(&LOCK_global_system_variables);
DBUG_RETURN(!init_key_cache(key_cache,
tmp_block_size,
tmp_buff_size,
@ -3741,12 +3746,12 @@ int ha_resize_key_cache(KEY_CACHE *key_cache)
if (key_cache->key_cache_inited)
{
pthread_mutex_lock(&LOCK_global_system_variables);
mysql_mutex_lock(&LOCK_global_system_variables);
size_t tmp_buff_size= (size_t) key_cache->param_buff_size;
long tmp_block_size= (long) key_cache->param_block_size;
uint division_limit= key_cache->param_division_limit;
uint age_threshold= key_cache->param_age_threshold;
pthread_mutex_unlock(&LOCK_global_system_variables);
mysql_mutex_unlock(&LOCK_global_system_variables);
DBUG_RETURN(!resize_key_cache(key_cache, tmp_block_size,
tmp_buff_size,
division_limit, age_threshold));
@ -3762,10 +3767,10 @@ int ha_change_key_cache_param(KEY_CACHE *key_cache)
{
if (key_cache->key_cache_inited)
{
pthread_mutex_lock(&LOCK_global_system_variables);
mysql_mutex_lock(&LOCK_global_system_variables);
uint division_limit= key_cache->param_division_limit;
uint age_threshold= key_cache->param_age_threshold;
pthread_mutex_unlock(&LOCK_global_system_variables);
mysql_mutex_unlock(&LOCK_global_system_variables);
change_key_cache_param(key_cache, division_limit, age_threshold);
}
return 0;
@ -4794,7 +4799,8 @@ int example_of_iterator_using_for_logs_cleanup(handlerton *hton)
{
printf("%s\n", data.filename.str);
if (data.status == HA_LOG_STATUS_FREE &&
my_delete(data.filename.str, MYF(MY_WME)))
mysql_file_delete(INSTRUMENT_ME,
data.filename.str, MYF(MY_WME)))
goto err;
}
res= 0;
@ -4822,7 +4828,7 @@ err:
enum log_status fl_get_log_status(char *log)
{
MY_STAT stat_buff;
if (my_stat(log, &stat_buff, MYF(0)))
if (mysql_file_stat(INSTRUMENT_ME, log, &stat_buff, MYF(0)))
return HA_LOG_STATUS_INUSE;
return HA_LOG_STATUS_NOSUCHLOG;
}

55
sql/handler.h
View File

@ -1,7 +1,7 @@
#ifndef HANDLER_INCLUDED
#define HANDLER_INCLUDED
/* Copyright 2000-2008 MySQL AB, 2008 Sun Microsystems, Inc.
/* Copyright 2000-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -16,7 +16,6 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/* Definitions for parameters to do with handler-routines */
#ifdef USE_PRAGMA_INTERFACE
@ -305,6 +304,8 @@ enum legacy_db_type
DB_TYPE_MEMCACHE,
DB_TYPE_FALCON,
DB_TYPE_MARIA,
/** Performance schema engine. */
DB_TYPE_PERFORMANCE_SCHEMA,
DB_TYPE_FIRST_DYNAMIC=42,
DB_TYPE_DEFAULT=127 // Must be last
};
@ -1216,6 +1217,20 @@ public:
*/
uint auto_inc_intervals_count;
/**
Instrumented table associated with this handler.
This member should be set to NULL when no instrumentation is in place,
so that linking an instrumented/non instrumented server/plugin works.
For example:
- the server is compiled with the instrumentation.
The server expects either NULL or valid pointers in m_psi.
- an engine plugin is compiled without instrumentation.
The plugin can not leave this pointer uninitialized,
or can not leave a trash value on purpose in this pointer,
as this would crash the server.
*/
PSI_table *m_psi;
handler(handlerton *ht_arg, TABLE_SHARE *share_arg)
:table_share(share_arg), table(0),
estimation_rows_to_insert(0), ht(ht_arg),
@ -1224,7 +1239,8 @@ public:
ft_handler(0), inited(NONE),
locked(FALSE), implicit_emptied(0),
pushed_cond(0), next_insert_id(0), insert_id_for_cur_row(0),
auto_inc_intervals_count(0)
auto_inc_intervals_count(0),
m_psi(NULL)
{}
virtual ~handler(void)
{
@ -1824,6 +1840,39 @@ protected:
void **ha_data(THD *) const;
THD *ha_thd(void) const;
/**
Acquire the instrumented table information from a table share.
@param share a table share
@return an instrumented table share, or NULL.
*/
PSI_table_share *ha_table_share_psi(const TABLE_SHARE *share) const;
inline void psi_open()
{
DBUG_ASSERT(m_psi == NULL);
DBUG_ASSERT(table_share != NULL);
#ifdef HAVE_PSI_INTERFACE
if (PSI_server)
{
PSI_table_share *share_psi= ha_table_share_psi(table_share);
if (share_psi)
m_psi= PSI_server->open_table(share_psi, this);
}
#endif
}
inline void psi_close()
{
#ifdef HAVE_PSI_INTERFACE
if (PSI_server && m_psi)
{
PSI_server->close_table(m_psi);
m_psi= NULL; /* instrumentation handle, invalid after close_table() */
}
#endif
DBUG_ASSERT(m_psi == NULL);
}
/**
Default rename_table() and delete_table() rename/delete files with a
given name and extensions from bas_ext().

12
sql/hash_filo.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2000-2003, 2005 MySQL AB
/* Copyright (C) 2000-2003, 2005 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -45,7 +45,7 @@ class hash_filo
hash_filo_element *first_link,*last_link;
public:
pthread_mutex_t lock;
mysql_mutex_t lock;
HASH cache;
hash_filo(uint size_arg, uint key_offset_arg , uint key_length_arg,
@ -64,7 +64,7 @@ public:
{
if (cache.array.buffer) /* Avoid problems with thread library */
(void) my_hash_free(&cache);
pthread_mutex_destroy(&lock);
mysql_mutex_destroy(&lock);
}
}
void clear(bool locked=0)
@ -72,15 +72,15 @@ public:
if (!init)
{
init=1;
(void) pthread_mutex_init(&lock,MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_hash_filo_lock, &lock, MY_MUTEX_INIT_FAST);
}
if (!locked)
(void) pthread_mutex_lock(&lock);
mysql_mutex_lock(&lock);
(void) my_hash_free(&cache);
(void) my_hash_init(&cache,hash_charset,size,key_offset,
key_length, get_key, free_element,0);
if (!locked)
(void) pthread_mutex_unlock(&lock);
mysql_mutex_unlock(&lock);
first_link=last_link=0;
}

20
sql/hostname.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2000-2006 MySQL AB
/* Copyright (C) 2000-2006 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -169,11 +169,11 @@ static bool add_hostname(const char *ip_key, const char *hostname)
if (specialflag & SPECIAL_NO_HOST_CACHE)
return FALSE;
pthread_mutex_lock(&hostname_cache->lock);
mysql_mutex_lock(&hostname_cache->lock);
bool err_status= add_hostname_impl(ip_key, hostname);
pthread_mutex_unlock(&hostname_cache->lock);
mysql_mutex_unlock(&hostname_cache->lock);
return err_status;
}
@ -186,14 +186,14 @@ void inc_host_errors(const char *ip_string)
char ip_key[HOST_ENTRY_KEY_SIZE];
prepare_hostname_cache_key(ip_string, ip_key);
pthread_mutex_lock(&hostname_cache->lock);
mysql_mutex_lock(&hostname_cache->lock);
Host_entry *entry= hostname_cache_search(ip_key);
if (entry)
entry->connect_errors++;
pthread_mutex_unlock(&hostname_cache->lock);
mysql_mutex_unlock(&hostname_cache->lock);
}
@ -205,14 +205,14 @@ void reset_host_errors(const char *ip_string)
char ip_key[HOST_ENTRY_KEY_SIZE];
prepare_hostname_cache_key(ip_string, ip_key);
pthread_mutex_lock(&hostname_cache->lock);
mysql_mutex_lock(&hostname_cache->lock);
Host_entry *entry= hostname_cache_search(ip_key);
if (entry)
entry->connect_errors= 0;
pthread_mutex_unlock(&hostname_cache->lock);
mysql_mutex_unlock(&hostname_cache->lock);
}
@ -319,7 +319,7 @@ bool ip_to_hostname(struct sockaddr_storage *ip_storage,
if (!(specialflag & SPECIAL_NO_HOST_CACHE))
{
pthread_mutex_lock(&hostname_cache->lock);
mysql_mutex_lock(&hostname_cache->lock);
Host_entry *entry= hostname_cache_search(ip_key);
@ -337,12 +337,12 @@ bool ip_to_hostname(struct sockaddr_storage *ip_storage,
(const char *) (*hostname? *hostname : "null"),
(int) *connect_errors));
pthread_mutex_unlock(&hostname_cache->lock);
mysql_mutex_unlock(&hostname_cache->lock);
DBUG_RETURN(FALSE);
}
pthread_mutex_unlock(&hostname_cache->lock);
mysql_mutex_unlock(&hostname_cache->lock);
}
/*

28
sql/item_func.cc
View File

@ -5008,7 +5008,7 @@ void Item_func_get_system_var::fix_length_and_dec()
break;
case SHOW_CHAR:
case SHOW_CHAR_PTR:
pthread_mutex_lock(&LOCK_global_system_variables);
mysql_mutex_lock(&LOCK_global_system_variables);
cptr= var->show_type() == SHOW_CHAR ?
(char*) var->value_ptr(current_thd, var_type, &component) :
*(char**) var->value_ptr(current_thd, var_type, &component);
@ -5016,19 +5016,19 @@ void Item_func_get_system_var::fix_length_and_dec()
max_length= system_charset_info->cset->numchars(system_charset_info,
cptr,
cptr + strlen(cptr));
pthread_mutex_unlock(&LOCK_global_system_variables);
mysql_mutex_unlock(&LOCK_global_system_variables);
collation.set(system_charset_info, DERIVATION_SYSCONST);
max_length*= system_charset_info->mbmaxlen;
decimals=NOT_FIXED_DEC;
break;
case SHOW_LEX_STRING:
{
pthread_mutex_lock(&LOCK_global_system_variables);
mysql_mutex_lock(&LOCK_global_system_variables);
LEX_STRING *ls= ((LEX_STRING*)var->value_ptr(current_thd, var_type, &component));
max_length= system_charset_info->cset->numchars(system_charset_info,
ls->str,
ls->str + ls->length);
pthread_mutex_unlock(&LOCK_global_system_variables);
mysql_mutex_unlock(&LOCK_global_system_variables);
collation.set(system_charset_info, DERIVATION_SYSCONST);
max_length*= system_charset_info->mbmaxlen;
decimals=NOT_FIXED_DEC;
@ -5113,9 +5113,9 @@ enum_field_types Item_func_get_system_var::field_type() const
#define get_sys_var_safe(type) \
do { \
type value; \
pthread_mutex_lock(&LOCK_global_system_variables); \
mysql_mutex_lock(&LOCK_global_system_variables); \
value= *(type*) var->value_ptr(thd, var_type, &component); \
pthread_mutex_unlock(&LOCK_global_system_variables); \
mysql_mutex_unlock(&LOCK_global_system_variables); \
cache_present |= GET_SYS_VAR_CACHE_LONG; \
used_query_id= thd->query_id; \
cached_llval= null_value ? 0 : (longlong) value; \
@ -5238,7 +5238,7 @@ String* Item_func_get_system_var::val_str(String* str)
case SHOW_CHAR_PTR:
case SHOW_LEX_STRING:
{
pthread_mutex_lock(&LOCK_global_system_variables);
mysql_mutex_lock(&LOCK_global_system_variables);
char *cptr= var->show_type() == SHOW_CHAR ?
(char*) var->value_ptr(thd, var_type, &component) :
*(char**) var->value_ptr(thd, var_type, &component);
@ -5258,7 +5258,7 @@ String* Item_func_get_system_var::val_str(String* str)
null_value= TRUE;
str= NULL;
}
pthread_mutex_unlock(&LOCK_global_system_variables);
mysql_mutex_unlock(&LOCK_global_system_variables);
break;
}
@ -5323,9 +5323,9 @@ double Item_func_get_system_var::val_real()
switch (var->show_type())
{
case SHOW_DOUBLE:
pthread_mutex_lock(&LOCK_global_system_variables);
mysql_mutex_lock(&LOCK_global_system_variables);
cached_dval= *(double*) var->value_ptr(thd, var_type, &component);
pthread_mutex_unlock(&LOCK_global_system_variables);
mysql_mutex_unlock(&LOCK_global_system_variables);
used_query_id= thd->query_id;
cached_null_value= null_value;
if (null_value)
@ -5336,7 +5336,7 @@ double Item_func_get_system_var::val_real()
case SHOW_LEX_STRING:
case SHOW_CHAR_PTR:
{
pthread_mutex_lock(&LOCK_global_system_variables);
mysql_mutex_lock(&LOCK_global_system_variables);
char *cptr= var->show_type() == SHOW_CHAR ?
(char*) var->value_ptr(thd, var_type, &component) :
*(char**) var->value_ptr(thd, var_type, &component);
@ -5348,7 +5348,7 @@ double Item_func_get_system_var::val_real()
null_value= TRUE;
cached_dval= 0;
}
pthread_mutex_unlock(&LOCK_global_system_variables);
mysql_mutex_unlock(&LOCK_global_system_variables);
used_query_id= thd->query_id;
cached_null_value= null_value;
cache_present|= GET_SYS_VAR_CACHE_DOUBLE;
@ -6281,8 +6281,8 @@ void uuid_short_init()
longlong Item_func_uuid_short::val_int()
{
ulonglong val;
pthread_mutex_lock(&LOCK_uuid_generator);
mysql_mutex_lock(&LOCK_uuid_generator);
val= uuid_value++;
pthread_mutex_unlock(&LOCK_uuid_generator);
mysql_mutex_unlock(&LOCK_uuid_generator);
return (longlong) val;
}

36
sql/item_strfunc.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2000-2006 MySQL AB
/* Copyright (C) 2000-2006 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -465,18 +465,18 @@ String *Item_func_des_encrypt::val_str(String *str)
if (arg_count == 1)
{
/* Protect against someone doing FLUSH DES_KEY_FILE */
pthread_mutex_lock(&LOCK_des_key_file);
mysql_mutex_lock(&LOCK_des_key_file);
keyschedule= des_keyschedule[key_number=des_default_key];
pthread_mutex_unlock(&LOCK_des_key_file);
mysql_mutex_unlock(&LOCK_des_key_file);
}
else if (args[1]->result_type() == INT_RESULT)
{
key_number= (uint) args[1]->val_int();
if (key_number > 9)
goto error;
pthread_mutex_lock(&LOCK_des_key_file);
mysql_mutex_lock(&LOCK_des_key_file);
keyschedule= des_keyschedule[key_number];
pthread_mutex_unlock(&LOCK_des_key_file);
mysql_mutex_unlock(&LOCK_des_key_file);
}
else
{
@ -566,9 +566,9 @@ String *Item_func_des_decrypt::val_str(String *str)
key_number > 9)
goto error;
pthread_mutex_lock(&LOCK_des_key_file);
mysql_mutex_lock(&LOCK_des_key_file);
keyschedule= des_keyschedule[key_number];
pthread_mutex_unlock(&LOCK_des_key_file);
mysql_mutex_unlock(&LOCK_des_key_file);
}
else
{
@ -1702,17 +1702,17 @@ String *Item_func_encrypt::val_str(String *str)
return 0;
salt_ptr= salt_str->c_ptr_safe();
}
pthread_mutex_lock(&LOCK_crypt);
mysql_mutex_lock(&LOCK_crypt);
char *tmp= crypt(res->c_ptr_safe(),salt_ptr);
if (!tmp)
{
pthread_mutex_unlock(&LOCK_crypt);
mysql_mutex_unlock(&LOCK_crypt);
null_value= 1;
return 0;
}
str->set(tmp, (uint) strlen(tmp), &my_charset_bin);
str->copy();
pthread_mutex_unlock(&LOCK_crypt);
mysql_mutex_unlock(&LOCK_crypt);
return str;
#else
null_value=1;
@ -2998,7 +2998,7 @@ String *Item_load_file::val_str(String *str)
strncmp(opt_secure_file_priv, path, strlen(opt_secure_file_priv)))
goto err;
if (!my_stat(path, &stat_info, MYF(0)))
if (!mysql_file_stat(key_file_loadfile, path, &stat_info, MYF(0)))
goto err;
if (!(stat_info.st_mode & S_IROTH))
@ -3016,15 +3016,17 @@ String *Item_load_file::val_str(String *str)
}
if (tmp_value.alloc(stat_info.st_size))
goto err;
if ((file = my_open(file_name->ptr(), O_RDONLY, MYF(0))) < 0)
if ((file= mysql_file_open(key_file_loadfile,
file_name->ptr(), O_RDONLY, MYF(0))) < 0)
goto err;
if (my_read(file, (uchar*) tmp_value.ptr(), stat_info.st_size, MYF(MY_NABP)))
if (mysql_file_read(file, (uchar*) tmp_value.ptr(), stat_info.st_size,
MYF(MY_NABP)))
{
my_close(file, MYF(0));
mysql_file_close(file, MYF(0));
goto err;
}
tmp_value.length(stat_info.st_size);
my_close(file, MYF(0));
mysql_file_close(file, MYF(0));
null_value = 0;
DBUG_RETURN(&tmp_value);
@ -3468,7 +3470,7 @@ String *Item_func_uuid::val_str(String *str)
char *s;
THD *thd= current_thd;
pthread_mutex_lock(&LOCK_uuid_generator);
mysql_mutex_lock(&LOCK_uuid_generator);
if (! uuid_time) /* first UUID() call. initializing data */
{
ulong tmp=sql_rnd_with_mutex();
@ -3558,7 +3560,7 @@ String *Item_func_uuid::val_str(String *str)
}
uuid_time=tv;
pthread_mutex_unlock(&LOCK_uuid_generator);
mysql_mutex_unlock(&LOCK_uuid_generator);
uint32 time_low= (uint32) (tv & 0xFFFFFFFF);
uint16 time_mid= (uint16) ((tv >> 32) & 0xFFFF);

30
sql/lock.cc
View File

@ -1436,7 +1436,7 @@ bool lock_global_read_lock(THD *thd)
if (!thd->global_read_lock)
{
const char *old_message;
(void) pthread_mutex_lock(&LOCK_global_read_lock);
mysql_mutex_lock(&LOCK_global_read_lock);
old_message=thd->enter_cond(&COND_global_read_lock, &LOCK_global_read_lock,
"Waiting to get readlock");
DBUG_PRINT("info",
@ -1445,7 +1445,7 @@ bool lock_global_read_lock(THD *thd)
waiting_for_read_lock++;
while (protect_against_global_read_lock && !thd->killed)
pthread_cond_wait(&COND_global_read_lock, &LOCK_global_read_lock);
mysql_cond_wait(&COND_global_read_lock, &LOCK_global_read_lock);
waiting_for_read_lock--;
if (thd->killed)
{
@ -1476,16 +1476,16 @@ void unlock_global_read_lock(THD *thd)
("global_read_lock: %u global_read_lock_blocks_commit: %u",
global_read_lock, global_read_lock_blocks_commit));
pthread_mutex_lock(&LOCK_global_read_lock);
mysql_mutex_lock(&LOCK_global_read_lock);
tmp= --global_read_lock;
if (thd->global_read_lock == MADE_GLOBAL_READ_LOCK_BLOCK_COMMIT)
--global_read_lock_blocks_commit;
pthread_mutex_unlock(&LOCK_global_read_lock);
mysql_mutex_unlock(&LOCK_global_read_lock);
/* Send the signal outside the mutex to avoid a context switch */
if (!tmp)
{
DBUG_PRINT("signal", ("Broadcasting COND_global_read_lock"));
pthread_cond_broadcast(&COND_global_read_lock);
mysql_cond_broadcast(&COND_global_read_lock);
}
thd->global_read_lock= 0;
@ -1510,7 +1510,7 @@ bool wait_if_global_read_lock(THD *thd, bool abort_on_refresh,
*/
mysql_mutex_assert_not_owner(&LOCK_open);
(void) pthread_mutex_lock(&LOCK_global_read_lock);
mysql_mutex_lock(&LOCK_global_read_lock);
if ((need_exit_cond= must_wait))
{
if (thd->global_read_lock) // This thread had the read locks
@ -1518,7 +1518,7 @@ bool wait_if_global_read_lock(THD *thd, bool abort_on_refresh,
if (is_not_commit)
my_message(ER_CANT_UPDATE_WITH_READLOCK,
ER(ER_CANT_UPDATE_WITH_READLOCK), MYF(0));
(void) pthread_mutex_unlock(&LOCK_global_read_lock);
mysql_mutex_unlock(&LOCK_global_read_lock);
/*
We allow FLUSHer to COMMIT; we assume FLUSHer knows what it does.
This allowance is needed to not break existing versions of innobackup
@ -1532,7 +1532,7 @@ bool wait_if_global_read_lock(THD *thd, bool abort_on_refresh,
(!abort_on_refresh || thd->version == refresh_version))
{
DBUG_PRINT("signal", ("Waiting for COND_global_read_lock"));
(void) pthread_cond_wait(&COND_global_read_lock, &LOCK_global_read_lock);
mysql_cond_wait(&COND_global_read_lock, &LOCK_global_read_lock);
DBUG_PRINT("signal", ("Got COND_global_read_lock"));
}
if (thd->killed)
@ -1547,7 +1547,7 @@ bool wait_if_global_read_lock(THD *thd, bool abort_on_refresh,
if (unlikely(need_exit_cond))
thd->exit_cond(old_message); // this unlocks LOCK_global_read_lock
else
pthread_mutex_unlock(&LOCK_global_read_lock);
mysql_mutex_unlock(&LOCK_global_read_lock);
DBUG_RETURN(result);
}
@ -1558,13 +1558,13 @@ void start_waiting_global_read_lock(THD *thd)
DBUG_ENTER("start_waiting_global_read_lock");
if (unlikely(thd->global_read_lock))
DBUG_VOID_RETURN;
(void) pthread_mutex_lock(&LOCK_global_read_lock);
mysql_mutex_lock(&LOCK_global_read_lock);
DBUG_ASSERT(protect_against_global_read_lock);
tmp= (!--protect_against_global_read_lock &&
(waiting_for_read_lock || global_read_lock_blocks_commit));
(void) pthread_mutex_unlock(&LOCK_global_read_lock);
mysql_mutex_unlock(&LOCK_global_read_lock);
if (tmp)
pthread_cond_broadcast(&COND_global_read_lock);
mysql_cond_broadcast(&COND_global_read_lock);
DBUG_VOID_RETURN;
}
@ -1580,7 +1580,7 @@ bool make_global_read_lock_block_commit(THD *thd)
*/
if (thd->global_read_lock != GOT_GLOBAL_READ_LOCK)
DBUG_RETURN(0);
pthread_mutex_lock(&LOCK_global_read_lock);
mysql_mutex_lock(&LOCK_global_read_lock);
/* increment this BEFORE waiting on cond (otherwise race cond) */
global_read_lock_blocks_commit++;
/* For testing we set up some blocking, to see if we can be killed */
@ -1589,7 +1589,7 @@ bool make_global_read_lock_block_commit(THD *thd)
old_message= thd->enter_cond(&COND_global_read_lock, &LOCK_global_read_lock,
"Waiting for all running commits to finish");
while (protect_against_global_read_lock && !thd->killed)
pthread_cond_wait(&COND_global_read_lock, &LOCK_global_read_lock);
mysql_cond_wait(&COND_global_read_lock, &LOCK_global_read_lock);
DBUG_EXECUTE_IF("make_global_read_lock_block_commit_loop",
protect_against_global_read_lock--;);
if ((error= test(thd->killed)))
@ -1623,7 +1623,7 @@ bool make_global_read_lock_block_commit(THD *thd)
void broadcast_refresh(void)
{
mysql_cond_broadcast(&COND_refresh);
pthread_cond_broadcast(&COND_global_read_lock);
mysql_cond_broadcast(&COND_global_read_lock);
}
/**

395
sql/log.cc
View File

File diff suppressed because it is too large Load Diff

44
sql/log.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2005 MySQL AB
/* Copyright (C) 2005 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -65,8 +65,8 @@ class TC_LOG_MMAP: public TC_LOG
int size, free; // max and current number of free xid slots on the page
int waiters; // number of waiters on condition
PAGE_STATE state; // see above
pthread_mutex_t lock; // to access page data or control structure
pthread_cond_t cond; // to wait for a sync
mysql_mutex_t lock; // to access page data or control structure
mysql_cond_t cond; // to wait for a sync
} PAGE;
char logname[FN_REFLEN];
@ -81,8 +81,8 @@ class TC_LOG_MMAP: public TC_LOG
one has to use active->lock.
Same for LOCK_pool and LOCK_sync
*/
pthread_mutex_t LOCK_active, LOCK_pool, LOCK_sync;
pthread_cond_t COND_pool, COND_active;
mysql_mutex_t LOCK_active, LOCK_pool, LOCK_sync;
mysql_cond_t COND_pool, COND_active;
public:
TC_LOG_MMAP(): inited(0) {}
@ -136,21 +136,25 @@ extern TC_LOG_DUMMY tc_log_dummy;
class Relay_log_info;
#ifdef HAVE_PSI_INTERFACE
extern PSI_mutex_key key_LOG_INFO_lock;
#endif
typedef struct st_log_info
{
char log_file_name[FN_REFLEN];
my_off_t index_file_offset, index_file_start_offset;
my_off_t pos;
bool fatal; // if the purge happens to give us a negative offset
pthread_mutex_t lock;
mysql_mutex_t lock;
st_log_info()
: index_file_offset(0), index_file_start_offset(0),
pos(0), fatal(0)
{
log_file_name[0] = '\0';
pthread_mutex_init(&lock, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_LOG_INFO_lock, &lock, MY_MUTEX_INIT_FAST);
}
~st_log_info() { pthread_mutex_destroy(&lock);}
~st_log_info() { mysql_mutex_destroy(&lock);}
} LOG_INFO;
/*
@ -198,7 +202,7 @@ public:
int generate_new_name(char *new_name, const char *log_name);
protected:
/* LOCK_log is inited by init_pthread_objects() */
pthread_mutex_t LOCK_log;
mysql_mutex_t LOCK_log;
char *name;
char log_file_name[FN_REFLEN];
char time_buff[20], db[NAME_LEN + 1];
@ -244,10 +248,10 @@ class MYSQL_BIN_LOG: public TC_LOG, private MYSQL_LOG
{
private:
/* LOCK_log and LOCK_index are inited by init_pthread_objects() */
pthread_mutex_t LOCK_index;
pthread_mutex_t LOCK_prep_xids;
pthread_cond_t COND_prep_xids;
pthread_cond_t update_cond;
mysql_mutex_t LOCK_index;
mysql_mutex_t LOCK_prep_xids;
mysql_cond_t COND_prep_xids;
mysql_cond_t update_cond;
ulonglong bytes_written;
IO_CACHE index_file;
char index_file_name[FN_REFLEN];
@ -452,11 +456,11 @@ public:
inline char* get_index_fname() { return index_file_name;}
inline char* get_log_fname() { return log_file_name; }
inline char* get_name() { return name; }
inline pthread_mutex_t* get_log_lock() { return &LOCK_log; }
inline mysql_mutex_t* get_log_lock() { return &LOCK_log; }
inline IO_CACHE* get_log_file() { return &log_file; }
inline void lock_index() { pthread_mutex_lock(&LOCK_index);}
inline void unlock_index() { pthread_mutex_unlock(&LOCK_index);}
inline void lock_index() { mysql_mutex_lock(&LOCK_index);}
inline void unlock_index() { mysql_mutex_unlock(&LOCK_index);}
inline IO_CACHE *get_index_file() { return &index_file;}
inline uint32 get_open_count() { return open_count; }
};
@ -551,7 +555,7 @@ public:
/* Class which manages slow, general and error log event handlers */
class LOGGER
{
rw_lock_t LOCK_logger;
mysql_rwlock_t LOCK_logger;
/* flag to check whether logger mutex is initialized */
uint inited;
@ -571,9 +575,9 @@ public:
LOGGER() : inited(0), table_log_handler(NULL),
file_log_handler(NULL), is_log_tables_initialized(FALSE)
{}
void lock_shared() { rw_rdlock(&LOCK_logger); }
void lock_exclusive() { rw_wrlock(&LOCK_logger); }
void unlock() { rw_unlock(&LOCK_logger); }
void lock_shared() { mysql_rwlock_rdlock(&LOCK_logger); }
void lock_exclusive() { mysql_rwlock_wrlock(&LOCK_logger); }
void unlock() { mysql_rwlock_unlock(&LOCK_logger); }
bool is_log_table_enabled(uint log_table_type);
bool log_command(THD *thd, enum enum_server_command command);

105
sql/log_event.cc
View File

@ -1,4 +1,4 @@
/* Copyright 2000-2008 MySQL AB, 2008 Sun Microsystems, Inc.
/* Copyright 2000-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -497,7 +497,7 @@ static void cleanup_load_tmpdir()
if (is_prefix(file->name, prefbuf))
{
fn_format(fname,file->name,slave_load_tmpdir,"",MY_UNPACK_FILENAME);
my_delete(fname, MYF(0));
mysql_file_delete(key_file_misc, fname, MYF(0));
}
}
@ -967,7 +967,7 @@ bool Log_event::write_header(IO_CACHE* file, ulong event_data_length)
*/
int Log_event::read_log_event(IO_CACHE* file, String* packet,
pthread_mutex_t* log_lock)
mysql_mutex_t* log_lock)
{
ulong data_len;
int result=0;
@ -975,7 +975,7 @@ int Log_event::read_log_event(IO_CACHE* file, String* packet,
DBUG_ENTER("Log_event::read_log_event");
if (log_lock)
pthread_mutex_lock(log_lock);
mysql_mutex_lock(log_lock);
if (my_b_read(file, (uchar*) buf, sizeof(buf)))
{
/*
@ -1033,14 +1033,14 @@ int Log_event::read_log_event(IO_CACHE* file, String* packet,
end:
if (log_lock)
pthread_mutex_unlock(log_lock);
mysql_mutex_unlock(log_lock);
DBUG_RETURN(result);
}
#endif /* !MYSQL_CLIENT */
#ifndef MYSQL_CLIENT
#define UNLOCK_MUTEX if (log_lock) pthread_mutex_unlock(log_lock);
#define LOCK_MUTEX if (log_lock) pthread_mutex_lock(log_lock);
#define UNLOCK_MUTEX if (log_lock) mysql_mutex_unlock(log_lock);
#define LOCK_MUTEX if (log_lock) mysql_mutex_lock(log_lock);
#else
#define UNLOCK_MUTEX
#define LOCK_MUTEX
@ -1052,7 +1052,7 @@ end:
Allocates memory; The caller is responsible for clean-up.
*/
Log_event* Log_event::read_log_event(IO_CACHE* file,
pthread_mutex_t* log_lock,
mysql_mutex_t* log_lock,
const Format_description_log_event
*description_event)
#else
@ -4932,7 +4932,7 @@ int Rotate_log_event::do_update_pos(Relay_log_info *rli)
!is_relay_log_event() &&
!rli->is_in_group())
{
pthread_mutex_lock(&rli->data_lock);
mysql_mutex_lock(&rli->data_lock);
DBUG_PRINT("info", ("old group_master_log_name: '%s' "
"old group_master_log_pos: %lu",
rli->group_master_log_name,
@ -4944,7 +4944,7 @@ int Rotate_log_event::do_update_pos(Relay_log_info *rli)
"new group_master_log_pos: %lu",
rli->group_master_log_name,
(ulong) rli->group_master_log_pos));
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
flush_relay_log_info(rli);
/*
@ -5765,8 +5765,8 @@ Slave_log_event::Slave_log_event(THD* thd_arg,
Master_info* mi = rli->mi;
// TODO: re-write this better without holding both locks at the same time
pthread_mutex_lock(&mi->data_lock);
pthread_mutex_lock(&rli->data_lock);
mysql_mutex_lock(&mi->data_lock);
mysql_mutex_lock(&rli->data_lock);
master_host_len = strlen(mi->host);
master_log_len = strlen(rli->group_master_log_name);
// on OOM, just do not initialize the structure and print the error
@ -5784,8 +5784,8 @@ Slave_log_event::Slave_log_event(THD* thd_arg,
}
else
sql_print_error("Out of memory while recording slave event");
pthread_mutex_unlock(&rli->data_lock);
pthread_mutex_unlock(&mi->data_lock);
mysql_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&mi->data_lock);
DBUG_VOID_RETURN;
}
#endif /* !MYSQL_CLIENT */
@ -6142,10 +6142,12 @@ int Create_file_log_event::do_apply_event(Relay_log_info const *rli)
fname_buf= strmov(proc_info, "Making temp file ");
ext= slave_load_file_stem(fname_buf, file_id, server_id, ".info");
thd_proc_info(thd, proc_info);
my_delete(fname_buf, MYF(0)); // old copy may exist already
if ((fd= my_create(fname_buf, CREATE_MODE,
O_WRONLY | O_BINARY | O_EXCL | O_NOFOLLOW,
MYF(MY_WME))) < 0 ||
/* old copy may exist already */
mysql_file_delete(key_file_log_event_info, fname_buf, MYF(0));
if ((fd= mysql_file_create(key_file_log_event_info,
fname_buf, CREATE_MODE,
O_WRONLY | O_BINARY | O_EXCL | O_NOFOLLOW,
MYF(MY_WME))) < 0 ||
init_io_cache(&file, fd, IO_SIZE, WRITE_CACHE, (my_off_t)0, 0,
MYF(MY_WME|MY_NABP)))
{
@ -6167,20 +6169,22 @@ int Create_file_log_event::do_apply_event(Relay_log_info const *rli)
goto err;
}
end_io_cache(&file);
my_close(fd, MYF(0));
mysql_file_close(fd, MYF(0));
// fname_buf now already has .data, not .info, because we did our trick
my_delete(fname_buf, MYF(0)); // old copy may exist already
if ((fd= my_create(fname_buf, CREATE_MODE,
O_WRONLY | O_BINARY | O_EXCL | O_NOFOLLOW,
MYF(MY_WME))) < 0)
/* old copy may exist already */
mysql_file_delete(key_file_log_event_data, fname_buf, MYF(0));
if ((fd= mysql_file_create(key_file_log_event_data,
fname_buf, CREATE_MODE,
O_WRONLY | O_BINARY | O_EXCL | O_NOFOLLOW,
MYF(MY_WME))) < 0)
{
rli->report(ERROR_LEVEL, my_errno,
"Error in Create_file event: could not open file '%s'",
fname_buf);
goto err;
}
if (my_write(fd, (uchar*) block, block_len, MYF(MY_WME+MY_NABP)))
if (mysql_file_write(fd, (uchar*) block, block_len, MYF(MY_WME+MY_NABP)))
{
rli->report(ERROR_LEVEL, my_errno,
"Error in Create_file event: write to '%s' failed",
@ -6193,7 +6197,7 @@ err:
if (error)
end_io_cache(&file);
if (fd >= 0)
my_close(fd, MYF(0));
mysql_file_close(fd, MYF(0));
thd_proc_info(thd, 0);
return error != 0;
}
@ -6325,10 +6329,12 @@ int Append_block_log_event::do_apply_event(Relay_log_info const *rli)
*/
lex_start(thd);
mysql_reset_thd_for_next_command(thd);
my_delete(fname, MYF(0)); // old copy may exist already
if ((fd= my_create(fname, CREATE_MODE,
O_WRONLY | O_BINARY | O_EXCL | O_NOFOLLOW,
MYF(MY_WME))) < 0)
/* old copy may exist already */
mysql_file_delete(key_file_log_event_data, fname, MYF(0));
if ((fd= mysql_file_create(key_file_log_event_data,
fname, CREATE_MODE,
O_WRONLY | O_BINARY | O_EXCL | O_NOFOLLOW,
MYF(MY_WME))) < 0)
{
rli->report(ERROR_LEVEL, my_errno,
"Error in %s event: could not create file '%s'",
@ -6336,8 +6342,10 @@ int Append_block_log_event::do_apply_event(Relay_log_info const *rli)
goto err;
}
}
else if ((fd = my_open(fname, O_WRONLY | O_APPEND | O_BINARY | O_NOFOLLOW,
MYF(MY_WME))) < 0)
else if ((fd= mysql_file_open(key_file_log_event_data,
fname,
O_WRONLY | O_APPEND | O_BINARY | O_NOFOLLOW,
MYF(MY_WME))) < 0)
{
rli->report(ERROR_LEVEL, my_errno,
"Error in %s event: could not open file '%s'",
@ -6345,10 +6353,14 @@ int Append_block_log_event::do_apply_event(Relay_log_info const *rli)
goto err;
}
DBUG_EXECUTE_IF("remove_slave_load_file_before_write",
my_close(fd,MYF(0)); fd= -1; my_delete(fname, MYF(0)););
DBUG_EXECUTE_IF("remove_slave_load_file_before_write",
{
mysql_file_close(fd, MYF(0));
fd= -1;
mysql_file_delete(0, fname, MYF(0));
});
if (my_write(fd, (uchar*) block, block_len, MYF(MY_WME+MY_NABP)))
if (mysql_file_write(fd, (uchar*) block, block_len, MYF(MY_WME+MY_NABP)))
{
rli->report(ERROR_LEVEL, my_errno,
"Error in %s event: write to '%s' failed",
@ -6359,7 +6371,7 @@ int Append_block_log_event::do_apply_event(Relay_log_info const *rli)
err:
if (fd >= 0)
my_close(fd, MYF(0));
mysql_file_close(fd, MYF(0));
thd_proc_info(thd, 0);
DBUG_RETURN(error);
}
@ -6453,9 +6465,9 @@ int Delete_file_log_event::do_apply_event(Relay_log_info const *rli)
{
char fname[FN_REFLEN+10];
char *ext= slave_load_file_stem(fname, file_id, server_id, ".data");
(void) my_delete(fname, MYF(MY_WME));
mysql_file_delete(key_file_log_event_data, fname, MYF(MY_WME));
strmov(ext, ".info");
(void) my_delete(fname, MYF(MY_WME));
mysql_file_delete(key_file_log_event_info, fname, MYF(MY_WME));
return 0;
}
#endif /* defined(HAVE_REPLICATION) && !defined(MYSQL_CLIENT) */
@ -6556,8 +6568,9 @@ int Execute_load_log_event::do_apply_event(Relay_log_info const *rli)
Load_log_event *lev= 0;
ext= slave_load_file_stem(fname, file_id, server_id, ".info");
if ((fd = my_open(fname, O_RDONLY | O_BINARY | O_NOFOLLOW,
MYF(MY_WME))) < 0 ||
if ((fd= mysql_file_open(key_file_log_event_info,
fname, O_RDONLY | O_BINARY | O_NOFOLLOW,
MYF(MY_WME))) < 0 ||
init_io_cache(&file, fd, IO_SIZE, READ_CACHE, (my_off_t)0, 0,
MYF(MY_WME|MY_NABP)))
{
@ -6567,7 +6580,7 @@ int Execute_load_log_event::do_apply_event(Relay_log_info const *rli)
goto err;
}
if (!(lev = (Load_log_event*)Log_event::read_log_event(&file,
(pthread_mutex_t*)0,
(mysql_mutex_t*)0,
rli->relay_log.description_event_for_exec)) ||
lev->get_type_code() != NEW_LOAD_EVENT)
{
@ -6607,24 +6620,24 @@ int Execute_load_log_event::do_apply_event(Relay_log_info const *rli)
}
/*
We have an open file descriptor to the .info file; we need to close it
or Windows will refuse to delete the file in my_delete().
or Windows will refuse to delete the file in mysql_file_delete().
*/
if (fd >= 0)
{
my_close(fd, MYF(0));
mysql_file_close(fd, MYF(0));
end_io_cache(&file);
fd= -1;
}
(void) my_delete(fname, MYF(MY_WME));
mysql_file_delete(key_file_log_event_info, fname, MYF(MY_WME));
memcpy(ext, ".data", 6);
(void) my_delete(fname, MYF(MY_WME));
mysql_file_delete(key_file_log_event_data, fname, MYF(MY_WME));
error = 0;
err:
delete lev;
if (fd >= 0)
{
my_close(fd, MYF(0));
mysql_file_close(fd, MYF(0));
end_io_cache(&file);
}
return error;
@ -6863,7 +6876,7 @@ Execute_load_query_log_event::do_apply_event(Relay_log_info const *rli)
file so that we can re-execute this event at START SLAVE.
*/
if (!error)
(void) my_delete(fname, MYF(MY_WME));
mysql_file_delete(key_file_log_event_data, fname, MYF(MY_WME));
my_free(buf, MYF(MY_ALLOW_ZERO_PTR));
return error;

6
sql/log_event.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2000-2006 MySQL AB
/* Copyright (C) 2000-2006 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -946,11 +946,11 @@ public:
constructor and pass description_event as an argument.
*/
static Log_event* read_log_event(IO_CACHE* file,
pthread_mutex_t* log_lock,
mysql_mutex_t* log_lock,
const Format_description_log_event
*description_event);
static int read_log_event(IO_CACHE* file, String* packet,
pthread_mutex_t* log_lock);
mysql_mutex_t* log_lock);
/*
init_show_field_list() prepares the column names and types for the
output of SHOW BINLOG EVENTS; it is used only by SHOW BINLOG

128
sql/mysql_priv.h
View File

@ -891,7 +891,10 @@ inline bool check_routine_access(THD *thd,ulong want_access,char *db,
char *name, bool is_proc, bool no_errors)
{ return false; }
inline bool check_some_access(THD *thd, ulong want_access, TABLE_LIST *table)
{ return false; }
{
table->grant.privilege= want_access;
return false;
}
inline bool check_merge_table_access(THD *thd, char *db, TABLE_LIST *table_list)
{ return false; }
inline bool check_some_routine_access(THD *thd, const char *db,
@ -1041,6 +1044,7 @@ int check_user(THD *thd, enum enum_server_command command,
const char *passwd, uint passwd_len, const char *db,
bool check_count);
pthread_handler_t handle_one_connection(void *arg);
void do_handle_one_connection(THD *thd_arg);
bool init_new_connection_handler_thread();
void reset_mqh(LEX_USER *lu, bool get_them);
bool check_mqh(THD *thd, uint check_command);
@ -1093,6 +1097,7 @@ void init_max_user_conn(void);
void init_update_queries(void);
void free_max_user_conn(void);
pthread_handler_t handle_bootstrap(void *arg);
void do_handle_bootstrap(THD *thd);
int mysql_execute_command(THD *thd);
bool do_command(THD *thd);
bool dispatch_command(enum enum_server_command command, THD *thd,
@ -1117,15 +1122,17 @@ bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables,
bool *write_to_binlog);
#ifndef NO_EMBEDDED_ACCESS_CHECKS
bool check_access(THD *thd, ulong access, const char *db, ulong *save_priv,
bool no_grant, bool no_errors, bool schema_db);
bool check_table_access(THD *thd, ulong requirements,TABLE_LIST *tables,
GRANT_INTERNAL_INFO *grant_internal_info,
bool no_grant, bool no_errors);
bool check_table_access(THD *thd, ulong requirements, TABLE_LIST *tables,
bool any_combination_of_privileges_will_do,
uint number,
bool no_errors);
#else
inline bool check_access(THD *thd, ulong access, const char *db,
ulong *save_priv, bool no_grant, bool no_errors,
bool schema_db)
ulong *save_priv,
GRANT_INTERNAL_INFO *grant_internal_info,
bool no_grant, bool no_errors)
{
if (save_priv)
*save_priv= GLOBAL_ACLS;
@ -1314,7 +1321,7 @@ bool table_is_used(TABLE *table, bool wait_for_name_lock);
TABLE *drop_locked_tables(THD *thd,const char *db, const char *table_name);
void abort_locked_tables(THD *thd,const char *db, const char *table_name);
void execute_init_command(THD *thd, LEX_STRING *init_command,
rw_lock_t *var_mutex);
mysql_rwlock_t *var_mutex);
extern Field *not_found_field;
extern Field *view_ref_found;
@ -1355,7 +1362,7 @@ struct st_des_keyschedule
extern char *des_key_file;
extern struct st_des_keyschedule des_keyschedule[10];
extern uint des_default_key;
extern pthread_mutex_t LOCK_des_key_file;
extern mysql_mutex_t LOCK_des_key_file;
bool load_des_key_file(const char *file_name);
#endif /* HAVE_OPENSSL */
@ -1402,6 +1409,8 @@ void free_status_vars();
void reset_status_vars();
/* information schema */
extern LEX_STRING INFORMATION_SCHEMA_NAME;
/* performance schema */
extern LEX_STRING PERFORMANCE_SCHEMA_DB_NAME;
/* log tables */
extern LEX_STRING MYSQL_SCHEMA_NAME;
extern LEX_STRING GENERAL_LOG_NAME;
@ -1423,9 +1432,11 @@ bool get_schema_tables_result(JOIN *join,
enum enum_schema_table_state executed_place);
enum enum_schema_tables get_schema_table_idx(ST_SCHEMA_TABLE *schema_table);
#define is_schema_db(X) \
#define is_infoschema_db(X) \
!my_strcasecmp(system_charset_info, INFORMATION_SCHEMA_NAME.str, (X))
void initialize_information_schema_acl();
/* sql_handler.cc */
bool mysql_ha_open(THD *thd, TABLE_LIST *tables, bool reopen);
bool mysql_ha_close(THD *thd, TABLE_LIST *tables);
@ -1728,7 +1739,7 @@ void release_ddl_log();
void execute_ddl_log_recovery();
bool execute_ddl_log_entry(THD *thd, uint first_entry);
extern pthread_mutex_t LOCK_gdl;
extern mysql_mutex_t LOCK_gdl;
#define WFRM_WRITE_SHADOW 1
#define WFRM_INSTALL_SHADOW 2
@ -1745,9 +1756,8 @@ bool open_system_tables_for_read(THD *thd, TABLE_LIST *table_list,
void close_system_tables(THD *thd, Open_tables_state *backup);
TABLE *open_system_table_for_update(THD *thd, TABLE_LIST *one_table);
TABLE *open_performance_schema_table(THD *thd, TABLE_LIST *one_table,
Open_tables_state *backup);
void close_performance_schema_table(THD *thd, Open_tables_state *backup);
TABLE *open_log_table(THD *thd, TABLE_LIST *one_table, Open_tables_state *backup);
void close_log_table(THD *thd, Open_tables_state *backup);
bool close_cached_tables(THD *thd, TABLE_LIST *tables, bool have_lock,
bool wait_for_refresh, bool wait_for_placeholders);
@ -2034,31 +2044,29 @@ extern my_bool old_mode;
extern MYSQL_PLUGIN_IMPORT MYSQL_BIN_LOG mysql_bin_log;
extern LOGGER logger;
extern TABLE_LIST general_log, slow_log;
extern FILE *bootstrap_file;
extern MYSQL_FILE *bootstrap_file;
extern int bootstrap_error;
extern FILE *stderror_file;
extern pthread_key(MEM_ROOT**,THR_MALLOC);
extern pthread_mutex_t LOCK_mapped_file,
LOCK_error_log, LOCK_uuid_generator,
LOCK_crypt, LOCK_timezone,
extern mysql_mutex_t LOCK_mysql_create_db, LOCK_open, LOCK_lock_db,
LOCK_mapped_file, LOCK_user_locks, LOCK_status,
LOCK_error_log, LOCK_delayed_insert, LOCK_uuid_generator,
LOCK_delayed_status, LOCK_delayed_create, LOCK_crypt, LOCK_timezone,
LOCK_slave_list, LOCK_active_mi, LOCK_manager, LOCK_global_read_lock,
LOCK_global_system_variables, LOCK_user_conn,
LOCK_prepared_stmt_count, LOCK_error_messages, LOCK_connection_count;
extern mysql_mutex_t LOCK_mysql_create_db, LOCK_lock_db, LOCK_open,
LOCK_user_locks, LOCK_status, LOCK_delayed_status, LOCK_delayed_insert,
LOCK_delayed_create;
extern MYSQL_PLUGIN_IMPORT pthread_mutex_t LOCK_thread_count;
#ifdef HAVE_OPENSSL
extern pthread_mutex_t LOCK_des_key_file;
extern mysql_mutex_t LOCK_des_key_file;
#endif
extern pthread_mutex_t LOCK_server_started;
extern pthread_cond_t COND_server_started;
extern mysql_mutex_t LOCK_server_started;
extern mysql_cond_t COND_server_started;
extern int mysqld_server_started;
extern rw_lock_t LOCK_grant, LOCK_sys_init_connect, LOCK_sys_init_slave;
extern rw_lock_t LOCK_system_variables_hash;
extern mysql_cond_t COND_refresh;
extern pthread_cond_t COND_thread_count, COND_manager;
extern pthread_cond_t COND_global_read_lock;
extern mysql_rwlock_t LOCK_grant, LOCK_sys_init_connect, LOCK_sys_init_slave;
extern mysql_rwlock_t LOCK_system_variables_hash;
extern pthread_cond_t COND_thread_count;
extern mysql_cond_t COND_refresh, COND_manager;
extern mysql_cond_t COND_global_read_lock;
extern pthread_attr_t connection_attrib;
extern I_List<THD> threads;
extern MY_BITMAP temp_pool;
@ -2081,7 +2089,6 @@ extern String null_string;
extern HASH open_cache, lock_db_cache;
extern TABLE *unused_tables;
extern const char* any_db;
extern struct my_option my_long_options[];
extern const LEX_STRING view_type;
extern scheduler_functions thread_scheduler;
extern TYPELIB thread_handling_typelib;
@ -2644,4 +2651,69 @@ extern "C" int test_if_data_home_dir(const char *dir);
#endif /* MYSQL_CLIENT */
#ifdef MYSQL_SERVER
#ifdef HAVE_PSI_INTERFACE
#ifdef HAVE_MMAP
extern PSI_mutex_key key_PAGE_lock, key_LOCK_sync, key_LOCK_active,
key_LOCK_pool;
#endif /* HAVE_MMAP */
#ifdef HAVE_OPENSSL
extern PSI_mutex_key key_LOCK_des_key_file;
#endif
extern PSI_mutex_key key_BINLOG_LOCK_index, key_BINLOG_LOCK_prep_xids,
key_delayed_insert_mutex, key_hash_filo_lock, key_LOCK_active_mi,
key_LOCK_connection_count, key_LOCK_crypt, key_LOCK_delayed_create,
key_LOCK_delayed_insert, key_LOCK_delayed_status, key_LOCK_error_log,
key_LOCK_gdl, key_LOCK_global_read_lock, key_LOCK_global_system_variables,
key_LOCK_lock_db, key_LOCK_logger, key_LOCK_manager, key_LOCK_mapped_file,
key_LOCK_mysql_create_db, key_LOCK_open, key_LOCK_prepared_stmt_count,
key_LOCK_rpl_status, key_LOCK_server_started, key_LOCK_status,
key_LOCK_table_share, key_LOCK_thd_data,
key_LOCK_user_conn, key_LOCK_uuid_generator, key_LOG_LOCK_log,
key_master_info_data_lock, key_master_info_run_lock,
key_mutex_slave_reporting_capability_err_lock, key_relay_log_info_data_lock,
key_relay_log_info_log_space_lock, key_relay_log_info_run_lock,
key_structure_guard_mutex, key_TABLE_SHARE_mutex, key_LOCK_error_messages;
extern PSI_rwlock_key key_rwlock_LOCK_grant, key_rwlock_LOCK_logger,
key_rwlock_LOCK_sys_init_connect, key_rwlock_LOCK_sys_init_slave,
key_rwlock_LOCK_system_variables_hash, key_rwlock_query_cache_query_lock;
#ifdef HAVE_MMAP
extern PSI_cond_key key_PAGE_cond, key_COND_active, key_COND_pool;
#endif /* HAVE_MMAP */
extern PSI_cond_key key_BINLOG_COND_prep_xids, key_BINLOG_update_cond,
key_COND_cache_status_changed, key_COND_global_read_lock, key_COND_manager,
key_COND_refresh, key_COND_rpl_status, key_COND_server_started,
key_delayed_insert_cond, key_delayed_insert_cond_client,
key_item_func_sleep_cond, key_master_info_data_cond,
key_master_info_start_cond, key_master_info_stop_cond,
key_relay_log_info_data_cond, key_relay_log_info_log_space_cond,
key_relay_log_info_start_cond, key_relay_log_info_stop_cond,
key_TABLE_SHARE_cond, key_user_level_lock_cond;
extern PSI_thread_key key_thread_bootstrap, key_thread_delayed_insert,
key_thread_handle_manager, key_thread_kill_server, key_thread_main,
key_thread_one_connection, key_thread_signal_hand;
#ifdef HAVE_MMAP
extern PSI_file_key key_file_map;
#endif /* HAVE_MMAP */
extern PSI_file_key key_file_binlog, key_file_binlog_index, key_file_casetest,
key_file_dbopt, key_file_des_key_file, key_file_ERRMSG, key_select_to_file,
key_file_fileparser, key_file_frm, key_file_global_ddl_log, key_file_load,
key_file_loadfile, key_file_log_event_data, key_file_log_event_info,
key_file_master_info, key_file_misc, key_file_MYSQL_LOG, key_file_partition,
key_file_pid, key_file_relay_log_info, key_file_send_file, key_file_tclog,
key_file_trg, key_file_trn, key_file_init;
void init_server_psi_keys();
#endif /* HAVE_PSI_INTERFACE */
#endif /* MYSQL_SERVER */
#endif /* MYSQL_PRIV_H */

1025
sql/mysqld.cc
View File

File diff suppressed because it is too large Load Diff

31
sql/parse_file.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2004 MySQL AB
/* Copyright (C) 2004 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -237,8 +237,9 @@ sql_create_definition_file(const LEX_STRING *dir, const LEX_STRING *file_name,
// temporary file name
path[path_end]='~';
path[path_end+1]= '\0';
if ((handler= my_create(path, CREATE_MODE, O_RDWR | O_TRUNC,
MYF(MY_WME))) <= 0)
if ((handler= mysql_file_create(key_file_fileparser,
path, CREATE_MODE, O_RDWR | O_TRUNC,
MYF(MY_WME))) <= 0)
{
DBUG_RETURN(TRUE);
}
@ -267,11 +268,11 @@ sql_create_definition_file(const LEX_STRING *dir, const LEX_STRING *file_name,
goto err_w_file;
if (opt_sync_frm) {
if (my_sync(handler, MYF(MY_WME)))
if (mysql_file_sync(handler, MYF(MY_WME)))
goto err_w_file;
}
if (my_close(handler, MYF(MY_WME)))
if (mysql_file_close(handler, MYF(MY_WME)))
{
DBUG_RETURN(TRUE);
}
@ -283,7 +284,7 @@ sql_create_definition_file(const LEX_STRING *dir, const LEX_STRING *file_name,
char path_to[FN_REFLEN];
memcpy(path_to, path, path_end+1);
path[path_end]='~';
if (my_rename(path, path_to, MYF(MY_WME)))
if (mysql_file_rename(key_file_fileparser, path, path_to, MYF(MY_WME)))
{
DBUG_RETURN(TRUE);
}
@ -292,7 +293,7 @@ sql_create_definition_file(const LEX_STRING *dir, const LEX_STRING *file_name,
err_w_cache:
end_io_cache(&file);
err_w_file:
my_close(handler, MYF(MY_WME));
mysql_file_close(handler, MYF(MY_WME));
DBUG_RETURN(TRUE);
}
@ -321,7 +322,7 @@ my_bool rename_in_schema_file(THD *thd,
build_table_filename(new_path, sizeof(new_path) - 1,
new_db, new_name, reg_ext, 0);
if (my_rename(old_path, new_path, MYF(MY_WME)))
if (mysql_file_rename(key_file_frm, old_path, new_path, MYF(MY_WME)))
return 1;
/* check if arc_dir exists: disabled unused feature (see bug #17823). */
@ -365,7 +366,8 @@ sql_parse_prepare(const LEX_STRING *file_name, MEM_ROOT *mem_root,
File file;
DBUG_ENTER("sql_parse_prepare");
if (!my_stat(file_name->str, &stat_info, MYF(MY_WME)))
if (!mysql_file_stat(key_file_fileparser,
file_name->str, &stat_info, MYF(MY_WME)))
{
DBUG_RETURN(0);
}
@ -386,20 +388,21 @@ sql_parse_prepare(const LEX_STRING *file_name, MEM_ROOT *mem_root,
DBUG_RETURN(0);
}
if ((file= my_open(file_name->str, O_RDONLY | O_SHARE, MYF(MY_WME))) < 0)
if ((file= mysql_file_open(key_file_fileparser, file_name->str,
O_RDONLY | O_SHARE, MYF(MY_WME))) < 0)
{
DBUG_RETURN(0);
}
if ((len= my_read(file, (uchar *)parser->buff,
stat_info.st_size, MYF(MY_WME))) ==
if ((len= mysql_file_read(file, (uchar *)parser->buff,
stat_info.st_size, MYF(MY_WME))) ==
MY_FILE_ERROR)
{
my_close(file, MYF(MY_WME));
mysql_file_close(file, MYF(MY_WME));
DBUG_RETURN(0);
}
if (my_close(file, MYF(MY_WME)))
if (mysql_file_close(file, MYF(MY_WME)))
{
DBUG_RETURN(0);
}

89
sql/repl_failsafe.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2001-2006 MySQL AB & Sasha
/* Copyright (C) 2001-2006 MySQL AB & Sasha, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -39,8 +39,8 @@
uint rpl_status=RPL_NULL;
pthread_mutex_t LOCK_rpl_status;
pthread_cond_t COND_rpl_status;
mysql_mutex_t LOCK_rpl_status;
mysql_cond_t COND_rpl_status;
HASH slave_list;
const char *rpl_role_type[] = {"MASTER","SLAVE",NullS};
@ -107,11 +107,11 @@ static int init_failsafe_rpl_thread(THD* thd)
void change_rpl_status(RPL_STATUS from_status, RPL_STATUS to_status)
{
pthread_mutex_lock(&LOCK_rpl_status);
mysql_mutex_lock(&LOCK_rpl_status);
if (rpl_status == from_status || rpl_status == RPL_ANY)
rpl_status = to_status;
pthread_cond_signal(&COND_rpl_status);
pthread_mutex_unlock(&LOCK_rpl_status);
mysql_cond_signal(&COND_rpl_status);
mysql_mutex_unlock(&LOCK_rpl_status);
}
@ -140,7 +140,7 @@ void unregister_slave(THD* thd, bool only_mine, bool need_mutex)
if (thd->server_id)
{
if (need_mutex)
pthread_mutex_lock(&LOCK_slave_list);
mysql_mutex_lock(&LOCK_slave_list);
SLAVE_INFO* old_si;
if ((old_si = (SLAVE_INFO*)my_hash_search(&slave_list,
@ -149,7 +149,7 @@ void unregister_slave(THD* thd, bool only_mine, bool need_mutex)
my_hash_delete(&slave_list, (uchar*)old_si);
if (need_mutex)
pthread_mutex_unlock(&LOCK_slave_list);
mysql_mutex_unlock(&LOCK_slave_list);
}
}
@ -170,7 +170,7 @@ int register_slave(THD* thd, uchar* packet, uint packet_length)
uchar *p= packet, *p_end= packet + packet_length;
const char *errmsg= "Wrong parameters to function register_slave";
if (check_access(thd, REPL_SLAVE_ACL, any_db,0,0,0,0))
if (check_access(thd, REPL_SLAVE_ACL, any_db, NULL, NULL, 0, 0))
return 1;
if (!(si = (SLAVE_INFO*)my_malloc(sizeof(SLAVE_INFO), MYF(MY_WME))))
goto err2;
@ -189,10 +189,10 @@ int register_slave(THD* thd, uchar* packet, uint packet_length)
si->master_id= server_id;
si->thd= thd;
pthread_mutex_lock(&LOCK_slave_list);
mysql_mutex_lock(&LOCK_slave_list);
unregister_slave(thd,0,0);
res= my_hash_insert(&slave_list, (uchar*) si);
pthread_mutex_unlock(&LOCK_slave_list);
mysql_mutex_unlock(&LOCK_slave_list);
return res;
err:
@ -215,12 +215,37 @@ extern "C" void slave_info_free(void *s)
my_free(s, MYF(MY_WME));
}
#ifdef HAVE_PSI_INTERFACE
static PSI_mutex_key key_LOCK_slave_list;
static PSI_mutex_info all_slave_list_mutexes[]=
{
{ &key_LOCK_slave_list, "LOCK_slave_list", PSI_FLAG_GLOBAL}
};
static void init_all_slave_list_mutexes(void)
{
const char* category= "sql";
int count;
if (PSI_server == NULL)
return;
count= array_elements(all_slave_list_mutexes);
PSI_server->register_mutex(category, all_slave_list_mutexes, count);
}
#endif /* HAVE_PSI_INTERFACE */
void init_slave_list()
{
#ifdef HAVE_PSI_INTERFACE
init_all_slave_list_mutexes();
#endif
my_hash_init(&slave_list, system_charset_info, SLAVE_LIST_CHUNK, 0, 0,
(my_hash_get_key) slave_list_key,
(my_hash_free_key) slave_info_free, 0);
pthread_mutex_init(&LOCK_slave_list, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_LOCK_slave_list, &LOCK_slave_list, MY_MUTEX_INIT_FAST);
}
void end_slave_list()
@ -229,7 +254,7 @@ void end_slave_list()
if (my_hash_inited(&slave_list))
{
my_hash_free(&slave_list);
pthread_mutex_destroy(&LOCK_slave_list);
mysql_mutex_destroy(&LOCK_slave_list);
}
}
@ -241,7 +266,7 @@ static int find_target_pos(LEX_MASTER_INFO *mi, IO_CACHE *log, char *errmsg)
for (;;)
{
Log_event* ev;
if (!(ev = Log_event::read_log_event(log, (pthread_mutex_t*) 0, 0)))
if (!(ev= Log_event::read_log_event(log, (mysql_mutex_t*) 0, 0)))
{
if (log->error > 0)
strmov(errmsg, "Binary log truncated in the middle of event");
@ -283,7 +308,7 @@ int translate_master(THD* thd, LEX_MASTER_INFO* mi, char* errmsg)
char last_log_name[FN_REFLEN];
IO_CACHE log;
File file = -1, last_file = -1;
pthread_mutex_t *log_lock;
mysql_mutex_t *log_lock;
const char* errmsg_p;
Slave_log_event* sev = 0;
my_off_t last_pos = 0;
@ -313,7 +338,7 @@ int translate_master(THD* thd, LEX_MASTER_INFO* mi, char* errmsg)
bzero((char*) &log,sizeof(log));
log_lock = mysql_bin_log.get_log_lock();
pthread_mutex_lock(log_lock);
mysql_mutex_lock(log_lock);
for (;;)
{
@ -345,7 +370,7 @@ int translate_master(THD* thd, LEX_MASTER_INFO* mi, char* errmsg)
goto err;
}
end_io_cache(&log);
(void) my_close(file, MYF(MY_WME));
mysql_file_close(file, MYF(MY_WME));
if (init_io_cache(&log, (file = last_file), IO_SIZE, READ_CACHE, 0, 0,
MYF(MY_WME)))
{
@ -361,7 +386,7 @@ int translate_master(THD* thd, LEX_MASTER_INFO* mi, char* errmsg)
switch (mysql_bin_log.find_next_log(&linfo, 1)) {
case LOG_INFO_EOF:
if (last_file >= 0)
(void)my_close(last_file, MYF(MY_WME));
mysql_file_close(last_file, MYF(MY_WME));
last_file = -1;
goto found_log;
case 0:
@ -373,7 +398,7 @@ int translate_master(THD* thd, LEX_MASTER_INFO* mi, char* errmsg)
end_io_cache(&log);
if (last_file >= 0)
(void) my_close(last_file, MYF(MY_WME));
mysql_file_close(last_file, MYF(MY_WME));
last_file = file;
}
@ -386,15 +411,15 @@ found_log:
mi_inited:
error = 0;
err:
pthread_mutex_unlock(log_lock);
mysql_mutex_unlock(log_lock);
end_io_cache(&log);
pthread_mutex_lock(&LOCK_thread_count);
thd->current_linfo = 0;
pthread_mutex_unlock(&LOCK_thread_count);
if (file >= 0)
(void) my_close(file, MYF(MY_WME));
mysql_file_close(file, MYF(MY_WME));
if (last_file >= 0 && last_file != file)
(void) my_close(last_file, MYF(MY_WME));
mysql_file_close(last_file, MYF(MY_WME));
DBUG_RETURN(error);
}
@ -415,7 +440,7 @@ static Slave_log_event* find_slave_event(IO_CACHE* log,
for (i = 0; i < 2; i++)
{
if (!(ev = Log_event::read_log_event(log, (pthread_mutex_t*)0, 0)))
if (!(ev= Log_event::read_log_event(log, (mysql_mutex_t*)0, 0)))
{
my_snprintf(errmsg, SLAVE_ERRMSG_SIZE,
"Error reading event in log '%s'",
@ -537,7 +562,7 @@ HOSTS";
goto err;
}
pthread_mutex_lock(&LOCK_slave_list);
mysql_mutex_lock(&LOCK_slave_list);
while ((row= mysql_fetch_row(res)))
{
@ -552,14 +577,14 @@ HOSTS";
if (!(si = (SLAVE_INFO*)my_malloc(sizeof(SLAVE_INFO), MYF(MY_WME))))
{
error= "the slave is out of memory";
pthread_mutex_unlock(&LOCK_slave_list);
mysql_mutex_unlock(&LOCK_slave_list);
goto err;
}
si->server_id = log_server_id;
if (my_hash_insert(&slave_list, (uchar*)si))
{
error= "the slave is out of memory";
pthread_mutex_unlock(&LOCK_slave_list);
mysql_mutex_unlock(&LOCK_slave_list);
goto err;
}
}
@ -573,7 +598,7 @@ HOSTS";
strmake(si->password, row[3], sizeof(si->password)-1);
}
}
pthread_mutex_unlock(&LOCK_slave_list);
mysql_mutex_unlock(&LOCK_slave_list);
err:
if (res)
@ -611,13 +636,13 @@ pthread_handler_t handle_failsafe_rpl(void *arg)
sql_print_error("Could not initialize failsafe replication thread");
goto err;
}
pthread_mutex_lock(&LOCK_rpl_status);
mysql_mutex_lock(&LOCK_rpl_status);
msg= thd->enter_cond(&COND_rpl_status,
&LOCK_rpl_status, "Waiting for request");
while (!thd->killed && !abort_loop)
{
bool break_req_chain = 0;
pthread_cond_wait(&COND_rpl_status, &LOCK_rpl_status);
mysql_cond_wait(&COND_rpl_status, &LOCK_rpl_status);
thd_proc_info(thd, "Processing request");
while (!break_req_chain)
{
@ -680,7 +705,7 @@ bool show_slave_hosts(THD* thd)
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
DBUG_RETURN(TRUE);
pthread_mutex_lock(&LOCK_slave_list);
mysql_mutex_lock(&LOCK_slave_list);
for (uint i = 0; i < slave_list.records; ++i)
{
@ -697,11 +722,11 @@ bool show_slave_hosts(THD* thd)
protocol->store((uint32) si->master_id);
if (protocol->write())
{
pthread_mutex_unlock(&LOCK_slave_list);
mysql_mutex_unlock(&LOCK_slave_list);
DBUG_RETURN(TRUE);
}
}
pthread_mutex_unlock(&LOCK_slave_list);
mysql_mutex_unlock(&LOCK_slave_list);
my_eof(thd);
DBUG_RETURN(FALSE);
}

6
sql/repl_failsafe.h
View File

@ -1,7 +1,7 @@
#ifndef REPL_FAILSAFE_INCLUDED
#define REPL_FAILSAFE_INCLUDED
/* Copyright (C) 2001-2005 MySQL AB & Sasha
/* Copyright (C) 2001-2005 MySQL AB & Sasha, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -28,8 +28,8 @@ typedef enum {RPL_AUTH_MASTER=0,RPL_IDLE_SLAVE,RPL_ACTIVE_SLAVE,
RPL_ANY /* wild card used by change_rpl_status */ } RPL_STATUS;
extern uint rpl_status;
extern pthread_mutex_t LOCK_rpl_status;
extern pthread_cond_t COND_rpl_status;
extern mysql_mutex_t LOCK_rpl_status;
extern mysql_cond_t COND_rpl_status;
extern TYPELIB rpl_role_typelib, rpl_status_typelib;
extern const char* rpl_role_type[], *rpl_status_type[];

42
sql/rpl_mi.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2000-2003 MySQL AB
/* Copyright (C) 2000-2003 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -44,21 +44,21 @@ Master_info::Master_info(bool is_slave_recovery)
my_init_dynamic_array(&ignore_server_ids, sizeof(::server_id), 16, 16);
bzero((char*) &file, sizeof(file));
pthread_mutex_init(&run_lock, MY_MUTEX_INIT_FAST);
pthread_mutex_init(&data_lock, MY_MUTEX_INIT_FAST);
pthread_cond_init(&data_cond, NULL);
pthread_cond_init(&start_cond, NULL);
pthread_cond_init(&stop_cond, NULL);
mysql_mutex_init(key_master_info_run_lock, &run_lock, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_master_info_data_lock, &data_lock, MY_MUTEX_INIT_FAST);
mysql_cond_init(key_master_info_data_cond, &data_cond, NULL);
mysql_cond_init(key_master_info_start_cond, &start_cond, NULL);
mysql_cond_init(key_master_info_stop_cond, &stop_cond, NULL);
}
Master_info::~Master_info()
{
delete_dynamic(&ignore_server_ids);
pthread_mutex_destroy(&run_lock);
pthread_mutex_destroy(&data_lock);
pthread_cond_destroy(&data_cond);
pthread_cond_destroy(&start_cond);
pthread_cond_destroy(&stop_cond);
mysql_mutex_destroy(&run_lock);
mysql_mutex_destroy(&data_lock);
mysql_cond_destroy(&data_cond);
mysql_cond_destroy(&start_cond);
mysql_cond_destroy(&stop_cond);
}
/**
@ -175,7 +175,7 @@ int init_master_info(Master_info* mi, const char* master_info_fname,
keep other threads from reading bogus info
*/
pthread_mutex_lock(&mi->data_lock);
mysql_mutex_lock(&mi->data_lock);
fd = mi->fd;
/* does master.info exist ? */
@ -184,7 +184,7 @@ int init_master_info(Master_info* mi, const char* master_info_fname,
{
if (abort_if_no_master_info_file)
{
pthread_mutex_unlock(&mi->data_lock);
mysql_mutex_unlock(&mi->data_lock);
DBUG_RETURN(0);
}
/*
@ -192,8 +192,9 @@ int init_master_info(Master_info* mi, const char* master_info_fname,
the old descriptor and re-create the old file
*/
if (fd >= 0)
my_close(fd, MYF(MY_WME));
if ((fd = my_open(fname, O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0 )
mysql_file_close(fd, MYF(MY_WME));
if ((fd= mysql_file_open(key_file_master_info,
fname, O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0 )
{
sql_print_error("Failed to create a new master info file (\
file '%s', errno %d)", fname, my_errno);
@ -217,7 +218,8 @@ file '%s')", fname);
reinit_io_cache(&mi->file, READ_CACHE, 0L,0,0);
else
{
if ((fd = my_open(fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0 )
if ((fd= mysql_file_open(key_file_master_info,
fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0 )
{
sql_print_error("Failed to open the existing master info file (\
file '%s', errno %d)", fname, my_errno);
@ -369,7 +371,7 @@ file '%s')", fname);
reinit_io_cache(&mi->file, WRITE_CACHE, 0L, 0, 1);
if ((error=test(flush_master_info(mi, 1))))
sql_print_error("Failed to flush master info file");
pthread_mutex_unlock(&mi->data_lock);
mysql_mutex_unlock(&mi->data_lock);
DBUG_RETURN(error);
errwithmsg:
@ -378,11 +380,11 @@ errwithmsg:
err:
if (fd >= 0)
{
my_close(fd, MYF(0));
mysql_file_close(fd, MYF(0));
end_io_cache(&mi->file);
}
mi->fd= -1;
pthread_mutex_unlock(&mi->data_lock);
mysql_mutex_unlock(&mi->data_lock);
DBUG_RETURN(1);
}
@ -494,7 +496,7 @@ void end_master_info(Master_info* mi)
if (mi->fd >= 0)
{
end_io_cache(&mi->file);
(void)my_close(mi->fd, MYF(MY_WME));
mysql_file_close(mi->fd, MYF(MY_WME));
mi->fd = -1;
}
mi->inited = 0;

6
sql/rpl_mi.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2000-2003 MySQL AB
/* Copyright (C) 2000-2003 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -77,8 +77,8 @@ class Master_info : public Slave_reporting_capability
File fd; // we keep the file open, so we need to remember the file pointer
IO_CACHE file;
pthread_mutex_t data_lock,run_lock;
pthread_cond_t data_cond,start_cond,stop_cond;
mysql_mutex_t data_lock, run_lock;
mysql_cond_t data_cond, start_cond, stop_cond;
THD *io_thd;
MYSQL* mysql;
uint32 file_id; /* for 3.23 load data infile */

28
sql/rpl_reporting.cc
View File

@ -1,7 +1,29 @@
/* Copyright (C) 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
#include "mysql_priv.h"
#include "rpl_reporting.h"
Slave_reporting_capability::Slave_reporting_capability(char const *thread_name)
: m_thread_name(thread_name)
{
mysql_mutex_init(key_mutex_slave_reporting_capability_err_lock,
&err_lock, MY_MUTEX_INIT_FAST);
}
void
Slave_reporting_capability::report(loglevel level, int err_code,
const char *msg, ...) const
@ -13,7 +35,7 @@ Slave_reporting_capability::report(loglevel level, int err_code,
va_list args;
va_start(args, msg);
pthread_mutex_lock(&err_lock);
mysql_mutex_lock(&err_lock);
switch (level)
{
case ERROR_LEVEL:
@ -39,7 +61,7 @@ Slave_reporting_capability::report(loglevel level, int err_code,
my_vsnprintf(pbuff, pbuffsize, msg, args);
pthread_mutex_unlock(&err_lock);
mysql_mutex_unlock(&err_lock);
va_end(args);
/* If the msg string ends with '.', do not add a ',' it would be ugly */
@ -51,5 +73,5 @@ Slave_reporting_capability::report(loglevel level, int err_code,
Slave_reporting_capability::~Slave_reporting_capability()
{
pthread_mutex_destroy(&err_lock);
mysql_mutex_destroy(&err_lock);
}

27
sql/rpl_reporting.h
View File

@ -1,6 +1,21 @@
#ifndef RPL_REPORTING_H
#define RPL_REPORTING_H
/* Copyright (C) 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/**
Maximum size of an error message from a slave thread.
*/
@ -17,17 +32,13 @@ class Slave_reporting_capability
{
public:
/** lock used to synchronize m_last_error on 'SHOW SLAVE STATUS' **/
mutable pthread_mutex_t err_lock;
mutable mysql_mutex_t err_lock;
/**
Constructor.
@param thread_name Printable name of the slave thread that is reporting.
*/
Slave_reporting_capability(char const *thread_name)
: m_thread_name(thread_name)
{
pthread_mutex_init(&err_lock, MY_MUTEX_INIT_FAST);
}
Slave_reporting_capability(char const *thread_name);
/**
Writes a message and, if it's an error message, to Last_Error
@ -47,9 +58,9 @@ public:
STATUS</code>.
*/
void clear_error() {
pthread_mutex_lock(&err_lock);
mysql_mutex_lock(&err_lock);
m_last_error.clear();
pthread_mutex_unlock(&err_lock);
mysql_mutex_unlock(&err_lock);
}
/**

101
sql/rpl_rli.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2000-2003 MySQL AB
/* Copyright (C) 2000-2003 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -54,13 +54,15 @@ Relay_log_info::Relay_log_info(bool is_slave_recovery)
bzero((char*) &info_file, sizeof(info_file));
bzero((char*) &cache_buf, sizeof(cache_buf));
cached_charset_invalidate();
pthread_mutex_init(&run_lock, MY_MUTEX_INIT_FAST);
pthread_mutex_init(&data_lock, MY_MUTEX_INIT_FAST);
pthread_mutex_init(&log_space_lock, MY_MUTEX_INIT_FAST);
pthread_cond_init(&data_cond, NULL);
pthread_cond_init(&start_cond, NULL);
pthread_cond_init(&stop_cond, NULL);
pthread_cond_init(&log_space_cond, NULL);
mysql_mutex_init(key_relay_log_info_run_lock, &run_lock, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_relay_log_info_data_lock,
&data_lock, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_relay_log_info_log_space_lock,
&log_space_lock, MY_MUTEX_INIT_FAST);
mysql_cond_init(key_relay_log_info_data_cond, &data_cond, NULL);
mysql_cond_init(key_relay_log_info_start_cond, &start_cond, NULL);
mysql_cond_init(key_relay_log_info_stop_cond, &stop_cond, NULL);
mysql_cond_init(key_relay_log_info_log_space_cond, &log_space_cond, NULL);
relay_log.init_pthread_objects();
DBUG_VOID_RETURN;
}
@ -70,13 +72,13 @@ Relay_log_info::~Relay_log_info()
{
DBUG_ENTER("Relay_log_info::~Relay_log_info");
pthread_mutex_destroy(&run_lock);
pthread_mutex_destroy(&data_lock);
pthread_mutex_destroy(&log_space_lock);
pthread_cond_destroy(&data_cond);
pthread_cond_destroy(&start_cond);
pthread_cond_destroy(&stop_cond);
pthread_cond_destroy(&log_space_cond);
mysql_mutex_destroy(&run_lock);
mysql_mutex_destroy(&data_lock);
mysql_mutex_destroy(&log_space_lock);
mysql_cond_destroy(&data_cond);
mysql_cond_destroy(&start_cond);
mysql_cond_destroy(&stop_cond);
mysql_cond_destroy(&log_space_cond);
relay_log.cleanup();
DBUG_VOID_RETURN;
}
@ -95,7 +97,7 @@ int init_relay_log_info(Relay_log_info* rli,
if (rli->inited) // Set if this function called
DBUG_RETURN(0);
fn_format(fname, info_fname, mysql_data_home, "", 4+32);
pthread_mutex_lock(&rli->data_lock);
mysql_mutex_lock(&rli->data_lock);
info_fd = rli->info_fd;
rli->cur_log_fd = -1;
rli->slave_skip_counter=0;
@ -110,7 +112,7 @@ int init_relay_log_info(Relay_log_info* rli,
if (fn_format(pattern, PREFIX_SQL_LOAD, pattern, "",
MY_SAFE_PATH | MY_RETURN_REAL_PATH) == NullS)
{
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
sql_print_error("Unable to use slave's temporary directory %s",
slave_load_tmpdir);
DBUG_RETURN(1);
@ -139,7 +141,7 @@ int init_relay_log_info(Relay_log_info* rli,
if (opt_relay_logname &&
opt_relay_logname[strlen(opt_relay_logname) - 1] == FN_LIBCHAR)
{
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
sql_print_error("Path '%s' is a directory name, please specify \
a file name for --relay-log option", opt_relay_logname);
DBUG_RETURN(1);
@ -151,7 +153,7 @@ a file name for --relay-log option", opt_relay_logname);
opt_relaylog_index_name[strlen(opt_relaylog_index_name) - 1]
== FN_LIBCHAR)
{
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
sql_print_error("Path '%s' is a directory name, please specify \
a file name for --relay-log-index option", opt_relaylog_index_name);
DBUG_RETURN(1);
@ -188,7 +190,7 @@ a file name for --relay-log-index option", opt_relaylog_index_name);
(max_relay_log_size ? max_relay_log_size :
max_binlog_size), 1, TRUE))
{
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
sql_print_error("Failed in open_log() called from init_relay_log_info()");
DBUG_RETURN(1);
}
@ -203,8 +205,9 @@ a file name for --relay-log-index option", opt_relaylog_index_name);
the old descriptor and re-create the old file
*/
if (info_fd >= 0)
my_close(info_fd, MYF(MY_WME));
if ((info_fd = my_open(fname, O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0)
mysql_file_close(info_fd, MYF(MY_WME));
if ((info_fd= mysql_file_open(key_file_relay_log_info,
fname, O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0)
{
sql_print_error("Failed to create a new relay log info file (\
file '%s', errno %d)", fname, my_errno);
@ -238,7 +241,8 @@ file '%s', errno %d)", fname, my_errno);
else
{
int error=0;
if ((info_fd = my_open(fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0)
if ((info_fd= mysql_file_open(key_file_relay_log_info,
fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0)
{
sql_print_error("\
Failed to open the existing relay log info file '%s' (errno %d)",
@ -255,10 +259,10 @@ Failed to open the existing relay log info file '%s' (errno %d)",
if (error)
{
if (info_fd >= 0)
my_close(info_fd, MYF(0));
mysql_file_close(info_fd, MYF(0));
rli->info_fd= -1;
rli->relay_log.close(LOG_CLOSE_INDEX | LOG_CLOSE_STOP_EVENT);
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
DBUG_RETURN(1);
}
}
@ -327,17 +331,17 @@ Failed to open the existing relay log info file '%s' (errno %d)",
goto err;
}
rli->inited= 1;
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
DBUG_RETURN(error);
err:
sql_print_error("%s", msg);
end_io_cache(&rli->info_file);
if (info_fd >= 0)
my_close(info_fd, MYF(0));
mysql_file_close(info_fd, MYF(0));
rli->info_fd= -1;
rli->relay_log.close(LOG_CLOSE_INDEX | LOG_CLOSE_STOP_EVENT);
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
DBUG_RETURN(1);
}
@ -346,7 +350,8 @@ static inline int add_relay_log(Relay_log_info* rli,LOG_INFO* linfo)
{
MY_STAT s;
DBUG_ENTER("add_relay_log");
if (!my_stat(linfo->log_file_name,&s,MYF(0)))
if (!mysql_file_stat(key_file_binlog,
linfo->log_file_name, &s, MYF(0)))
{
sql_print_error("log %s listed in the index, but failed to stat",
linfo->log_file_name);
@ -446,10 +451,10 @@ int init_relay_log_pos(Relay_log_info* rli,const char* log,
DBUG_PRINT("info", ("pos: %lu", (ulong) pos));
*errmsg=0;
pthread_mutex_t *log_lock=rli->relay_log.get_log_lock();
mysql_mutex_t *log_lock= rli->relay_log.get_log_lock();
if (need_data_lock)
pthread_mutex_lock(&rli->data_lock);
mysql_mutex_lock(&rli->data_lock);
/*
Slave threads are not the only users of init_relay_log_pos(). CHANGE MASTER
@ -469,13 +474,13 @@ int init_relay_log_pos(Relay_log_info* rli,const char* log,
rli->relay_log.description_event_for_exec= new
Format_description_log_event(3);
pthread_mutex_lock(log_lock);
mysql_mutex_lock(log_lock);
/* Close log file and free buffers if it's already open */
if (rli->cur_log_fd >= 0)
{
end_io_cache(&rli->cache_buf);
my_close(rli->cur_log_fd, MYF(MY_WME));
mysql_file_close(rli->cur_log_fd, MYF(MY_WME));
rli->cur_log_fd = -1;
}
@ -609,12 +614,12 @@ err:
*/
if (!relay_log_purge)
rli->log_space_limit= 0;
pthread_cond_broadcast(&rli->data_cond);
mysql_cond_broadcast(&rli->data_cond);
pthread_mutex_unlock(log_lock);
mysql_mutex_unlock(log_lock);
if (need_data_lock)
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
if (!rli->relay_log.description_event_for_exec->is_valid() && !*errmsg)
*errmsg= "Invalid Format_description log event; could be out of memory";
@ -665,7 +670,7 @@ int Relay_log_info::wait_for_pos(THD* thd, String* log_name,
log_name->c_ptr(), (ulong) log_pos, (ulong) timeout));
set_timespec(abstime,timeout);
pthread_mutex_lock(&data_lock);
mysql_mutex_lock(&data_lock);
msg= thd->enter_cond(&data_cond, &data_lock,
"Waiting for the slave SQL thread to "
"advance position");
@ -778,26 +783,26 @@ int Relay_log_info::wait_for_pos(THD* thd, String* log_name,
DBUG_PRINT("info",("Waiting for master update"));
/*
We are going to pthread_cond_(timed)wait(); if the SQL thread stops it
We are going to mysql_cond_(timed)wait(); if the SQL thread stops it
will wake us up.
*/
if (timeout > 0)
{
/*
Note that pthread_cond_timedwait checks for the timeout
Note that mysql_cond_timedwait checks for the timeout
before for the condition ; i.e. it returns ETIMEDOUT
if the system time equals or exceeds the time specified by abstime
before the condition variable is signaled or broadcast, _or_ if
the absolute time specified by abstime has already passed at the time
of the call.
For that reason, pthread_cond_timedwait will do the "timeoutting" job
For that reason, mysql_cond_timedwait will do the "timeoutting" job
even if its condition is always immediately signaled (case of a loaded
master).
*/
error=pthread_cond_timedwait(&data_cond, &data_lock, &abstime);
error= mysql_cond_timedwait(&data_cond, &data_lock, &abstime);
}
else
pthread_cond_wait(&data_cond, &data_lock);
mysql_cond_wait(&data_cond, &data_lock);
DBUG_PRINT("info",("Got signal of master update or timed out"));
if (error == ETIMEDOUT || error == ETIME)
{
@ -833,7 +838,7 @@ void Relay_log_info::inc_group_relay_log_pos(ulonglong log_pos,
DBUG_ENTER("Relay_log_info::inc_group_relay_log_pos");
if (!skip_lock)
pthread_mutex_lock(&data_lock);
mysql_mutex_lock(&data_lock);
inc_event_relay_log_pos();
group_relay_log_pos= event_relay_log_pos;
strmake(group_relay_log_name,event_relay_log_name,
@ -877,9 +882,9 @@ void Relay_log_info::inc_group_relay_log_pos(ulonglong log_pos,
{
group_master_log_pos= log_pos;
}
pthread_cond_broadcast(&data_cond);
mysql_cond_broadcast(&data_cond);
if (!skip_lock)
pthread_mutex_unlock(&data_lock);
mysql_mutex_unlock(&data_lock);
DBUG_VOID_RETURN;
}
@ -948,7 +953,7 @@ int purge_relay_logs(Relay_log_info* rli, THD *thd, bool just_reset,
DBUG_ASSERT(rli->mi->slave_running == 0);
rli->slave_skip_counter=0;
pthread_mutex_lock(&rli->data_lock);
mysql_mutex_lock(&rli->data_lock);
/*
we close the relay log fd possibly left open by the slave SQL thread,
@ -959,7 +964,7 @@ int purge_relay_logs(Relay_log_info* rli, THD *thd, bool just_reset,
if (rli->cur_log_fd >= 0)
{
end_io_cache(&rli->cache_buf);
my_close(rli->cur_log_fd, MYF(MY_WME));
mysql_file_close(rli->cur_log_fd, MYF(MY_WME));
rli->cur_log_fd= -1;
}
@ -991,7 +996,7 @@ err:
char buf[22];
#endif
DBUG_PRINT("info",("log_space_total: %s",llstr(rli->log_space_total,buf)));
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
DBUG_RETURN(error);
}

12
sql/rpl_rli.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2005 MySQL AB
/* Copyright (C) 2005 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -123,17 +123,17 @@ public:
TABLE *save_temporary_tables;
/*
standard lock acquistion order to avoid deadlocks:
standard lock acquisition order to avoid deadlocks:
run_lock, data_lock, relay_log.LOCK_log, relay_log.LOCK_index
*/
pthread_mutex_t data_lock,run_lock;
mysql_mutex_t data_lock, run_lock;
/*
start_cond is broadcast when SQL thread is started
stop_cond - when stopped
data_cond - when data protected by data_lock changes
*/
pthread_cond_t start_cond, stop_cond, data_cond;
mysql_cond_t start_cond, stop_cond, data_cond;
/* parent Master_info structure */
Master_info *mi;
@ -215,8 +215,8 @@ public:
volatile uint32 slave_skip_counter;
volatile ulong abort_pos_wait; /* Incremented on change master */
volatile ulong slave_run_id; /* Incremented on slave start */
pthread_mutex_t log_space_lock;
pthread_cond_t log_space_cond;
mysql_mutex_t log_space_lock;
mysql_cond_t log_space_cond;
THD * sql_thd;
#ifndef DBUG_OFF
int events_till_abort;

39
sql/set_var.cc
View File

@ -1,4 +1,4 @@
/* Copyright 2000-2008 MySQL AB, 2008 Sun Microsystems, Inc.
/* Copyright 2000-2008 MySQL AB, 2008-2010 Sun Microsystems, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -38,16 +38,12 @@ static uchar *get_sys_var_length(const sys_var *var, size_t *length,
sys_var_chain all_sys_vars = { NULL, NULL };
int sys_var_init(DYNAMIC_ARRAY *long_options)
int sys_var_init()
{
uint count= 0;
uint saved_elements= long_options->elements;
DBUG_ENTER("sys_var_init");
for (sys_var *var=all_sys_vars.first; var; var= var->next, count++)
if (var->register_option(long_options))
goto error;
/* Must be already initialized. */
DBUG_ASSERT(system_charset_info != NULL);
if (my_hash_init(&system_variable_hash, system_charset_info, 100, 0,
0, (my_hash_get_key) get_sys_var_length, 0, HASH_UNIQUE))
@ -58,6 +54,25 @@ int sys_var_init(DYNAMIC_ARRAY *long_options)
DBUG_RETURN(0);
error:
fprintf(stderr, "failed to initialize System variables");
DBUG_RETURN(1);
}
int sys_var_add_options(DYNAMIC_ARRAY *long_options, int parse_flags)
{
uint saved_elements= long_options->elements;
DBUG_ENTER("sys_var_add_options");
for (sys_var *var=all_sys_vars.first; var; var= var->next)
{
if (var->register_option(long_options, parse_flags))
goto error;
}
DBUG_RETURN(0);
error:
fprintf(stderr, "failed to initialize System variables");
long_options->elements= saved_elements;
@ -99,6 +114,7 @@ void sys_var_end()
@param deprecated_version if not 0 - when this variable will go away
@param substitute if not 0 - what one should use instead when this
deprecated variable
@param parse_flag either PARSE_EARLY or PARSE_NORMAL
*/
sys_var::sys_var(sys_var_chain *chain, const char *name_arg,
const char *comment, int flags_arg, ptrdiff_t off,
@ -107,10 +123,11 @@ sys_var::sys_var(sys_var_chain *chain, const char *name_arg,
PolyLock *lock, enum binlog_status_enum binlog_status_arg,
on_check_function on_check_func,
on_update_function on_update_func,
uint deprecated_version, const char *substitute) :
uint deprecated_version, const char *substitute,
int parse_flag) :
next(0),
binlog_status(binlog_status_arg),
flags(flags_arg), show_val_type(show_val_type_arg),
flags(flags_arg), m_parse_flag(parse_flag), show_val_type(show_val_type_arg),
guard(lock), offset(off), on_check(on_check_func), on_update(on_update_func),
is_os_charset(FALSE)
{
@ -203,7 +220,7 @@ uchar *sys_var::value_ptr(THD *thd, enum_var_type type, LEX_STRING *base)
{
if (type == OPT_GLOBAL || scope() == GLOBAL)
{
safe_mutex_assert_owner(&LOCK_global_system_variables);
mysql_mutex_assert_owner(&LOCK_global_system_variables);
AutoRLock lock(guard);
return global_value_ptr(thd, base);
}

17
sql/set_var.h
View File

@ -1,6 +1,6 @@
#ifndef SET_VAR_INCLUDED
#define SET_VAR_INCLUDED
/* Copyright 2000-2008 MySQL AB, 2009 Sun Microsystems, Inc.
/* Copyright (C) 2000-2008 MySQL AB, 2008-2010 Sun Microsystems, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -56,6 +56,8 @@ public:
LEX_CSTRING name;
enum flag_enum { GLOBAL, SESSION, ONLY_SESSION, SCOPE_MASK=1023,
READONLY=1024, ALLOCATED=2048 };
static const int PARSE_EARLY= 1;
static const int PARSE_NORMAL= 2;
/**
Enumeration type to indicate for a system variable whether
it will be written to the binlog or not.
@ -68,6 +70,7 @@ protected:
typedef bool (*on_update_function)(sys_var *self, THD *thd, enum_var_type type);
int flags; ///< or'ed flag_enum values
int m_parse_flag; ///< either PARSE_EARLY or PARSE_NORMAL.
const SHOW_TYPE show_val_type; ///< what value_ptr() returns for sql_show.cc
my_option option; ///< min, max, default values are stored here
PolyLock *guard; ///< *second* lock that protects the variable
@ -83,7 +86,7 @@ public:
enum get_opt_arg_type getopt_arg_type, SHOW_TYPE show_val_type_arg,
longlong def_val, PolyLock *lock, enum binlog_status_enum binlog_status_arg,
on_check_function on_check_func, on_update_function on_update_func,
uint deprecated_version, const char *substitute);
uint deprecated_version, const char *substitute, int parse_flag);
/**
The instance should only be destroyed on shutdown, as it doesn't unlink
itself from the chain.
@ -122,8 +125,11 @@ public:
}
return true; // keep gcc happy
}
bool register_option(DYNAMIC_ARRAY *array)
{ return option.id != -1 && insert_dynamic(array, (uchar*)&option); }
bool register_option(DYNAMIC_ARRAY *array, int parse_flags)
{
return (option.id != -1) && (m_parse_flag & parse_flags) &&
insert_dynamic(array, (uchar*)&option);
}
private:
virtual bool do_check(THD *thd, set_var *var) = 0;
@ -289,7 +295,8 @@ extern sys_var *Sys_autocommit_ptr;
CHARSET_INFO *get_old_charset_by_name(const char *old_name);
int sys_var_init(DYNAMIC_ARRAY *long_options);
int sys_var_init();
int sys_var_add_options(DYNAMIC_ARRAY *long_options, int parse_flags);
void sys_var_end(void);
#endif

5
sql/share/errmsg-utf8.txt
View File

@ -6266,3 +6266,8 @@ ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT
eng "The syntax '%s' is deprecated and will be removed in MySQL %s."
ger "Die Syntax '%s' ist veraltet und wird in MySQL %s entfernt."
ER_WRONG_NATIVE_TABLE_STRUCTURE
eng "Native table '%-.64s'.'%-.64s' has the wrong structure"
ER_WRONG_PERFSCHEMA_USAGE
eng "Invalid performance_schema usage."

314
sql/slave.cc
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2000-2003 MySQL AB
/* Copyright (C) 2000-2003 MySQL AB, 2008-2009 Sun Microsystems, Inc
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -148,8 +148,8 @@ static int get_master_version_and_clock(MYSQL* mysql, Master_info* mi);
static Log_event* next_event(Relay_log_info* rli);
static int queue_event(Master_info* mi,const char* buf,ulong event_len);
static int terminate_slave_thread(THD *thd,
pthread_mutex_t *term_lock,
pthread_cond_t *term_cond,
mysql_mutex_t *term_lock,
mysql_cond_t *term_cond,
volatile uint *slave_running,
bool skip_lock);
static bool check_io_slave_killed(THD *thd, Master_info *mi, const char *info);
@ -198,8 +198,8 @@ void lock_slave_threads(Master_info* mi)
DBUG_ENTER("lock_slave_threads");
//TODO: see if we can do this without dual mutex
pthread_mutex_lock(&mi->run_lock);
pthread_mutex_lock(&mi->rli.run_lock);
mysql_mutex_lock(&mi->run_lock);
mysql_mutex_lock(&mi->rli.run_lock);
DBUG_VOID_RETURN;
}
@ -213,11 +213,32 @@ void unlock_slave_threads(Master_info* mi)
DBUG_ENTER("unlock_slave_threads");
//TODO: see if we can do this without dual mutex
pthread_mutex_unlock(&mi->rli.run_lock);
pthread_mutex_unlock(&mi->run_lock);
mysql_mutex_unlock(&mi->rli.run_lock);
mysql_mutex_unlock(&mi->run_lock);
DBUG_VOID_RETURN;
}
#ifdef HAVE_PSI_INTERFACE
static PSI_thread_key key_thread_slave_io, key_thread_slave_sql;
static PSI_thread_info all_slave_threads[]=
{
{ &key_thread_slave_io, "slave_io", PSI_FLAG_GLOBAL},
{ &key_thread_slave_sql, "slave_sql", PSI_FLAG_GLOBAL}
};
static void init_slave_psi_keys(void)
{
const char* category= "sql";
int count;
if (PSI_server == NULL)
return;
count= array_elements(all_slave_threads);
PSI_server->register_thread(category, all_slave_threads, count);
}
#endif /* HAVE_PSI_INTERFACE */
/* Initialize slave structures */
@ -226,12 +247,16 @@ int init_slave()
DBUG_ENTER("init_slave");
int error= 0;
#ifdef HAVE_PSI_INTERFACE
init_slave_psi_keys();
#endif
/*
This is called when mysqld starts. Before client connections are
accepted. However bootstrap may conflict with us if it does START SLAVE.
So it's safer to take the lock.
*/
pthread_mutex_lock(&LOCK_active_mi);
mysql_mutex_lock(&LOCK_active_mi);
/*
TODO: re-write this to interate through the list of files
for multi-master
@ -288,7 +313,7 @@ int init_slave()
}
err:
pthread_mutex_unlock(&LOCK_active_mi);
mysql_mutex_unlock(&LOCK_active_mi);
DBUG_RETURN(error);
}
@ -466,7 +491,7 @@ int terminate_slave_threads(Master_info* mi,int thread_mask,bool skip_lock)
if (!mi->inited)
DBUG_RETURN(0); /* successfully do nothing */
int error,force_all = (thread_mask & SLAVE_FORCE_ALL);
pthread_mutex_t *sql_lock = &mi->rli.run_lock, *io_lock = &mi->run_lock;
mysql_mutex_t *sql_lock = &mi->rli.run_lock, *io_lock = &mi->run_lock;
if (thread_mask & (SLAVE_IO|SLAVE_FORCE_ALL))
{
@ -530,19 +555,19 @@ int terminate_slave_threads(Master_info* mi,int thread_mask,bool skip_lock)
*/
static int
terminate_slave_thread(THD *thd,
pthread_mutex_t *term_lock,
pthread_cond_t *term_cond,
mysql_mutex_t *term_lock,
mysql_cond_t *term_cond,
volatile uint *slave_running,
bool skip_lock)
{
DBUG_ENTER("terminate_slave_thread");
if (!skip_lock)
{
pthread_mutex_lock(term_lock);
mysql_mutex_lock(term_lock);
}
else
{
safe_mutex_assert_owner(term_lock);
mysql_mutex_assert_owner(term_lock);
}
if (!*slave_running)
{
@ -552,7 +577,7 @@ terminate_slave_thread(THD *thd,
if run_lock (term_lock) is acquired locally then either
slave_running status is fine
*/
pthread_mutex_unlock(term_lock);
mysql_mutex_unlock(term_lock);
DBUG_RETURN(0);
}
else
@ -573,7 +598,7 @@ terminate_slave_thread(THD *thd,
int error;
DBUG_PRINT("loop", ("killing slave thread"));
pthread_mutex_lock(&thd->LOCK_thd_data);
mysql_mutex_lock(&thd->LOCK_thd_data);
#ifndef DONT_USE_THR_ALARM
/*
Error codes from pthread_kill are:
@ -584,7 +609,7 @@ terminate_slave_thread(THD *thd,
DBUG_ASSERT(err != EINVAL);
#endif
thd->awake(THD::NOT_KILLED);
pthread_mutex_unlock(&thd->LOCK_thd_data);
mysql_mutex_unlock(&thd->LOCK_thd_data);
/*
There is a small chance that slave thread might miss the first
@ -592,21 +617,25 @@ terminate_slave_thread(THD *thd,
*/
struct timespec abstime;
set_timespec(abstime,2);
error= pthread_cond_timedwait(term_cond, term_lock, &abstime);
error= mysql_cond_timedwait(term_cond, term_lock, &abstime);
DBUG_ASSERT(error == ETIMEDOUT || error == 0);
}
DBUG_ASSERT(*slave_running == 0);
if (!skip_lock)
pthread_mutex_unlock(term_lock);
mysql_mutex_unlock(term_lock);
DBUG_RETURN(0);
}
int start_slave_thread(pthread_handler h_func, pthread_mutex_t *start_lock,
pthread_mutex_t *cond_lock,
pthread_cond_t *start_cond,
int start_slave_thread(
#ifdef HAVE_PSI_INTERFACE
PSI_thread_key thread_key,
#endif
pthread_handler h_func, mysql_mutex_t *start_lock,
mysql_mutex_t *cond_lock,
mysql_cond_t *start_cond,
volatile uint *slave_running,
volatile ulong *slave_run_id,
Master_info* mi)
@ -618,13 +647,13 @@ int start_slave_thread(pthread_handler h_func, pthread_mutex_t *start_lock,
DBUG_ASSERT(mi->inited);
if (start_lock)
pthread_mutex_lock(start_lock);
mysql_mutex_lock(start_lock);
if (!server_id)
{
if (start_cond)
pthread_cond_broadcast(start_cond);
mysql_cond_broadcast(start_cond);
if (start_lock)
pthread_mutex_unlock(start_lock);
mysql_mutex_unlock(start_lock);
sql_print_error("Server id not set, will not start slave");
DBUG_RETURN(ER_BAD_SLAVE);
}
@ -632,17 +661,18 @@ int start_slave_thread(pthread_handler h_func, pthread_mutex_t *start_lock,
if (*slave_running)
{
if (start_cond)
pthread_cond_broadcast(start_cond);
mysql_cond_broadcast(start_cond);
if (start_lock)
pthread_mutex_unlock(start_lock);
mysql_mutex_unlock(start_lock);
DBUG_RETURN(ER_SLAVE_MUST_STOP);
}
start_id= *slave_run_id;
DBUG_PRINT("info",("Creating new slave thread"));
if (pthread_create(&th, &connection_attrib, h_func, (void*)mi))
if (mysql_thread_create(thread_key,
&th, &connection_attrib, h_func, (void*)mi))
{
if (start_lock)
pthread_mutex_unlock(start_lock);
mysql_mutex_unlock(start_lock);
DBUG_RETURN(ER_SLAVE_THREAD);
}
if (start_cond && cond_lock) // caller has cond_lock
@ -653,19 +683,19 @@ int start_slave_thread(pthread_handler h_func, pthread_mutex_t *start_lock,
DBUG_PRINT("sleep",("Waiting for slave thread to start"));
const char* old_msg = thd->enter_cond(start_cond,cond_lock,
"Waiting for slave thread to start");
pthread_cond_wait(start_cond, cond_lock);
mysql_cond_wait(start_cond, cond_lock);
thd->exit_cond(old_msg);
pthread_mutex_lock(cond_lock); // re-acquire it as exit_cond() released
mysql_mutex_lock(cond_lock); // re-acquire it as exit_cond() released
if (thd->killed)
{
if (start_lock)
pthread_mutex_unlock(start_lock);
mysql_mutex_unlock(start_lock);
DBUG_RETURN(thd->killed_errno());
}
}
}
if (start_lock)
pthread_mutex_unlock(start_lock);
mysql_mutex_unlock(start_lock);
DBUG_RETURN(0);
}
@ -683,8 +713,8 @@ int start_slave_threads(bool need_slave_mutex, bool wait_for_start,
Master_info* mi, const char* master_info_fname,
const char* slave_info_fname, int thread_mask)
{
pthread_mutex_t *lock_io=0,*lock_sql=0,*lock_cond_io=0,*lock_cond_sql=0;
pthread_cond_t* cond_io=0,*cond_sql=0;
mysql_mutex_t *lock_io=0, *lock_sql=0, *lock_cond_io=0, *lock_cond_sql=0;
mysql_cond_t* cond_io=0, *cond_sql=0;
int error=0;
DBUG_ENTER("start_slave_threads");
@ -702,16 +732,24 @@ int start_slave_threads(bool need_slave_mutex, bool wait_for_start,
}
if (thread_mask & SLAVE_IO)
error=start_slave_thread(handle_slave_io,lock_io,lock_cond_io,
cond_io,
&mi->slave_running, &mi->slave_run_id,
mi);
error= start_slave_thread(
#ifdef HAVE_PSI_INTERFACE
key_thread_slave_io,
#endif
handle_slave_io, lock_io, lock_cond_io,
cond_io,
&mi->slave_running, &mi->slave_run_id,
mi);
if (!error && (thread_mask & SLAVE_SQL))
{
error=start_slave_thread(handle_slave_sql,lock_sql,lock_cond_sql,
cond_sql,
&mi->rli.slave_running, &mi->rli.slave_run_id,
mi);
error= start_slave_thread(
#ifdef HAVE_PSI_INTERFACE
key_thread_slave_sql,
#endif
handle_slave_sql, lock_sql, lock_cond_sql,
cond_sql,
&mi->rli.slave_running, &mi->rli.slave_run_id,
mi);
if (error)
terminate_slave_threads(mi, thread_mask & SLAVE_IO, !need_slave_mutex);
}
@ -748,7 +786,7 @@ void end_slave()
will make us wait until slave threads have started, and START SLAVE
returns, then we terminate them here.
*/
pthread_mutex_lock(&LOCK_active_mi);
mysql_mutex_lock(&LOCK_active_mi);
if (active_mi)
{
/*
@ -758,7 +796,7 @@ void end_slave()
*/
terminate_slave_threads(active_mi,SLAVE_FORCE_ALL);
}
pthread_mutex_unlock(&LOCK_active_mi);
mysql_mutex_unlock(&LOCK_active_mi);
DBUG_VOID_RETURN;
}
@ -773,14 +811,14 @@ void end_slave()
*/
void close_active_mi()
{
pthread_mutex_lock(&LOCK_active_mi);
mysql_mutex_lock(&LOCK_active_mi);
if (active_mi)
{
end_master_info(active_mi);
delete active_mi;
active_mi= 0;
}
pthread_mutex_unlock(&LOCK_active_mi);
mysql_mutex_unlock(&LOCK_active_mi);
}
static bool io_slave_killed(THD* thd, Master_info* mi)
@ -1479,7 +1517,7 @@ static bool wait_for_relay_log_space(Relay_log_info* rli)
THD* thd = mi->io_thd;
DBUG_ENTER("wait_for_relay_log_space");
pthread_mutex_lock(&rli->log_space_lock);
mysql_mutex_lock(&rli->log_space_lock);
save_proc_info= thd->enter_cond(&rli->log_space_cond,
&rli->log_space_lock,
"\
@ -1487,7 +1525,7 @@ Waiting for the slave SQL thread to free enough relay log space");
while (rli->log_space_limit < rli->log_space_total &&
!(slave_killed=io_slave_killed(thd,mi)) &&
!rli->ignore_log_space_limit)
pthread_cond_wait(&rli->log_space_cond, &rli->log_space_lock);
mysql_cond_wait(&rli->log_space_cond, &rli->log_space_lock);
thd->exit_cond(save_proc_info);
DBUG_RETURN(slave_killed);
}
@ -1509,11 +1547,11 @@ Waiting for the slave SQL thread to free enough relay log space");
static void write_ignored_events_info_to_relay_log(THD *thd, Master_info *mi)
{
Relay_log_info *rli= &mi->rli;
pthread_mutex_t *log_lock= rli->relay_log.get_log_lock();
mysql_mutex_t *log_lock= rli->relay_log.get_log_lock();
DBUG_ENTER("write_ignored_events_info_to_relay_log");
DBUG_ASSERT(thd == mi->io_thd);
pthread_mutex_lock(log_lock);
mysql_mutex_lock(log_lock);
if (rli->ign_master_log_name_end[0])
{
DBUG_PRINT("info",("writing a Rotate event to track down ignored events"));
@ -1522,7 +1560,7 @@ static void write_ignored_events_info_to_relay_log(THD *thd, Master_info *mi)
Rotate_log_event::DUP_NAME);
rli->ign_master_log_name_end[0]= 0;
/* can unlock before writing as slave SQL thd will soon see our Rotate */
pthread_mutex_unlock(log_lock);
mysql_mutex_unlock(log_lock);
if (likely((bool)ev))
{
ev->server_id= 0; // don't be ignored by slave SQL thread
@ -1544,7 +1582,7 @@ static void write_ignored_events_info_to_relay_log(THD *thd, Master_info *mi)
" SHOW SLAVE STATUS may be inaccurate");
}
else
pthread_mutex_unlock(log_lock);
mysql_mutex_unlock(log_lock);
DBUG_VOID_RETURN;
}
@ -1715,14 +1753,14 @@ bool show_master_info(THD* thd, Master_info* mi)
slave_running can be accessed without run_lock but not other
non-volotile members like mi->io_thd, which is guarded by the mutex.
*/
pthread_mutex_lock(&mi->run_lock);
mysql_mutex_lock(&mi->run_lock);
protocol->store(mi->io_thd ? mi->io_thd->proc_info : "", &my_charset_bin);
pthread_mutex_unlock(&mi->run_lock);
mysql_mutex_unlock(&mi->run_lock);
pthread_mutex_lock(&mi->data_lock);
pthread_mutex_lock(&mi->rli.data_lock);
pthread_mutex_lock(&mi->err_lock);
pthread_mutex_lock(&mi->rli.err_lock);
mysql_mutex_lock(&mi->data_lock);
mysql_mutex_lock(&mi->rli.data_lock);
mysql_mutex_lock(&mi->err_lock);
mysql_mutex_lock(&mi->rli.err_lock);
protocol->store(mi->host, &my_charset_bin);
protocol->store(mi->user, &my_charset_bin);
protocol->store((uint32) mi->port);
@ -1849,10 +1887,10 @@ bool show_master_info(THD* thd, Master_info* mi)
// Master_Server_id
protocol->store((uint32) mi->master_id);
pthread_mutex_unlock(&mi->rli.err_lock);
pthread_mutex_unlock(&mi->err_lock);
pthread_mutex_unlock(&mi->rli.data_lock);
pthread_mutex_unlock(&mi->data_lock);
mysql_mutex_unlock(&mi->rli.err_lock);
mysql_mutex_unlock(&mi->err_lock);
mysql_mutex_unlock(&mi->rli.data_lock);
mysql_mutex_unlock(&mi->data_lock);
if (my_net_write(&thd->net, (uchar*) thd->packet.ptr(), packet->length()))
DBUG_RETURN(TRUE);
@ -2228,7 +2266,7 @@ int apply_event_and_update_pos(Log_event* ev, THD* thd, Relay_log_info* rli)
int reason= ev->shall_skip(rli);
if (reason == Log_event::EVENT_SKIP_COUNT)
sql_slave_skip_counter= --rli->slave_skip_counter;
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
if (reason == Log_event::EVENT_SKIP_NOT)
exec_res= ev->apply_event(rli);
@ -2334,7 +2372,7 @@ static int exec_relay_log_event(THD* thd, Relay_log_info* rli)
event execution. But we will release it in places where we will
wait for something for example inside of next_event().
*/
pthread_mutex_lock(&rli->data_lock);
mysql_mutex_lock(&rli->data_lock);
Log_event * ev = next_event(rli);
@ -2342,7 +2380,7 @@ static int exec_relay_log_event(THD* thd, Relay_log_info* rli)
if (sql_slave_killed(thd,rli))
{
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
delete ev;
DBUG_RETURN(1);
}
@ -2365,7 +2403,7 @@ static int exec_relay_log_event(THD* thd, Relay_log_info* rli)
error in query execution to be printed.
*/
rli->abort_slave= 1;
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
delete ev;
DBUG_RETURN(1);
}
@ -2383,7 +2421,7 @@ static int exec_relay_log_event(THD* thd, Relay_log_info* rli)
{
DBUG_ASSERT(thd->transaction.all.modified_non_trans_table);
rli->abort_slave= 1;
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
delete ev;
rli->inc_event_relay_log_pos();
DBUG_RETURN(0);
@ -2447,10 +2485,10 @@ static int exec_relay_log_event(THD* thd, Relay_log_info* rli)
/* chance for concurrent connection to get more locks */
safe_sleep(thd, min(rli->trans_retries, MAX_SLAVE_RETRY_PAUSE),
(CHECK_KILLED_FUNC)sql_slave_killed, (void*)rli);
pthread_mutex_lock(&rli->data_lock); // because of SHOW STATUS
mysql_mutex_lock(&rli->data_lock); // because of SHOW STATUS
rli->trans_retries++;
rli->retried_trans++;
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
DBUG_PRINT("info", ("Slave retries transaction "
"rli->trans_retries: %lu", rli->trans_retries));
}
@ -2478,7 +2516,7 @@ static int exec_relay_log_event(THD* thd, Relay_log_info* rli)
}
DBUG_RETURN(exec_res);
}
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
rli->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_READ_FAILURE,
ER(ER_SLAVE_RELAY_LOG_READ_FAILURE), "\
Could not parse relay log event entry. The possible reasons are: the master's \
@ -2609,7 +2647,7 @@ pthread_handler_t handle_slave_io(void *arg)
mysql= NULL ;
retry_count= 0;
pthread_mutex_lock(&mi->run_lock);
mysql_mutex_lock(&mi->run_lock);
/* Inform waiting threads that slave has started */
mi->slave_run_id++;
@ -2626,8 +2664,8 @@ pthread_handler_t handle_slave_io(void *arg)
mi->clear_error();
if (init_slave_thread(thd, SLAVE_THD_IO))
{
pthread_cond_broadcast(&mi->start_cond);
pthread_mutex_unlock(&mi->run_lock);
mysql_cond_broadcast(&mi->start_cond);
mysql_mutex_unlock(&mi->run_lock);
sql_print_error("Failed during slave I/O thread initialization");
goto err;
}
@ -2636,8 +2674,8 @@ pthread_handler_t handle_slave_io(void *arg)
pthread_mutex_unlock(&LOCK_thread_count);
mi->slave_running = 1;
mi->abort_slave = 0;
pthread_mutex_unlock(&mi->run_lock);
pthread_cond_broadcast(&mi->start_cond);
mysql_mutex_unlock(&mi->run_lock);
mysql_cond_broadcast(&mi->start_cond);
DBUG_PRINT("master_info",("log_file_name: '%s' position: %s",
mi->master_log_name,
@ -2920,7 +2958,7 @@ err:
}
write_ignored_events_info_to_relay_log(thd, mi);
thd_proc_info(thd, "Waiting for slave mutex on exit");
pthread_mutex_lock(&mi->run_lock);
mysql_mutex_lock(&mi->run_lock);
/* Forget the relay log's format */
delete mi->rli.relay_log.description_event_for_queue;
@ -2942,9 +2980,9 @@ err:
is important. Otherwise a killer_thread can execute between the calls and
delete the mi structure leading to a crash! (see BUG#25306 for details)
*/
pthread_cond_broadcast(&mi->stop_cond); // tell the world we are done
mysql_cond_broadcast(&mi->stop_cond); // tell the world we are done
DBUG_EXECUTE_IF("simulate_slave_delay_at_terminate_bug38694", sleep(5););
pthread_mutex_unlock(&mi->run_lock);
mysql_mutex_unlock(&mi->run_lock);
DBUG_LEAVE; // Must match DBUG_ENTER()
my_thread_end();
@ -2981,16 +3019,17 @@ int check_temp_dir(char* tmp_file)
/*
Check permissions to create a file.
*/
if ((fd= my_create(tmp_file, CREATE_MODE,
O_WRONLY | O_BINARY | O_EXCL | O_NOFOLLOW,
MYF(MY_WME))) < 0)
if ((fd= mysql_file_create(key_file_misc,
tmp_file, CREATE_MODE,
O_WRONLY | O_BINARY | O_EXCL | O_NOFOLLOW,
MYF(MY_WME))) < 0)
DBUG_RETURN(1);
/*
Clean up.
*/
my_close(fd, MYF(0));
my_delete(tmp_file, MYF(0));
mysql_file_close(fd, MYF(0));
mysql_file_delete(key_file_misc, tmp_file, MYF(0));
DBUG_RETURN(0);
}
@ -3016,7 +3055,7 @@ pthread_handler_t handle_slave_sql(void *arg)
DBUG_ENTER("handle_slave_sql");
DBUG_ASSERT(rli->inited);
pthread_mutex_lock(&rli->run_lock);
mysql_mutex_lock(&rli->run_lock);
DBUG_ASSERT(!rli->slave_running);
errmsg= 0;
#ifndef DBUG_OFF
@ -3038,8 +3077,8 @@ pthread_handler_t handle_slave_sql(void *arg)
TODO: this is currently broken - slave start and change master
will be stuck if we fail here
*/
pthread_cond_broadcast(&rli->start_cond);
pthread_mutex_unlock(&rli->run_lock);
mysql_cond_broadcast(&rli->start_cond);
mysql_mutex_unlock(&rli->run_lock);
rli->report(ERROR_LEVEL, ER_SLAVE_FATAL_ERROR,
"Failed during slave thread initialization");
goto err;
@ -3059,8 +3098,8 @@ pthread_handler_t handle_slave_sql(void *arg)
Seconds_Behind_Master grows. No big deal.
*/
rli->abort_slave = 0;
pthread_mutex_unlock(&rli->run_lock);
pthread_cond_broadcast(&rli->start_cond);
mysql_mutex_unlock(&rli->run_lock);
mysql_cond_broadcast(&rli->start_cond);
/*
Reset errors for a clean start (otherwise, if the master is idle, the SQL
@ -3075,9 +3114,9 @@ pthread_handler_t handle_slave_sql(void *arg)
rli->clear_error();
//tell the I/O thread to take relay_log_space_limit into account from now on
pthread_mutex_lock(&rli->log_space_lock);
mysql_mutex_lock(&rli->log_space_lock);
rli->ignore_log_space_limit= 0;
pthread_mutex_unlock(&rli->log_space_lock);
mysql_mutex_unlock(&rli->log_space_lock);
rli->trans_retries= 0; // start from "no error"
DBUG_PRINT("info", ("rli->trans_retries: %lu", rli->trans_retries));
@ -3151,17 +3190,17 @@ log '%s' at position %s, relay log '%s' position: %s", RPL_LOG_NAME,
First check until condition - probably there is nothing to execute. We
do not want to wait for next event in this case.
*/
pthread_mutex_lock(&rli->data_lock);
mysql_mutex_lock(&rli->data_lock);
if (rli->until_condition != Relay_log_info::UNTIL_NONE &&
rli->is_until_satisfied(thd, NULL))
{
char buf[22];
sql_print_information("Slave SQL thread stopped because it reached its"
" UNTIL position %s", llstr(rli->until_pos(), buf));
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
goto err;
}
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
/* Read queries from the IO/THREAD until this thread is killed */
@ -3264,9 +3303,9 @@ the slave SQL thread with \"SLAVE START\". We stopped at log \
thd->set_query(NULL, 0);
thd->reset_db(NULL, 0);
thd_proc_info(thd, "Waiting for slave mutex on exit");
pthread_mutex_lock(&rli->run_lock);
mysql_mutex_lock(&rli->run_lock);
/* We need data_lock, at least to wake up any waiting master_pos_wait() */
pthread_mutex_lock(&rli->data_lock);
mysql_mutex_lock(&rli->data_lock);
DBUG_ASSERT(rli->slave_running == 1); // tracking buffer overrun
/* When master_pos_wait() wakes up it will check this and terminate */
rli->slave_running= 0;
@ -3274,9 +3313,9 @@ the slave SQL thread with \"SLAVE START\". We stopped at log \
delete rli->relay_log.description_event_for_exec;
rli->relay_log.description_event_for_exec= 0;
/* Wake up master_pos_wait() */
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
DBUG_PRINT("info",("Signaling possibly waiting master_pos_wait() functions"));
pthread_cond_broadcast(&rli->data_cond);
mysql_cond_broadcast(&rli->data_cond);
rli->ignore_log_space_limit= 0; /* don't need any lock */
/* we die so won't remember charset - re-update them on next thread start */
rli->cached_charset_invalidate();
@ -3302,9 +3341,9 @@ the slave SQL thread with \"SLAVE START\". We stopped at log \
is important. Otherwise a killer_thread can execute between the calls and
delete the mi structure leading to a crash! (see BUG#25306 for details)
*/
pthread_cond_broadcast(&rli->stop_cond);
mysql_cond_broadcast(&rli->stop_cond);
DBUG_EXECUTE_IF("simulate_slave_delay_at_terminate_bug38694", sleep(5););
pthread_mutex_unlock(&rli->run_lock); // tell the world we are done
mysql_mutex_unlock(&rli->run_lock); // tell the world we are done
DBUG_LEAVE; // Must match DBUG_ENTER()
my_thread_end();
@ -3447,7 +3486,7 @@ err:
static int process_io_rotate(Master_info *mi, Rotate_log_event *rev)
{
DBUG_ENTER("process_io_rotate");
safe_mutex_assert_owner(&mi->data_lock);
mysql_mutex_assert_owner(&mi->data_lock);
if (unlikely(!rev->is_valid()))
DBUG_RETURN(1);
@ -3543,7 +3582,7 @@ static int queue_binlog_ver_1_event(Master_info *mi, const char *buf,
DBUG_RETURN(1);
}
pthread_mutex_lock(&mi->data_lock);
mysql_mutex_lock(&mi->data_lock);
ev->log_pos= mi->master_log_pos; /* 3.23 events don't contain log_pos */
switch (ev->get_type_code()) {
case STOP_EVENT:
@ -3554,7 +3593,7 @@ static int queue_binlog_ver_1_event(Master_info *mi, const char *buf,
if (unlikely(process_io_rotate(mi,(Rotate_log_event*)ev)))
{
delete ev;
pthread_mutex_unlock(&mi->data_lock);
mysql_mutex_unlock(&mi->data_lock);
DBUG_RETURN(1);
}
inc_pos= 0;
@ -3575,7 +3614,7 @@ static int queue_binlog_ver_1_event(Master_info *mi, const char *buf,
delete ev;
mi->master_log_pos += inc_pos;
DBUG_PRINT("info", ("master_log_pos: %lu", (ulong) mi->master_log_pos));
pthread_mutex_unlock(&mi->data_lock);
mysql_mutex_unlock(&mi->data_lock);
my_free((char*)tmp_buf, MYF(0));
DBUG_RETURN(error);
}
@ -3594,7 +3633,7 @@ static int queue_binlog_ver_1_event(Master_info *mi, const char *buf,
if (unlikely(rli->relay_log.append(ev)))
{
delete ev;
pthread_mutex_unlock(&mi->data_lock);
mysql_mutex_unlock(&mi->data_lock);
DBUG_RETURN(1);
}
rli->relay_log.harvest_bytes_written(&rli->log_space_total);
@ -3602,7 +3641,7 @@ static int queue_binlog_ver_1_event(Master_info *mi, const char *buf,
delete ev;
mi->master_log_pos+= inc_pos;
DBUG_PRINT("info", ("master_log_pos: %lu", (ulong) mi->master_log_pos));
pthread_mutex_unlock(&mi->data_lock);
mysql_mutex_unlock(&mi->data_lock);
DBUG_RETURN(0);
}
@ -3630,7 +3669,7 @@ static int queue_binlog_ver_3_event(Master_info *mi, const char *buf,
my_free((char*) tmp_buf, MYF(MY_ALLOW_ZERO_PTR));
DBUG_RETURN(1);
}
pthread_mutex_lock(&mi->data_lock);
mysql_mutex_lock(&mi->data_lock);
switch (ev->get_type_code()) {
case STOP_EVENT:
goto err;
@ -3638,7 +3677,7 @@ static int queue_binlog_ver_3_event(Master_info *mi, const char *buf,
if (unlikely(process_io_rotate(mi,(Rotate_log_event*)ev)))
{
delete ev;
pthread_mutex_unlock(&mi->data_lock);
mysql_mutex_unlock(&mi->data_lock);
DBUG_RETURN(1);
}
inc_pos= 0;
@ -3650,7 +3689,7 @@ static int queue_binlog_ver_3_event(Master_info *mi, const char *buf,
if (unlikely(rli->relay_log.append(ev)))
{
delete ev;
pthread_mutex_unlock(&mi->data_lock);
mysql_mutex_unlock(&mi->data_lock);
DBUG_RETURN(1);
}
rli->relay_log.harvest_bytes_written(&rli->log_space_total);
@ -3658,7 +3697,7 @@ static int queue_binlog_ver_3_event(Master_info *mi, const char *buf,
mi->master_log_pos+= inc_pos;
err:
DBUG_PRINT("info", ("master_log_pos: %lu", (ulong) mi->master_log_pos));
pthread_mutex_unlock(&mi->data_lock);
mysql_mutex_unlock(&mi->data_lock);
DBUG_RETURN(0);
}
@ -3708,7 +3747,7 @@ static int queue_event(Master_info* mi,const char* buf, ulong event_len)
String error_msg;
ulong inc_pos;
Relay_log_info *rli= &mi->rli;
pthread_mutex_t *log_lock= rli->relay_log.get_log_lock();
mysql_mutex_t *log_lock= rli->relay_log.get_log_lock();
ulong s_id;
DBUG_ENTER("queue_event");
@ -3719,7 +3758,7 @@ static int queue_event(Master_info* mi,const char* buf, ulong event_len)
DBUG_RETURN(queue_old_event(mi,buf,event_len));
LINT_INIT(inc_pos);
pthread_mutex_lock(&mi->data_lock);
mysql_mutex_lock(&mi->data_lock);
switch (buf[EVENT_TYPE_OFFSET]) {
case STOP_EVENT:
@ -3855,7 +3894,7 @@ static int queue_event(Master_info* mi,const char* buf, ulong event_len)
direct master (an unsupported, useless setup!).
*/
pthread_mutex_lock(log_lock);
mysql_mutex_lock(log_lock);
s_id= uint4korr(buf + SERVER_ID_OFFSET);
if ((s_id == ::server_id && !mi->rli.replicate_same_server_id) ||
/*
@ -3917,12 +3956,12 @@ static int queue_event(Master_info* mi,const char* buf, ulong event_len)
}
rli->ign_master_log_name_end[0]= 0; // last event is not ignored
}
pthread_mutex_unlock(log_lock);
mysql_mutex_unlock(log_lock);
skip_relay_logging:
err:
pthread_mutex_unlock(&mi->data_lock);
mysql_mutex_unlock(&mi->data_lock);
DBUG_PRINT("info", ("error: %d", error));
if (error)
mi->report(ERROR_LEVEL, error, ER(error),
@ -3942,13 +3981,13 @@ void end_relay_log_info(Relay_log_info* rli)
if (rli->info_fd >= 0)
{
end_io_cache(&rli->info_file);
(void) my_close(rli->info_fd, MYF(MY_WME));
mysql_file_close(rli->info_fd, MYF(MY_WME));
rli->info_fd = -1;
}
if (rli->cur_log_fd >= 0)
{
end_io_cache(&rli->cache_buf);
(void)my_close(rli->cur_log_fd, MYF(MY_WME));
mysql_file_close(rli->cur_log_fd, MYF(MY_WME));
rli->cur_log_fd = -1;
}
rli->inited = 0;
@ -4304,7 +4343,7 @@ static Log_event* next_event(Relay_log_info* rli)
{
Log_event* ev;
IO_CACHE* cur_log = rli->cur_log;
pthread_mutex_t *log_lock = rli->relay_log.get_log_lock();
mysql_mutex_t *log_lock = rli->relay_log.get_log_lock();
const char* errmsg=0;
THD* thd = rli->sql_thd;
DBUG_ENTER("next_event");
@ -4321,9 +4360,9 @@ static Log_event* next_event(Relay_log_info* rli)
so we assume calling function acquired this mutex for us and we will
hold it for the most of the loop below However, we will release it
whenever it is worth the hassle, and in the cases when we go into a
pthread_cond_wait() with the non-data_lock mutex
mysql_cond_wait() with the non-data_lock mutex
*/
safe_mutex_assert_owner(&rli->data_lock);
mysql_mutex_assert_owner(&rli->data_lock);
while (!sql_slave_killed(thd,rli))
{
@ -4342,7 +4381,7 @@ static Log_event* next_event(Relay_log_info* rli)
if ((hot_log = (cur_log != &rli->cache_buf)))
{
DBUG_ASSERT(rli->cur_log_fd == -1); // foreign descriptor
pthread_mutex_lock(log_lock);
mysql_mutex_lock(log_lock);
/*
Reading xxx_file_id is safe because the log will only
@ -4352,7 +4391,7 @@ static Log_event* next_event(Relay_log_info* rli)
{
// The master has switched to a new log file; Reopen the old log file
cur_log=reopen_relay_log(rli, &errmsg);
pthread_mutex_unlock(log_lock);
mysql_mutex_unlock(log_lock);
if (!cur_log) // No more log files
goto err;
hot_log=0; // Using old binary log
@ -4399,7 +4438,7 @@ static Log_event* next_event(Relay_log_info* rli)
*/
rli->future_event_relay_log_pos= my_b_tell(cur_log);
if (hot_log)
pthread_mutex_unlock(log_lock);
mysql_mutex_unlock(log_lock);
DBUG_RETURN(ev);
}
DBUG_ASSERT(thd==rli->sql_thd);
@ -4409,7 +4448,7 @@ static Log_event* next_event(Relay_log_info* rli)
{
errmsg = "slave SQL thread aborted because of I/O error";
if (hot_log)
pthread_mutex_unlock(log_lock);
mysql_mutex_unlock(log_lock);
goto err;
}
if (!cur_log->error) /* EOF */
@ -4456,7 +4495,7 @@ static Log_event* next_event(Relay_log_info* rli)
0, rli->ign_master_log_pos_end,
Rotate_log_event::DUP_NAME);
rli->ign_master_log_name_end[0]= 0;
pthread_mutex_unlock(log_lock);
mysql_mutex_unlock(log_lock);
if (unlikely(!ev))
{
errmsg= "Slave SQL thread failed to create a Rotate event "
@ -4471,7 +4510,7 @@ static Log_event* next_event(Relay_log_info* rli)
We can, and should release data_lock while we are waiting for
update. If we do not, show slave status will block
*/
pthread_mutex_unlock(&rli->data_lock);
mysql_mutex_unlock(&rli->data_lock);
/*
Possible deadlock :
@ -4497,7 +4536,7 @@ static Log_event* next_event(Relay_log_info* rli)
be stopped, and the SQL thread sets ignore_log_space_limit to 0 when
it stops.
*/
pthread_mutex_lock(&rli->log_space_lock);
mysql_mutex_lock(&rli->log_space_lock);
// prevent the I/O thread from blocking next times
rli->ignore_log_space_limit= 1;
/*
@ -4506,12 +4545,12 @@ static Log_event* next_event(Relay_log_info* rli)
~Relay_log_info(), i.e. when rli is destroyed, and rli will
not be destroyed before we exit the present function.
*/
pthread_mutex_unlock(&rli->log_space_lock);
pthread_cond_broadcast(&rli->log_space_cond);
mysql_mutex_unlock(&rli->log_space_lock);
mysql_cond_broadcast(&rli->log_space_cond);
// Note that wait_for_update_relay_log unlocks lock_log !
rli->relay_log.wait_for_update_relay_log(rli->sql_thd);
// re-acquire data lock since we released it earlier
pthread_mutex_lock(&rli->data_lock);
mysql_mutex_lock(&rli->data_lock);
rli->last_master_timestamp= save_timestamp;
continue;
}
@ -4522,7 +4561,7 @@ static Log_event* next_event(Relay_log_info* rli)
*/
end_io_cache(cur_log);
DBUG_ASSERT(rli->cur_log_fd >= 0);
my_close(rli->cur_log_fd, MYF(MY_WME));
mysql_file_close(rli->cur_log_fd, MYF(MY_WME));
rli->cur_log_fd = -1;
if (relay_log_purge)
@ -4579,7 +4618,7 @@ static Log_event* next_event(Relay_log_info* rli)
DBUG_PRINT("info",("hot_log: %d",hot_log));
if (!hot_log) /* if hot_log, we already have this mutex */
pthread_mutex_lock(log_lock);
mysql_mutex_lock(log_lock);
if (rli->relay_log.is_active(rli->linfo.log_file_name))
{
#ifdef EXTRA_DEBUG
@ -4600,13 +4639,16 @@ static Log_event* next_event(Relay_log_info* rli)
*/
if (check_binlog_magic(cur_log,&errmsg))
{
if (!hot_log) pthread_mutex_unlock(log_lock);
if (!hot_log)
mysql_mutex_unlock(log_lock);
goto err;
}
if (!hot_log) pthread_mutex_unlock(log_lock);
if (!hot_log)
mysql_mutex_unlock(log_lock);
continue;
}
if (!hot_log) pthread_mutex_unlock(log_lock);
if (!hot_log)
mysql_mutex_unlock(log_lock);
/*
if we get here, the log was not hot, so we will have to open it
ourselves. We are sure that the log is still not hot now (a log can get
@ -4629,7 +4671,7 @@ static Log_event* next_event(Relay_log_info* rli)
TODO: come up with something better to handle this error
*/
if (hot_log)
pthread_mutex_unlock(log_lock);
mysql_mutex_unlock(log_lock);
sql_print_error("Slave SQL thread: I/O error reading \
event(errno: %d cur_log->error: %d)",
my_errno,cur_log->error);

Some files were not shown because too many files have changed in this diff Show More