mirror of
https://github.com/MariaDB/server.git
synced 2025-01-16 12:02:42 +01:00
3cb578c001
- Part 3: Adding mem_root to push_back() and push_front() Other things: - Added THD as an argument to some partition functions. - Added memory overflow checking for XML tag's in read_xml()
288 lines
8 KiB
C++
288 lines
8 KiB
C++
/*
|
|
Copyright (c) 2001, 2011, Oracle and/or its affiliates.
|
|
|
|
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
|
|
|
/**
|
|
@file
|
|
|
|
All of the functions defined in this file which are not used (the ones to
|
|
handle failsafe) are not used; their code has not been updated for more
|
|
than one year now so should be considered as BADLY BROKEN. Do not enable
|
|
it. The used functions (to handle LOAD DATA FROM MASTER, plus some small
|
|
functions like register_slave()) are working.
|
|
*/
|
|
|
|
#include <my_global.h>
|
|
#include "sql_priv.h"
|
|
#include "sql_parse.h" // check_access
|
|
#ifdef HAVE_REPLICATION
|
|
|
|
#include "repl_failsafe.h"
|
|
#include "sql_acl.h" // REPL_SLAVE_ACL
|
|
#include "sql_repl.h"
|
|
#include "slave.h"
|
|
#include "rpl_mi.h"
|
|
#include "rpl_filter.h"
|
|
#include "log_event.h"
|
|
#include <mysql.h>
|
|
|
|
#define SLAVE_LIST_CHUNK 128
|
|
#define SLAVE_ERRMSG_SIZE (FN_REFLEN+64)
|
|
|
|
|
|
ulong rpl_status=RPL_NULL;
|
|
mysql_mutex_t LOCK_rpl_status;
|
|
HASH slave_list;
|
|
|
|
const char *rpl_role_type[] = {"MASTER","SLAVE",NullS};
|
|
TYPELIB rpl_role_typelib = {array_elements(rpl_role_type)-1,"",
|
|
rpl_role_type, NULL};
|
|
|
|
const char* rpl_status_type[]=
|
|
{
|
|
"AUTH_MASTER","IDLE_SLAVE","ACTIVE_SLAVE","LOST_SOLDIER","TROOP_SOLDIER",
|
|
"RECOVERY_CAPTAIN","NULL",NullS
|
|
};
|
|
|
|
/*
|
|
All of the functions defined in this file which are not used (the ones to
|
|
handle failsafe) are not used; their code has not been updated for more than
|
|
one year now so should be considered as BADLY BROKEN. Do not enable it.
|
|
The used functions (to handle LOAD DATA FROM MASTER, plus some small
|
|
functions like register_slave()) are working.
|
|
*/
|
|
|
|
void change_rpl_status(ulong from_status, ulong to_status)
|
|
{
|
|
mysql_mutex_lock(&LOCK_rpl_status);
|
|
if (rpl_status == from_status || rpl_status == RPL_ANY)
|
|
rpl_status = to_status;
|
|
mysql_mutex_unlock(&LOCK_rpl_status);
|
|
}
|
|
|
|
|
|
#define get_object(p, obj, msg) \
|
|
{\
|
|
uint len = (uint)*p++; \
|
|
if (p + len > p_end || len >= sizeof(obj)) \
|
|
{\
|
|
errmsg= msg;\
|
|
goto err; \
|
|
}\
|
|
strmake(obj,(char*) p,len); \
|
|
p+= len; \
|
|
}\
|
|
|
|
|
|
void unregister_slave(THD* thd, bool only_mine, bool need_mutex)
|
|
{
|
|
uint32 thd_server_id= thd->variables.server_id;
|
|
if (thd_server_id)
|
|
{
|
|
if (need_mutex)
|
|
mysql_mutex_lock(&LOCK_slave_list);
|
|
|
|
SLAVE_INFO* old_si;
|
|
if ((old_si = (SLAVE_INFO*)my_hash_search(&slave_list,
|
|
(uchar*)&thd_server_id, 4)) &&
|
|
(!only_mine || old_si->thd == thd))
|
|
my_hash_delete(&slave_list, (uchar*)old_si);
|
|
|
|
if (need_mutex)
|
|
mysql_mutex_unlock(&LOCK_slave_list);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
Register slave in 'slave_list' hash table.
|
|
|
|
@return
|
|
0 ok
|
|
@return
|
|
1 Error. Error message sent to client
|
|
*/
|
|
|
|
int register_slave(THD* thd, uchar* packet, uint packet_length)
|
|
{
|
|
int res;
|
|
SLAVE_INFO *si;
|
|
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, NULL, NULL, 0, 0))
|
|
return 1;
|
|
if (!(si = (SLAVE_INFO*)my_malloc(sizeof(SLAVE_INFO), MYF(MY_WME))))
|
|
goto err2;
|
|
|
|
thd->variables.server_id= si->server_id= uint4korr(p);
|
|
p+= 4;
|
|
get_object(p,si->host, "Failed to register slave: too long 'report-host'");
|
|
get_object(p,si->user, "Failed to register slave: too long 'report-user'");
|
|
get_object(p,si->password, "Failed to register slave; too long 'report-password'");
|
|
if (p+10 > p_end)
|
|
goto err;
|
|
si->port= uint2korr(p);
|
|
p += 2;
|
|
/*
|
|
We need to by pass the bytes used in the fake rpl_recovery_rank
|
|
variable. It was removed in patch for BUG#13963. But this would
|
|
make a server with that patch unable to connect to an old master.
|
|
See: BUG#49259
|
|
*/
|
|
// si->rpl_recovery_rank= uint4korr(p);
|
|
p += 4;
|
|
if (!(si->master_id= uint4korr(p)))
|
|
si->master_id= global_system_variables.server_id;
|
|
si->thd= thd;
|
|
|
|
mysql_mutex_lock(&LOCK_slave_list);
|
|
unregister_slave(thd,0,0);
|
|
res= my_hash_insert(&slave_list, (uchar*) si);
|
|
mysql_mutex_unlock(&LOCK_slave_list);
|
|
return res;
|
|
|
|
err:
|
|
my_free(si);
|
|
my_message(ER_UNKNOWN_ERROR, errmsg, MYF(0)); /* purecov: inspected */
|
|
err2:
|
|
return 1;
|
|
}
|
|
|
|
extern "C" uint32
|
|
*slave_list_key(SLAVE_INFO* si, size_t *len,
|
|
my_bool not_used __attribute__((unused)))
|
|
{
|
|
*len = 4;
|
|
return &si->server_id;
|
|
}
|
|
|
|
extern "C" void slave_info_free(void *s)
|
|
{
|
|
my_free(s);
|
|
}
|
|
|
|
#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);
|
|
mysql_mutex_init(key_LOCK_slave_list, &LOCK_slave_list, MY_MUTEX_INIT_FAST);
|
|
}
|
|
|
|
void end_slave_list()
|
|
{
|
|
/* No protection by a mutex needed as we are only called at shutdown */
|
|
if (my_hash_inited(&slave_list))
|
|
{
|
|
my_hash_free(&slave_list);
|
|
mysql_mutex_destroy(&LOCK_slave_list);
|
|
}
|
|
}
|
|
|
|
/**
|
|
Execute a SHOW SLAVE HOSTS statement.
|
|
|
|
@param thd Pointer to THD object for the client thread executing the
|
|
statement.
|
|
|
|
@retval FALSE success
|
|
@retval TRUE failure
|
|
*/
|
|
bool show_slave_hosts(THD* thd)
|
|
{
|
|
List<Item> field_list;
|
|
Protocol *protocol= thd->protocol;
|
|
MEM_ROOT *mem_root= thd->mem_root;
|
|
DBUG_ENTER("show_slave_hosts");
|
|
|
|
field_list.push_back(new (mem_root)
|
|
Item_return_int(thd, "Server_id", 10,
|
|
MYSQL_TYPE_LONG),
|
|
thd->mem_root);
|
|
field_list.push_back(new (mem_root)
|
|
Item_empty_string(thd, "Host", 20),
|
|
thd->mem_root);
|
|
if (opt_show_slave_auth_info)
|
|
{
|
|
field_list.push_back(new (mem_root) Item_empty_string(thd, "User", 20),
|
|
thd->mem_root);
|
|
field_list.push_back(new (mem_root) Item_empty_string(thd, "Password", 20),
|
|
thd->mem_root);
|
|
}
|
|
field_list.push_back(new (mem_root)
|
|
Item_return_int(thd, "Port", 7, MYSQL_TYPE_LONG),
|
|
thd->mem_root);
|
|
field_list.push_back(new (mem_root)
|
|
Item_return_int(thd, "Master_id", 10, MYSQL_TYPE_LONG),
|
|
thd->mem_root);
|
|
|
|
if (protocol->send_result_set_metadata(&field_list,
|
|
Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
|
|
DBUG_RETURN(TRUE);
|
|
|
|
mysql_mutex_lock(&LOCK_slave_list);
|
|
|
|
for (uint i = 0; i < slave_list.records; ++i)
|
|
{
|
|
SLAVE_INFO* si = (SLAVE_INFO*) my_hash_element(&slave_list, i);
|
|
protocol->prepare_for_resend();
|
|
protocol->store((uint32) si->server_id);
|
|
protocol->store(si->host, &my_charset_bin);
|
|
if (opt_show_slave_auth_info)
|
|
{
|
|
protocol->store(si->user, &my_charset_bin);
|
|
protocol->store(si->password, &my_charset_bin);
|
|
}
|
|
protocol->store((uint32) si->port);
|
|
protocol->store((uint32) si->master_id);
|
|
if (protocol->write())
|
|
{
|
|
mysql_mutex_unlock(&LOCK_slave_list);
|
|
DBUG_RETURN(TRUE);
|
|
}
|
|
}
|
|
mysql_mutex_unlock(&LOCK_slave_list);
|
|
my_eof(thd);
|
|
DBUG_RETURN(FALSE);
|
|
}
|
|
|
|
#endif /* HAVE_REPLICATION */
|
|
|