slave.cc 123 KB
Newer Older
1
/* Copyright (C) 2000-2003 MySQL AB
unknown's avatar
unknown committed
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
   
   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; either version 2 of the License, or
   (at your option) any later version.
   
   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"
unknown's avatar
SCRUM  
unknown committed
18 19 20

#ifdef HAVE_REPLICATION

unknown's avatar
unknown committed
21
#include <mysql.h>
22
#include <myisam.h>
23
#include "slave.h"
24
#include "sql_repl.h"
25
#include "repl_failsafe.h"
unknown's avatar
unknown committed
26
#include <thr_alarm.h>
unknown's avatar
unknown committed
27
#include <my_dir.h>
unknown's avatar
unknown committed
28
#include <sql_common.h>
unknown's avatar
SCRUM  
unknown committed
29

30 31 32
bool use_slave_mask = 0;
MY_BITMAP slave_error_mask;

33 34
typedef bool (*CHECK_KILLED_FUNC)(THD*,void*);

35
volatile bool slave_sql_running = 0, slave_io_running = 0;
36
char* slave_load_tmpdir = 0;
unknown's avatar
unknown committed
37
MASTER_INFO *active_mi;
38
volatile int active_mi_in_use = 0;
39
HASH replicate_do_table, replicate_ignore_table;
unknown's avatar
unknown committed
40
DYNAMIC_ARRAY replicate_wild_do_table, replicate_wild_ignore_table;
41
bool do_table_inited = 0, ignore_table_inited = 0;
unknown's avatar
unknown committed
42
bool wild_do_table_inited = 0, wild_ignore_table_inited = 0;
43
bool table_rules_on = 0;
44
ulonglong relay_log_space_limit = 0;
unknown's avatar
unknown committed
45 46 47 48 49 50 51

/*
  When slave thread exits, we need to remember the temporary tables so we
  can re-use them on slave start.

  TODO: move the vars below under MASTER_INFO
*/
52

53
int disconnect_slave_event_count = 0, abort_slave_event_count = 0;
54
int events_till_abort = -1;
55
static int events_till_disconnect = -1;
unknown's avatar
unknown committed
56

57
typedef enum { SLAVE_THD_IO, SLAVE_THD_SQL} SLAVE_THD_TYPE;
unknown's avatar
unknown committed
58

59
static int process_io_rotate(MASTER_INFO* mi, Rotate_log_event* rev);
unknown's avatar
unknown committed
60
static int process_io_create_file(MASTER_INFO* mi, Create_file_log_event* cev);
unknown's avatar
unknown committed
61
static bool wait_for_relay_log_space(RELAY_LOG_INFO* rli);
62 63
static inline bool io_slave_killed(THD* thd,MASTER_INFO* mi);
static inline bool sql_slave_killed(THD* thd,RELAY_LOG_INFO* rli);
unknown's avatar
unknown committed
64
static int count_relay_log_space(RELAY_LOG_INFO* rli);
65
static int init_slave_thread(THD* thd, SLAVE_THD_TYPE thd_type);
66
static int safe_connect(THD* thd, MYSQL* mysql, MASTER_INFO* mi);
unknown's avatar
unknown committed
67 68
static int safe_reconnect(THD* thd, MYSQL* mysql, MASTER_INFO* mi,
			  bool suppress_warnings);
unknown's avatar
unknown committed
69
static int connect_to_master(THD* thd, MYSQL* mysql, MASTER_INFO* mi,
unknown's avatar
unknown committed
70
			     bool reconnect, bool suppress_warnings);
71 72
static int safe_sleep(THD* thd, int sec, CHECK_KILLED_FUNC thread_killed,
		      void* thread_killed_arg);
73
static int request_table_dump(MYSQL* mysql, const char* db, const char* table);
74
static int create_table_from_dump(THD* thd, MYSQL *mysql, const char* db,
75
				  const char* table_name, bool overwrite);
unknown's avatar
unknown committed
76
static int check_master_version_and_clock(MYSQL* mysql, MASTER_INFO* mi);
77

78 79

/*
unknown's avatar
unknown committed
80
  Find out which replications threads are running
81

unknown's avatar
unknown committed
82 83 84 85 86 87 88 89 90 91 92 93 94
  SYNOPSIS
    init_thread_mask()
    mask		Return value here
    mi			master_info for slave
    inverse		If set, returns which threads are not running

  IMPLEMENTATION
    Get a bit mask for which threads are running so that we can later restart
    these threads.

  RETURN
    mask	If inverse == 0, running threads
		If inverse == 1, stopped threads    
95 96
*/

97 98 99 100 101 102 103 104
void init_thread_mask(int* mask,MASTER_INFO* mi,bool inverse)
{
  bool set_io = mi->slave_running, set_sql = mi->rli.slave_running;
  register int tmp_mask=0;
  if (set_io)
    tmp_mask |= SLAVE_IO;
  if (set_sql)
    tmp_mask |= SLAVE_SQL;
105 106
  if (inverse)
    tmp_mask^= (SLAVE_IO | SLAVE_SQL);
107 108 109
  *mask = tmp_mask;
}

110

unknown's avatar
unknown committed
111
/*
112
  lock_slave_threads()
unknown's avatar
unknown committed
113
*/
114

115 116 117 118 119 120 121
void lock_slave_threads(MASTER_INFO* mi)
{
  //TODO: see if we can do this without dual mutex
  pthread_mutex_lock(&mi->run_lock);
  pthread_mutex_lock(&mi->rli.run_lock);
}

122

unknown's avatar
unknown committed
123
/*
124
  unlock_slave_threads()
unknown's avatar
unknown committed
125
*/
126

127 128 129 130 131 132 133
void unlock_slave_threads(MASTER_INFO* mi)
{
  //TODO: see if we can do this without dual mutex
  pthread_mutex_unlock(&mi->rli.run_lock);
  pthread_mutex_unlock(&mi->run_lock);
}

134

unknown's avatar
unknown committed
135
/* Initialize slave structures */
136

137 138
int init_slave()
{
139
  DBUG_ENTER("init_slave");
140

141 142
  /* This is called when mysqld starts */

143 144 145 146
  /*
    TODO: re-write this to interate through the list of files
    for multi-master
  */
unknown's avatar
unknown committed
147
  active_mi= new MASTER_INFO;
148 149

  /*
150 151 152
    If master_host is not specified, try to read it from the master_info file.
    If master_host is specified, create the master_info file if it doesn't
    exists.
153
  */
154 155 156 157 158 159
  if (!active_mi)
  {
    sql_print_error("Failed to allocate memory for the master info structure");
    goto err;
  }
    
unknown's avatar
unknown committed
160
  if (init_master_info(active_mi,master_info_file,relay_log_info_file,
161
		       !master_host))
162
  {
163
    sql_print_error("Failed to initialize the master info structure");
unknown's avatar
unknown committed
164
    goto err;
165
  }
166 167 168 169 170 171 172 173 174

  /*
    make sure slave thread gets started if server_id is set,
    valid master.info is present, and master_host has not been specified
  */
  if (server_id && !master_host && active_mi->host[0])
    master_host= active_mi->host;

  if (master_host && !opt_skip_slave_start)
175
  {
176 177 178 179 180 181
    if (start_slave_threads(1 /* need mutex */,
			    0 /* no wait for start*/,
			    active_mi,
			    master_info_file,
			    relay_log_info_file,
			    SLAVE_IO | SLAVE_SQL))
unknown's avatar
unknown committed
182
    {
183
      sql_print_error("Failed to create slave threads");
unknown's avatar
unknown committed
184 185
      goto err;
    }
186
  }
187
  DBUG_RETURN(0);
188

unknown's avatar
unknown committed
189 190
err:
  DBUG_RETURN(1);
191
}
192

193

194 195
static void free_table_ent(TABLE_RULE_ENT* e)
{
unknown's avatar
unknown committed
196
  my_free((gptr) e, MYF(0));
197 198
}

199

200 201 202 203 204 205 206
static byte* get_table_key(TABLE_RULE_ENT* e, uint* len,
			   my_bool not_used __attribute__((unused)))
{
  *len = e->key_len;
  return (byte*)e->db;
}

207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225

/*
  Open the given relay log

  SYNOPSIS
    init_relay_log_pos()
    rli			Relay information (will be initialized)
    log			Name of relay log file to read from. NULL = First log
    pos			Position in relay log file 
    need_data_lock	Set to 1 if this functions should do mutex locks
    errmsg		Store pointer to error message here

  DESCRIPTION
  - Close old open relay log files.
  - If we are using the same relay log as the running IO-thread, then set
    rli->cur_log to point to the same IO_CACHE entry.
  - If not, open the 'log' binary file.

  TODO
226
    - check proper initialization of group_master_log_name/group_master_log_pos
227 228 229 230 231

  RETURN VALUES
    0	ok
    1	error.  errmsg is set to point to the error message
*/
unknown's avatar
unknown committed
232

233 234 235 236
int init_relay_log_pos(RELAY_LOG_INFO* rli,const char* log,
		       ulonglong pos, bool need_data_lock,
		       const char** errmsg)
{
unknown's avatar
unknown committed
237 238
  DBUG_ENTER("init_relay_log_pos");

239
  *errmsg=0;
240
  pthread_mutex_t *log_lock=rli->relay_log.get_log_lock();
241
  
242 243 244
  if (need_data_lock)
    pthread_mutex_lock(&rli->data_lock);
  
245 246
  pthread_mutex_lock(log_lock);
  
247
  /* Close log file and free buffers if it's already open */
248 249 250 251 252 253 254
  if (rli->cur_log_fd >= 0)
  {
    end_io_cache(&rli->cache_buf);
    my_close(rli->cur_log_fd, MYF(MY_WME));
    rli->cur_log_fd = -1;
  }
  
255
  rli->group_relay_log_pos = rli->event_relay_log_pos = pos;
unknown's avatar
unknown committed
256

unknown's avatar
unknown committed
257 258 259 260
  /*
    Test to see if the previous run was with the skip of purging
    If yes, we do not purge when we restart
  */
261
  if (rli->relay_log.find_log_pos(&rli->linfo, NullS, 1))
262 263 264 265
  {
    *errmsg="Could not find first log during relay log initialization";
    goto err;
  }
266

267
  if (log && rli->relay_log.find_log_pos(&rli->linfo, log, 1))
unknown's avatar
unknown committed
268
  {
269 270
    *errmsg="Could not find target log during relay log initialization";
    goto err;
unknown's avatar
unknown committed
271
  }
272 273 274 275
  strmake(rli->group_relay_log_name,rli->linfo.log_file_name,
	  sizeof(rli->group_relay_log_name)-1);
  strmake(rli->event_relay_log_name,rli->linfo.log_file_name,
	  sizeof(rli->event_relay_log_name)-1);
276 277
  if (rli->relay_log.is_active(rli->linfo.log_file_name))
  {
278 279 280 281 282
    /*
      The IO thread is using this log file.
      In this case, we will use the same IO_CACHE pointer to
      read data as the IO thread is using to write data.
    */
283
    if (my_b_tell((rli->cur_log=rli->relay_log.get_log_file())) == 0 &&
unknown's avatar
unknown committed
284
	check_binlog_magic(rli->cur_log,errmsg))
285
      goto err;
unknown's avatar
unknown committed
286
    rli->cur_log_old_open_count=rli->relay_log.get_open_count();
287 288 289
  }
  else
  {
290 291 292
    /*
      Open the relay log and set rli->cur_log to point at this one
    */
293 294 295 296 297
    if ((rli->cur_log_fd=open_binlog(&rli->cache_buf,
				     rli->linfo.log_file_name,errmsg)) < 0)
      goto err;
    rli->cur_log = &rli->cache_buf;
  }
298
  if (pos >= BIN_LOG_HEADER_SIZE)
unknown's avatar
unknown committed
299 300
    my_b_seek(rli->cur_log,(off_t)pos);

301
err:
302 303 304 305
  /*
    If we don't purge, we can't honour relay_log_space_limit ;
    silently discard it
  */
306
  if (!relay_log_purge)
307
    rli->log_space_limit= 0;
unknown's avatar
unknown committed
308
  pthread_cond_broadcast(&rli->data_cond);
309 310 311
  
  pthread_mutex_unlock(log_lock);

unknown's avatar
unknown committed
312 313
  if (need_data_lock)
    pthread_mutex_unlock(&rli->data_lock);
314

unknown's avatar
unknown committed
315
  DBUG_RETURN ((*errmsg) ? 1 : 0);
316 317
}

318

unknown's avatar
unknown committed
319 320
/*
  Init functio to set up array for errors that should be skipped for slave
unknown's avatar
unknown committed
321

unknown's avatar
unknown committed
322 323 324 325 326 327 328
  SYNOPSIS
    init_slave_skip_errors()
    arg		List of errors numbers to skip, separated with ','

  NOTES
    Called from get_options() in mysqld.cc on start-up
*/
329

unknown's avatar
unknown committed
330
void init_slave_skip_errors(const char* arg)
331
{
unknown's avatar
unknown committed
332
  const char *p;
333
  if (bitmap_init(&slave_error_mask,0,MAX_SLAVE_ERROR,0))
334 335 336 337 338
  {
    fprintf(stderr, "Badly out of memory, please check your system status\n");
    exit(1);
  }
  use_slave_mask = 1;
339
  for (;my_isspace(system_charset_info,*arg);++arg)
340
    /* empty */;
341
  if (!my_strnncoll(system_charset_info,(uchar*)arg,4,(const uchar*)"all",4))
342 343 344 345 346 347 348 349 350 351 352
  {
    bitmap_set_all(&slave_error_mask);
    return;
  }
  for (p= arg ; *p; )
  {
    long err_code;
    if (!(p= str2int(p, 10, 0, LONG_MAX, &err_code)))
      break;
    if (err_code < MAX_SLAVE_ERROR)
       bitmap_set_bit(&slave_error_mask,(uint)err_code);
353
    while (!my_isdigit(system_charset_info,*p) && *p)
354 355 356 357
      p++;
  }
}

unknown's avatar
unknown committed
358 359 360 361 362 363 364 365 366 367 368 369 370
void st_relay_log_info::close_temporary_tables()
{
  TABLE *table,*next;

  for (table=save_temporary_tables ; table ; table=next)
  {
    next=table->next;
    /*
      Don't ask for disk deletion. For now, anyway they will be deleted when
      slave restarts, but it is a better intention to not delete them.
    */
    close_temporary(table, 0);
  }
371 372
  save_temporary_tables= 0;
  slave_open_temp_tables= 0;
unknown's avatar
unknown committed
373
}
unknown's avatar
unknown committed
374

unknown's avatar
unknown committed
375
/*
376 377
  purge_relay_logs()

unknown's avatar
unknown committed
378 379
  NOTES
    Assumes to have a run lock on rli and that no slave thread are running.
unknown's avatar
unknown committed
380 381
*/

382 383
int purge_relay_logs(RELAY_LOG_INFO* rli, THD *thd, bool just_reset,
		     const char** errmsg)
384
{
385
  int error=0;
unknown's avatar
unknown committed
386
  DBUG_ENTER("purge_relay_logs");
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405

  /*
    Even if rli->inited==0, we still try to empty rli->master_log_* variables.
    Indeed, rli->inited==0 does not imply that they already are empty.
    It could be that slave's info initialization partly succeeded : 
    for example if relay-log.info existed but *relay-bin*.*
    have been manually removed, init_relay_log_info reads the old 
    relay-log.info and fills rli->master_log_*, then init_relay_log_info
    checks for the existence of the relay log, this fails and
    init_relay_log_info leaves rli->inited to 0.
    In that pathological case, rli->master_log_pos* will be properly reinited
    at the next START SLAVE (as RESET SLAVE or CHANGE
    MASTER, the callers of purge_relay_logs, will delete bogus *.info files
    or replace them with correct files), however if the user does SHOW SLAVE
    STATUS before START SLAVE, he will see old, confusing rli->master_log_*.
    In other words, we reinit rli->master_log_* for SHOW SLAVE STATUS 
    to display fine in any case.
  */

406 407
  rli->group_master_log_name[0]= 0;
  rli->group_master_log_pos= 0;
408

409
  if (!rli->inited)
410 411
  {
    DBUG_PRINT("info", ("rli->inited == 0"));
412
    DBUG_RETURN(0);
413
  }
unknown's avatar
unknown committed
414

415 416
  DBUG_ASSERT(rli->slave_running == 0);
  DBUG_ASSERT(rli->mi->slave_running == 0);
unknown's avatar
unknown committed
417

418 419
  rli->slave_skip_counter=0;
  pthread_mutex_lock(&rli->data_lock);
420
  if (rli->relay_log.reset_logs(thd))
421 422 423 424 425
  {
    *errmsg = "Failed during log reset";
    error=1;
    goto err;
  }
426
  /* Save name of used relay log file */
427 428 429 430
  strmake(rli->group_relay_log_name, rli->relay_log.get_log_fname(),
	  sizeof(rli->group_relay_log_name)-1);
  strmake(rli->event_relay_log_name, rli->relay_log.get_log_fname(),
 	  sizeof(rli->event_relay_log_name)-1);
unknown's avatar
unknown committed
431 432
  // Just first log with magic number and nothing else
  rli->log_space_total= BIN_LOG_HEADER_SIZE;
433
  rli->group_relay_log_pos= rli->event_relay_log_pos= BIN_LOG_HEADER_SIZE;
unknown's avatar
unknown committed
434
  rli->relay_log.reset_bytes_written();
435
  if (!just_reset)
436 437 438
    error= init_relay_log_pos(rli, rli->group_relay_log_name, rli->group_relay_log_pos,
  			      0 /* do not need data lock */, errmsg);
  
unknown's avatar
unknown committed
439 440 441 442
err:
#ifndef DBUG_OFF
  char buf[22];
#endif  
unknown's avatar
unknown committed
443
  DBUG_PRINT("info",("log_space_total: %s",llstr(rli->log_space_total,buf)));
444
  pthread_mutex_unlock(&rli->data_lock);
unknown's avatar
unknown committed
445
  DBUG_RETURN(error);
446 447
}

448

449 450 451 452 453 454 455
int terminate_slave_threads(MASTER_INFO* mi,int thread_mask,bool skip_lock)
{
  if (!mi->inited)
    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;
  pthread_mutex_t *sql_cond_lock,*io_cond_lock;
456
  DBUG_ENTER("terminate_slave_threads");
457 458 459 460 461 462 463 464 465 466

  sql_cond_lock=sql_lock;
  io_cond_lock=io_lock;
  
  if (skip_lock)
  {
    sql_lock = io_lock = 0;
  }
  if ((thread_mask & (SLAVE_IO|SLAVE_FORCE_ALL)) && mi->slave_running)
  {
unknown's avatar
unknown committed
467
    DBUG_PRINT("info",("Terminating IO thread"));
468 469
    mi->abort_slave=1;
    if ((error=terminate_slave_thread(mi->io_thd,io_lock,
unknown's avatar
unknown committed
470 471 472
				      io_cond_lock,
				      &mi->stop_cond,
				      &mi->slave_running)) &&
473
	!force_all)
474
      DBUG_RETURN(error);
475 476 477
  }
  if ((thread_mask & (SLAVE_SQL|SLAVE_FORCE_ALL)) && mi->rli.slave_running)
  {
unknown's avatar
unknown committed
478
    DBUG_PRINT("info",("Terminating SQL thread"));
479 480 481 482 483 484 485
    DBUG_ASSERT(mi->rli.sql_thd != 0) ;
    mi->rli.abort_slave=1;
    if ((error=terminate_slave_thread(mi->rli.sql_thd,sql_lock,
				      sql_cond_lock,
				      &mi->rli.stop_cond,
				      &mi->rli.slave_running)) &&
	!force_all)
486
      DBUG_RETURN(error);
487
  }
488
  DBUG_RETURN(0);
489 490
}

491

492 493 494 495 496 497 498 499 500 501 502 503 504 505 506
int terminate_slave_thread(THD* thd, pthread_mutex_t* term_lock,
			   pthread_mutex_t *cond_lock,
			   pthread_cond_t* term_cond,
			   volatile bool* slave_running)
{
  if (term_lock)
  {
    pthread_mutex_lock(term_lock);
    if (!*slave_running)
    {
      pthread_mutex_unlock(term_lock);
      return ER_SLAVE_NOT_RUNNING;
    }
  }
  DBUG_ASSERT(thd != 0);
unknown's avatar
unknown committed
507 508 509
  /*
    Is is criticate to test if the slave is running. Otherwise, we might
    be referening freed memory trying to kick it
510
  */
511
  THD_CHECK_SENTRY(thd);
unknown's avatar
unknown committed
512 513

  while (*slave_running)			// Should always be true
514 515
  {
    KICK_SLAVE(thd);
unknown's avatar
unknown committed
516 517 518
    /*
      There is a small chance that slave thread might miss the first
      alarm. To protect againts it, resend the signal until it reacts
519 520
    */
    struct timespec abstime;
unknown's avatar
unknown committed
521
    set_timespec(abstime,2);
522 523 524 525 526 527 528
    pthread_cond_timedwait(term_cond, cond_lock, &abstime);
  }
  if (term_lock)
    pthread_mutex_unlock(term_lock);
  return 0;
}

529

unknown's avatar
unknown committed
530
int start_slave_thread(pthread_handler h_func, pthread_mutex_t *start_lock,
531
		       pthread_mutex_t *cond_lock,
unknown's avatar
unknown committed
532 533 534
		       pthread_cond_t *start_cond,
		       volatile bool *slave_running,
		       volatile ulong *slave_run_id,
535 536
		       MASTER_INFO* mi,
                       bool high_priority)
537 538
{
  pthread_t th;
unknown's avatar
unknown committed
539
  ulong start_id;
540
  DBUG_ASSERT(mi->inited);
unknown's avatar
unknown committed
541 542
  DBUG_ENTER("start_slave_thread");

543 544 545 546 547 548 549 550 551
  if (start_lock)
    pthread_mutex_lock(start_lock);
  if (!server_id)
  {
    if (start_cond)
      pthread_cond_broadcast(start_cond);
    if (start_lock)
      pthread_mutex_unlock(start_lock);
    sql_print_error("Server id not set, will not start slave");
unknown's avatar
unknown committed
552
    DBUG_RETURN(ER_BAD_SLAVE);
553 554 555
  }
  
  if (*slave_running)
556 557 558 559 560
  {
    if (start_cond)
      pthread_cond_broadcast(start_cond);
    if (start_lock)
      pthread_mutex_unlock(start_lock);
unknown's avatar
unknown committed
561
    DBUG_RETURN(ER_SLAVE_MUST_STOP);
562
  }
unknown's avatar
unknown committed
563 564
  start_id= *slave_run_id;
  DBUG_PRINT("info",("Creating new slave thread"));
565 566
  if (high_priority)
    my_pthread_attr_setprio(&connection_attrib,CONNECT_PRIOR);
567 568 569 570
  if (pthread_create(&th, &connection_attrib, h_func, (void*)mi))
  {
    if (start_lock)
      pthread_mutex_unlock(start_lock);
unknown's avatar
unknown committed
571
    DBUG_RETURN(ER_SLAVE_THREAD);
572 573 574 575
  }
  if (start_cond && cond_lock)
  {
    THD* thd = current_thd;
unknown's avatar
unknown committed
576
    while (start_id == *slave_run_id)
577
    {
unknown's avatar
unknown committed
578
      DBUG_PRINT("sleep",("Waiting for slave thread to start"));
579
      const char* old_msg = thd->enter_cond(start_cond,cond_lock,
580
					    "Waiting for slave thread to start");
581 582 583 584 585
      pthread_cond_wait(start_cond,cond_lock);
      thd->exit_cond(old_msg);
      if (thd->killed)
      {
	pthread_mutex_unlock(cond_lock);
unknown's avatar
unknown committed
586
	DBUG_RETURN(ER_SERVER_SHUTDOWN);
587 588 589 590 591
      }
    }
  }
  if (start_lock)
    pthread_mutex_unlock(start_lock);
unknown's avatar
unknown committed
592
  DBUG_RETURN(0);
593
}
unknown's avatar
unknown committed
594

595

unknown's avatar
unknown committed
596
/*
597
  start_slave_threads()
unknown's avatar
unknown committed
598

unknown's avatar
unknown committed
599 600 601 602
  NOTES
    SLAVE_FORCE_ALL is not implemented here on purpose since it does not make
    sense to do that for starting a slave--we always care if it actually
    started the threads that were not previously running
603
*/
unknown's avatar
unknown committed
604

605 606 607 608 609 610 611
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;
  int error=0;
612
  DBUG_ENTER("start_slave_threads");
613 614 615 616 617 618 619 620 621 622 623 624 625
  
  if (need_slave_mutex)
  {
    lock_io = &mi->run_lock;
    lock_sql = &mi->rli.run_lock;
  }
  if (wait_for_start)
  {
    cond_io = &mi->start_cond;
    cond_sql = &mi->rli.start_cond;
    lock_cond_io = &mi->run_lock;
    lock_cond_sql = &mi->rli.run_lock;
  }
626 627 628

  if (thread_mask & SLAVE_IO)
    error=start_slave_thread(handle_slave_io,lock_io,lock_cond_io,
unknown's avatar
unknown committed
629 630
			     cond_io,
			     &mi->slave_running, &mi->slave_run_id,
631
			     mi, 1); //high priority, to read the most possible
632
  if (!error && (thread_mask & SLAVE_SQL))
633
  {
634 635
    error=start_slave_thread(handle_slave_sql,lock_sql,lock_cond_sql,
			     cond_sql,
unknown's avatar
unknown committed
636
			     &mi->rli.slave_running, &mi->rli.slave_run_id,
637
			     mi, 0);
638 639 640
    if (error)
      terminate_slave_threads(mi, thread_mask & SLAVE_IO, 0);
  }
641
  DBUG_RETURN(error);
642
}
643

644

645 646
void init_table_rule_hash(HASH* h, bool* h_inited)
{
unknown's avatar
unknown committed
647
  hash_init(h, system_charset_info,TABLE_RULE_HASH_SIZE,0,0,
648
	    (hash_get_key) get_table_key,
649
	    (hash_free_key) free_table_ent, 0);
650 651
  *h_inited = 1;
}
unknown's avatar
unknown committed
652

653

unknown's avatar
unknown committed
654 655
void init_table_rule_array(DYNAMIC_ARRAY* a, bool* a_inited)
{
656
  my_init_dynamic_array(a, sizeof(TABLE_RULE_ENT*), TABLE_RULE_ARR_SIZE,
unknown's avatar
unknown committed
657 658 659 660
		     TABLE_RULE_ARR_SIZE);
  *a_inited = 1;
}

661

unknown's avatar
unknown committed
662 663 664 665 666
static TABLE_RULE_ENT* find_wild(DYNAMIC_ARRAY *a, const char* key, int len)
{
  uint i;
  const char* key_end = key + len;
  
667
  for (i = 0; i < a->elements; i++)
unknown's avatar
unknown committed
668 669 670
    {
      TABLE_RULE_ENT* e ;
      get_dynamic(a, (gptr)&e, i);
unknown's avatar
unknown committed
671
      if (!my_wildcmp(system_charset_info, key, key_end, 
672
                            (const char*)e->db,
unknown's avatar
unknown committed
673 674
			    (const char*)(e->db + e->key_len),
			    '\\',wild_one,wild_many))
unknown's avatar
unknown committed
675 676 677 678 679 680
	return e;
    }
  
  return 0;
}

681

682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700
/*
  Checks whether tables match some (wild_)do_table and (wild_)ignore_table
  rules (for replication)

  SYNOPSIS
    tables_ok()
    thd             thread (SQL slave thread normally)
    tables          list of tables to check

  NOTES
    Note that changing the order of the tables in the list can lead to
    different results. Note also the order of precedence of the do/ignore 
    rules (see code below). For that reason, users should not set conflicting 
    rules because they may get unpredicted results.

  RETURN VALUES
    0           should not be logged/replicated
    1           should be logged/replicated                  
*/
701

702 703
int tables_ok(THD* thd, TABLE_LIST* tables)
{
704 705
  DBUG_ENTER("tables_ok");

unknown's avatar
unknown committed
706 707
  for (; tables; tables = tables->next)
  {
708 709 710 711
    char hash_key[2*NAME_LEN+2];
    char *end;
    uint len;

unknown's avatar
unknown committed
712 713
    if (!tables->updating) 
      continue;
714 715 716
    end= strmov(hash_key, tables->db ? tables->db : thd->db);
    *end++= '.';
    len= (uint) (strmov(end, tables->real_name) - hash_key);
unknown's avatar
unknown committed
717
    if (do_table_inited) // if there are any do's
718
    {
unknown's avatar
unknown committed
719
      if (hash_search(&replicate_do_table, (byte*) hash_key, len))
720
	DBUG_RETURN(1);
unknown's avatar
unknown committed
721
    }
722
    if (ignore_table_inited) // if there are any ignores
unknown's avatar
unknown committed
723 724
    {
      if (hash_search(&replicate_ignore_table, (byte*) hash_key, len))
725
	DBUG_RETURN(0); 
726
    }
unknown's avatar
unknown committed
727 728
    if (wild_do_table_inited && find_wild(&replicate_wild_do_table,
					  hash_key, len))
729
      DBUG_RETURN(1);
unknown's avatar
unknown committed
730 731
    if (wild_ignore_table_inited && find_wild(&replicate_wild_ignore_table,
					      hash_key, len))
732
      DBUG_RETURN(0);
unknown's avatar
unknown committed
733
  }
734

unknown's avatar
unknown committed
735 736 737 738
  /*
    If no explicit rule found and there was a do list, do not replicate.
    If there was no do list, go ahead
  */
739
  DBUG_RETURN(!do_table_inited && !wild_do_table_inited);
740 741
}

742

743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792
/*
  Checks whether a db matches wild_do_table and wild_ignore_table
  rules (for replication)

  SYNOPSIS
    db_ok_with_wild_table()
    db		name of the db to check.
		Is tested with check_db_name() before calling this function.

  NOTES
    Here is the reason for this function.
    We advise users who want to exclude a database 'db1' safely to do it
    with replicate_wild_ignore_table='db1.%' instead of binlog_ignore_db or
    replicate_ignore_db because the two lasts only check for the selected db,
    which won't work in that case:
    USE db2;
    UPDATE db1.t SET ... #this will be replicated and should not
    whereas replicate_wild_ignore_table will work in all cases.
    With replicate_wild_ignore_table, we only check tables. When
    one does 'DROP DATABASE db1', tables are not involved and the
    statement will be replicated, while users could expect it would not (as it
    rougly means 'DROP db1.first_table, DROP db1.second_table...').
    In other words, we want to interpret 'db1.%' as "everything touching db1".
    That is why we want to match 'db1' against 'db1.%' wild table rules.

  RETURN VALUES
    0           should not be logged/replicated
    1           should be logged/replicated
 */

int db_ok_with_wild_table(const char *db)
{
  char hash_key[NAME_LEN+2];
  char *end;
  int len;
  end= strmov(hash_key, db);
  *end++= '.';
  len= end - hash_key ;
  if (wild_do_table_inited && find_wild(&replicate_wild_do_table,
                                        hash_key, len))
    return 1;
  if (wild_ignore_table_inited && find_wild(&replicate_wild_ignore_table,
                                            hash_key, len))
    return 0;
  
  /*
    If no explicit rule found and there was a do list, do not replicate.
    If there was no do list, go ahead
  */
  return !wild_do_table_inited;
793 794 795 796 797
}


int add_table_rule(HASH* h, const char* table_spec)
{
unknown's avatar
unknown committed
798
  const char* dot = strchr(table_spec, '.');
unknown's avatar
unknown committed
799
  if (!dot) return 1;
unknown's avatar
unknown committed
800
  // len is always > 0 because we know the there exists a '.'
801 802 803
  uint len = (uint)strlen(table_spec);
  TABLE_RULE_ENT* e = (TABLE_RULE_ENT*)my_malloc(sizeof(TABLE_RULE_ENT)
						 + len, MYF(MY_WME));
unknown's avatar
unknown committed
804
  if (!e) return 1;
805 806 807 808
  e->db = (char*)e + sizeof(TABLE_RULE_ENT);
  e->tbl_name = e->db + (dot - table_spec) + 1;
  e->key_len = len;
  memcpy(e->db, table_spec, len);
unknown's avatar
SCRUM  
unknown committed
809
  (void)my_hash_insert(h, (byte*)e);
810 811 812
  return 0;
}

813

unknown's avatar
unknown committed
814 815 816
/*
  Add table expression with wildcards to dynamic array
*/
817

unknown's avatar
unknown committed
818 819
int add_wild_table_rule(DYNAMIC_ARRAY* a, const char* table_spec)
{
unknown's avatar
unknown committed
820
  const char* dot = strchr(table_spec, '.');
unknown's avatar
unknown committed
821
  if (!dot) return 1;
unknown's avatar
unknown committed
822 823 824
  uint len = (uint)strlen(table_spec);
  TABLE_RULE_ENT* e = (TABLE_RULE_ENT*)my_malloc(sizeof(TABLE_RULE_ENT)
						 + len, MYF(MY_WME));
unknown's avatar
unknown committed
825
  if (!e) return 1;
unknown's avatar
unknown committed
826 827 828 829 830 831 832 833
  e->db = (char*)e + sizeof(TABLE_RULE_ENT);
  e->tbl_name = e->db + (dot - table_spec) + 1;
  e->key_len = len;
  memcpy(e->db, table_spec, len);
  insert_dynamic(a, (gptr)&e);
  return 0;
}

834

835 836 837
static void free_string_array(DYNAMIC_ARRAY *a)
{
  uint i;
838
  for (i = 0; i < a->elements; i++)
839 840
    {
      char* p;
unknown's avatar
unknown committed
841
      get_dynamic(a, (gptr) &p, i);
842 843 844 845 846
      my_free(p, MYF(MY_WME));
    }
  delete_dynamic(a);
}

847

848
#ifdef NOT_USED_YET
849 850 851 852 853
static int end_slave_on_walk(MASTER_INFO* mi, gptr /*unused*/)
{
  end_master_info(mi);
  return 0;
}
854
#endif
855

856

unknown's avatar
unknown committed
857 858 859 860 861 862
/*
  Free all resources used by slave

  SYNOPSIS
    end_slave()
*/
863

864 865
void end_slave()
{
unknown's avatar
unknown committed
866
  /* This is called when the server terminates, in close_connections(). */
unknown's avatar
unknown committed
867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886
  if (active_mi)
  {
    /*
      TODO: replace the line below with
      list_walk(&master_list, (list_walk_action)end_slave_on_walk,0);
      once multi-master code is ready.
    */
    terminate_slave_threads(active_mi,SLAVE_FORCE_ALL);
    end_master_info(active_mi);
    if (do_table_inited)
      hash_free(&replicate_do_table);
    if (ignore_table_inited)
      hash_free(&replicate_ignore_table);
    if (wild_do_table_inited)
      free_string_array(&replicate_wild_do_table);
    if (wild_ignore_table_inited)
      free_string_array(&replicate_wild_ignore_table);
    delete active_mi;
    active_mi= 0;
  }
887
}
unknown's avatar
unknown committed
888

889

890
static bool io_slave_killed(THD* thd, MASTER_INFO* mi)
unknown's avatar
unknown committed
891
{
892 893 894
  DBUG_ASSERT(mi->io_thd == thd);
  DBUG_ASSERT(mi->slave_running == 1); // tracking buffer overrun
  return mi->abort_slave || abort_loop || thd->killed;
unknown's avatar
unknown committed
895 896
}

897

898
static bool sql_slave_killed(THD* thd, RELAY_LOG_INFO* rli)
899 900 901 902 903 904
{
  DBUG_ASSERT(rli->sql_thd == thd);
  DBUG_ASSERT(rli->slave_running == 1);// tracking buffer overrun
  return rli->abort_slave || abort_loop || thd->killed;
}

905

906 907 908 909 910 911 912 913 914 915 916 917 918 919
/*
  Writes an error message to rli->last_slave_error and rli->last_slave_errno
  (which will be displayed by SHOW SLAVE STATUS), and prints it to stderr.

  SYNOPSIS
    slave_print_error()
    rli		
    err_code    The error code
    msg         The error message (usually related to the error code, but can
                contain more information).
    ...         (this is printf-like format, with % symbols in msg)

  RETURN VALUES
    void
920
*/
921

922
void slave_print_error(RELAY_LOG_INFO* rli, int err_code, const char* msg, ...)
923 924 925
{
  va_list args;
  va_start(args,msg);
926 927 928
  my_vsnprintf(rli->last_slave_error,
	       sizeof(rli->last_slave_error), msg, args);
  rli->last_slave_errno = err_code;
929 930
  /* If the error string ends with '.', do not add a ',' it would be ugly */
  if (rli->last_slave_error[0] && 
931 932
      (*(strend(rli->last_slave_error)-1) == '.'))
    sql_print_error("Slave: %s Error_code: %d", rli->last_slave_error,
933 934
                    err_code);
  else
935
    sql_print_error("Slave: %s, Error_code: %d", rli->last_slave_error,
936 937
                    err_code);

938 939
}

unknown's avatar
unknown committed
940
/*
941 942
  skip_load_data_infile()

unknown's avatar
unknown committed
943 944 945
  NOTES
    This is used to tell a 3.23 master to break send_file()
*/
946 947 948 949 950 951 952 953

void skip_load_data_infile(NET *net)
{
  (void)net_request_file(net, "/dev/null");
  (void)my_net_read(net);				// discard response
  (void)net_write_command(net, 0, "", 0, "", 0);	// Send ok
}

954

955
bool net_request_file(NET* net, const char* fname)
956
{
957 958
  DBUG_ENTER("net_request_file");
  DBUG_RETURN(net_write_command(net, 251, fname, strlen(fname), "", 0));
959 960
}

961

962
const char *rewrite_db(const char* db)
unknown's avatar
unknown committed
963
{
unknown's avatar
unknown committed
964 965
  if (replicate_rewrite_db.is_empty() || !db)
    return db;
unknown's avatar
unknown committed
966 967 968
  I_List_iterator<i_string_pair> it(replicate_rewrite_db);
  i_string_pair* tmp;

unknown's avatar
unknown committed
969 970 971 972 973
  while ((tmp=it++))
  {
    if (!strcmp(tmp->key, db))
      return tmp->val;
  }
unknown's avatar
unknown committed
974 975
  return db;
}
976

977 978
/*
  From other comments and tests in code, it looks like
979
  sometimes Query_log_event and Load_log_event can have db == 0
980 981 982
  (see rewrite_db() above for example)
  (cases where this happens are unclear; it may be when the master is 3.23).
*/
983 984

const char *print_slave_db_safe(const char* db)
985
{
986
  return (db ? rewrite_db(db) : "");
987
}
988

989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002
/*
  Checks whether a db matches some do_db and ignore_db rules
  (for logging or replication)

  SYNOPSIS
    db_ok()
    db              name of the db to check
    do_list         either binlog_do_db or replicate_do_db
    ignore_list     either binlog_ignore_db or replicate_ignore_db

  RETURN VALUES
    0           should not be logged/replicated
    1           should be logged/replicated                  
*/
unknown's avatar
unknown committed
1003

unknown's avatar
unknown committed
1004 1005 1006
int db_ok(const char* db, I_List<i_string> &do_list,
	  I_List<i_string> &ignore_list )
{
unknown's avatar
unknown committed
1007
  if (do_list.is_empty() && ignore_list.is_empty())
unknown's avatar
unknown committed
1008 1009
    return 1; // ok to replicate if the user puts no constraints

unknown's avatar
unknown committed
1010 1011 1012 1013 1014
  /*
    If the user has specified restrictions on which databases to replicate
    and db was not selected, do not replicate.
  */
  if (!db)
unknown's avatar
unknown committed
1015
    return 0;
unknown's avatar
unknown committed
1016

unknown's avatar
unknown committed
1017 1018 1019 1020
  if (!do_list.is_empty()) // if the do's are not empty
  {
    I_List_iterator<i_string> it(do_list);
    i_string* tmp;
unknown's avatar
unknown committed
1021

unknown's avatar
unknown committed
1022 1023 1024 1025
    while ((tmp=it++))
    {
      if (!strcmp(tmp->ptr, db))
	return 1; // match
unknown's avatar
unknown committed
1026
    }
unknown's avatar
unknown committed
1027 1028
    return 0;
  }
unknown's avatar
unknown committed
1029
  else // there are some elements in the don't, otherwise we cannot get here
unknown's avatar
unknown committed
1030 1031 1032
  {
    I_List_iterator<i_string> it(ignore_list);
    i_string* tmp;
unknown's avatar
unknown committed
1033

unknown's avatar
unknown committed
1034 1035 1036 1037
    while ((tmp=it++))
    {
      if (!strcmp(tmp->ptr, db))
	return 0; // match
unknown's avatar
unknown committed
1038
    }
unknown's avatar
unknown committed
1039 1040
    return 1;
  }
unknown's avatar
unknown committed
1041 1042
}

1043

unknown's avatar
unknown committed
1044 1045
static int init_strvar_from_file(char *var, int max_size, IO_CACHE *f,
				 const char *default_val)
unknown's avatar
unknown committed
1046
{
unknown's avatar
unknown committed
1047 1048 1049 1050 1051 1052 1053
  uint length;
  if ((length=my_b_gets(f,var, max_size)))
  {
    char* last_p = var + length -1;
    if (*last_p == '\n')
      *last_p = 0; // if we stopped on newline, kill it
    else
unknown's avatar
unknown committed
1054
    {
unknown's avatar
unknown committed
1055 1056 1057 1058
      /*
	If we truncated a line or stopped on last char, remove all chars
	up to and including newline.
      */
unknown's avatar
unknown committed
1059
      int c;
unknown's avatar
unknown committed
1060
      while (((c=my_b_get(f)) != '\n' && c != my_b_EOF));
unknown's avatar
unknown committed
1061
    }
unknown's avatar
unknown committed
1062 1063 1064 1065
    return 0;
  }
  else if (default_val)
  {
unknown's avatar
unknown committed
1066
    strmake(var,  default_val, max_size-1);
unknown's avatar
unknown committed
1067 1068
    return 0;
  }
unknown's avatar
unknown committed
1069
  return 1;
unknown's avatar
unknown committed
1070 1071
}

1072

unknown's avatar
unknown committed
1073
static int init_intvar_from_file(int* var, IO_CACHE* f, int default_val)
unknown's avatar
unknown committed
1074 1075 1076
{
  char buf[32];
  
unknown's avatar
unknown committed
1077 1078 1079 1080 1081
  if (my_b_gets(f, buf, sizeof(buf))) 
  {
    *var = atoi(buf);
    return 0;
  }
unknown's avatar
unknown committed
1082
  else if (default_val)
unknown's avatar
unknown committed
1083 1084 1085 1086
  {
    *var = default_val;
    return 0;
  }
unknown's avatar
unknown committed
1087
  return 1;
unknown's avatar
unknown committed
1088 1089
}

1090

unknown's avatar
unknown committed
1091
static int get_master_version_and_clock(MYSQL* mysql, MASTER_INFO* mi)
1092
{
1093
  const char* errmsg= 0;
1094
  
unknown's avatar
unknown committed
1095 1096 1097
  /*
    Note the following switch will bug when we have MySQL branch 30 ;)
  */
1098
  switch (*mysql->server_version) {
1099
  case '3':
unknown's avatar
unknown committed
1100 1101 1102 1103
    mi->old_format = 
      (strncmp(mysql->server_version, "3.23.57", 7) < 0) /* < .57 */ ?
      BINLOG_FORMAT_323_LESS_57 : 
      BINLOG_FORMAT_323_GEQ_57 ;
1104 1105
    break;
  case '4':
unknown's avatar
unknown committed
1106
    mi->old_format = BINLOG_FORMAT_CURRENT;
1107 1108
    break;
  default:
1109
    /* 5.0 is not supported */
unknown's avatar
unknown committed
1110
    errmsg = "Master reported an unrecognized MySQL version. Note that 4.1 \
1111
slaves can't replicate a 5.0 or newer master.";
1112
    break;
1113
  }
1114

unknown's avatar
unknown committed
1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
  MYSQL_RES *master_clock_res;
  MYSQL_ROW master_clock_row;
  time_t slave_clock;

  if (mysql_real_query(mysql, "SELECT UNIX_TIMESTAMP()", 23))
    errmsg= "\"SELECT UNIX_TIMESTAMP()\" failed on master"; 
  else if (!(master_clock_res= mysql_store_result(mysql)))
  {
    errmsg= "Could not read the result of \"SELECT UNIX_TIMESTAMP()\" on \
master"; 
  }
  else 
  {
    if (!(master_clock_row= mysql_fetch_row(master_clock_res)))
      errmsg= "Could not read a row from the result of \"SELECT \
UNIX_TIMESTAMP()\" on master"; 
    else
    {
      slave_clock= time((time_t*) 0);
      mi->clock_diff_with_master= (long) (slave_clock -
                                          strtoul(master_clock_row[0], 0, 10));
      DBUG_PRINT("info",("slave_clock=%lu, master_clock=%s",
                         slave_clock, master_clock_row[0]));
    }
  mysql_free_result(master_clock_res);
  }

1142 1143 1144 1145 1146 1147 1148 1149
  if (errmsg)
  {
    sql_print_error(errmsg);
    return 1;
  }
  return 0;
}

1150 1151 1152 1153 1154 1155 1156 1157 1158
/*
  Used by fetch_master_table (used by LOAD TABLE tblname FROM MASTER and LOAD
  DATA FROM MASTER). Drops the table (if 'overwrite' is true) and recreates it
  from the dump. Honours replication inclusion/exclusion rules.

  RETURN VALUES
    0           success
    1           error
*/
1159

1160
static int create_table_from_dump(THD* thd, MYSQL *mysql, const char* db,
1161
				  const char* table_name, bool overwrite)
unknown's avatar
unknown committed
1162
{
1163
  ulong packet_len;
1164
  char *query;
1165
  char* save_db;
1166 1167
  Vio* save_vio;
  HA_CHECK_OPT check_opt;
unknown's avatar
unknown committed
1168
  TABLE_LIST tables;
1169 1170
  int error= 1;
  handler *file;
1171
  ulong save_options;
1172
  NET *net= &mysql->net;
unknown's avatar
unknown committed
1173 1174
  DBUG_ENTER("create_table_from_dump");  

1175
  packet_len= my_net_read(net); // read create table statement
1176 1177
  if (packet_len == packet_error)
  {
1178
    send_error(thd, ER_MASTER_NET_READ);
unknown's avatar
unknown committed
1179
    DBUG_RETURN(1);
1180 1181 1182
  }
  if (net->read_pos[0] == 255) // error from master
  {
1183 1184 1185 1186 1187
    char *err_msg; 
    err_msg= (char*) net->read_pos + ((mysql->server_capabilities &
				       CLIENT_PROTOCOL_41) ?
				      3+SQLSTATE_LENGTH+1 : 3);
    net_printf(thd, ER_MASTER, err_msg);
unknown's avatar
unknown committed
1188
    DBUG_RETURN(1);
1189
  }
unknown's avatar
unknown committed
1190
  thd->command = COM_TABLE_DUMP;
1191
  thd->query_length= packet_len;
1192
  /* Note that we should not set thd->query until the area is initalized */
1193
  if (!(query = thd->strmake((char*) net->read_pos, packet_len)))
1194 1195
  {
    sql_print_error("create_table_from_dump: out of memory");
1196
    net_printf(thd, ER_GET_ERRNO, "Out of memory");
unknown's avatar
unknown committed
1197
    DBUG_RETURN(1);
1198
  }
1199
  thd->query= query;
unknown's avatar
unknown committed
1200 1201
  thd->query_error = 0;
  thd->net.no_send_ok = 1;
1202

unknown's avatar
unknown committed
1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213
  bzero((char*) &tables,sizeof(tables));
  tables.db = (char*)db;
  tables.alias= tables.real_name= (char*)table_name;
  /* Drop the table if 'overwrite' is true */
  if (overwrite && mysql_rm_table(thd,&tables,1,0)) /* drop if exists */
  {
    send_error(thd);
    sql_print_error("create_table_from_dump: failed to drop the table");
    goto err;
  }

1214
  /* Create the table. We do not want to log the "create table" statement */
1215
  save_options = thd->options;
1216
  thd->options &= ~(ulong) (OPTION_BIN_LOG);
unknown's avatar
unknown committed
1217
  thd->proc_info = "Creating table from master dump";
unknown's avatar
unknown committed
1218
  // save old db in case we are creating in a different database
1219
  save_db = thd->db;
1220
  thd->db = (char*)db;
unknown's avatar
unknown committed
1221
  mysql_parse(thd, thd->query, packet_len); // run create table
1222
  thd->db = save_db;		// leave things the way the were before
1223
  thd->options = save_options;
unknown's avatar
unknown committed
1224
  
1225 1226
  if (thd->query_error)
    goto err;			// mysql_parse took care of the error send
unknown's avatar
unknown committed
1227 1228

  thd->proc_info = "Opening master dump table";
1229
  tables.lock_type = TL_WRITE;
unknown's avatar
unknown committed
1230 1231
  if (!open_ltable(thd, &tables, TL_WRITE))
  {
1232
    send_error(thd,0,0);			// Send error from open_ltable
unknown's avatar
unknown committed
1233
    sql_print_error("create_table_from_dump: could not open created table");
1234
    goto err;
unknown's avatar
unknown committed
1235
  }
unknown's avatar
unknown committed
1236
  
1237
  file = tables.table->file;
unknown's avatar
unknown committed
1238
  thd->proc_info = "Reading master dump table data";
1239
  /* Copy the data file */
unknown's avatar
unknown committed
1240 1241
  if (file->net_read_dump(net))
  {
1242
    net_printf(thd, ER_MASTER_NET_READ);
1243
    sql_print_error("create_table_from_dump: failed in\
unknown's avatar
unknown committed
1244
 handler::net_read_dump()");
1245
    goto err;
unknown's avatar
unknown committed
1246
  }
unknown's avatar
unknown committed
1247 1248

  check_opt.init();
unknown's avatar
unknown committed
1249
  check_opt.flags|= T_VERY_SILENT | T_CALC_CHECKSUM | T_QUICK;
unknown's avatar
unknown committed
1250
  thd->proc_info = "Rebuilding the index on master dump table";
unknown's avatar
unknown committed
1251 1252 1253 1254 1255
  /*
    We do not want repair() to spam us with messages
    just send them to the error log, and report the failure in case of
    problems.
  */
1256
  save_vio = thd->net.vio;
unknown's avatar
unknown committed
1257
  thd->net.vio = 0;
1258
  /* Rebuild the index file from the copied data file (with REPAIR) */
1259
  error=file->repair(thd,&check_opt) != 0;
unknown's avatar
unknown committed
1260
  thd->net.vio = save_vio;
1261
  if (error)
1262
    net_printf(thd, ER_INDEX_REBUILD,tables.table->real_name);
1263 1264

err:
unknown's avatar
unknown committed
1265 1266
  close_thread_tables(thd);
  thd->net.no_send_ok = 0;
unknown's avatar
unknown committed
1267
  DBUG_RETURN(error); 
unknown's avatar
unknown committed
1268 1269
}

1270

1271
int fetch_master_table(THD *thd, const char *db_name, const char *table_name,
1272
		       MASTER_INFO *mi, MYSQL *mysql, bool overwrite)
unknown's avatar
unknown committed
1273
{
1274 1275 1276 1277 1278 1279
  int error= 1;
  const char *errmsg=0;
  bool called_connected= (mysql != NULL);
  DBUG_ENTER("fetch_master_table");
  DBUG_PRINT("enter", ("db_name: '%s'  table_name: '%s'",
		       db_name,table_name));
unknown's avatar
unknown committed
1280

unknown's avatar
merge  
unknown committed
1281
  if (!called_connected)
1282
  { 
unknown's avatar
SCRUM  
unknown committed
1283
    if (!(mysql = mysql_init(NULL)))
1284
    {
1285
      send_error(thd);			// EOM
1286 1287
      DBUG_RETURN(1);
    }
unknown's avatar
merge  
unknown committed
1288
    if (connect_to_master(thd, mysql, mi))
1289
    {
unknown's avatar
SCRUM  
unknown committed
1290 1291
      net_printf(thd, ER_CONNECT_TO_MASTER, mysql_error(mysql));
      mysql_close(mysql);
1292
      DBUG_RETURN(1);
1293
    }
1294 1295
    if (thd->killed)
      goto err;
1296
  }
unknown's avatar
unknown committed
1297

unknown's avatar
unknown committed
1298
  if (request_table_dump(mysql, db_name, table_name))
1299
  {
1300 1301
    error= ER_UNKNOWN_ERROR;
    errmsg= "Failed on table dump request";
1302 1303
    goto err;
  }
unknown's avatar
unknown committed
1304 1305 1306
  if (create_table_from_dump(thd, mysql, db_name,
			     table_name, overwrite))
    goto err;    // create_table_from_dump have sent the error already
unknown's avatar
unknown committed
1307
  error = 0;
1308

unknown's avatar
unknown committed
1309
 err:
1310
  thd->net.no_send_ok = 0; // Clear up garbage after create_table_from_dump
1311
  if (!called_connected)
unknown's avatar
SCRUM  
unknown committed
1312
    mysql_close(mysql);
1313
  if (errmsg && thd->net.vio)
1314
    send_error(thd, error, errmsg);
1315
  DBUG_RETURN(test(error));			// Return 1 on error
unknown's avatar
unknown committed
1316 1317
}

1318

1319 1320
void end_master_info(MASTER_INFO* mi)
{
1321 1322
  DBUG_ENTER("end_master_info");

1323
  if (!mi->inited)
1324
    DBUG_VOID_RETURN;
1325 1326
  end_relay_log_info(&mi->rli);
  if (mi->fd >= 0)
1327 1328 1329 1330 1331
  {
    end_io_cache(&mi->file);
    (void)my_close(mi->fd, MYF(MY_WME));
    mi->fd = -1;
  }
1332
  mi->inited = 0;
1333 1334

  DBUG_VOID_RETURN;
1335 1336
}

1337

1338 1339 1340 1341 1342 1343
int init_relay_log_info(RELAY_LOG_INFO* rli, const char* info_fname)
{
  char fname[FN_REFLEN+128];
  int info_fd;
  const char* msg = 0;
  int error = 0;
1344
  DBUG_ENTER("init_relay_log_info");
unknown's avatar
unknown committed
1345

1346
  if (rli->inited)				// Set if this function called
unknown's avatar
unknown committed
1347 1348
    DBUG_RETURN(0);
  fn_format(fname, info_fname, mysql_data_home, "", 4+32);
1349 1350 1351 1352
  pthread_mutex_lock(&rli->data_lock);
  info_fd = rli->info_fd;
  rli->cur_log_fd = -1;
  rli->slave_skip_counter=0;
1353
  rli->abort_pos_wait=0;
1354 1355
  rli->log_space_limit= relay_log_space_limit;
  rli->log_space_total= 0;
1356

1357 1358 1359 1360
  // TODO: make this work with multi-master
  if (!opt_relay_logname)
  {
    char tmp[FN_REFLEN];
unknown's avatar
unknown committed
1361 1362 1363
    /*
      TODO: The following should be using fn_format();  We just need to
      first change fn_format() to cut the file name if it's too long.
1364 1365 1366 1367 1368
    */
    strmake(tmp,glob_hostname,FN_REFLEN-5);
    strmov(strcend(tmp,'.'),"-relay-bin");
    opt_relay_logname=my_strdup(tmp,MYF(MY_WME));
  }
1369 1370

  /*
unknown's avatar
unknown committed
1371 1372 1373
    The relay log will now be opened, as a SEQ_READ_APPEND IO_CACHE.
    Note that the I/O thread flushes it to disk after writing every event, in
    flush_master_info(mi, 1).
1374 1375
  */

unknown's avatar
unknown committed
1376 1377 1378 1379 1380 1381 1382 1383 1384 1385
  /*
    For the maximum log size, we choose max_relay_log_size if it is
    non-zero, max_binlog_size otherwise. If later the user does SET
    GLOBAL on one of these variables, fix_max_binlog_size and
    fix_max_relay_log_size will reconsider the choice (for example
    if the user changes max_relay_log_size to zero, we have to
    switch to using max_binlog_size for the relay log) and update
    rli->relay_log.max_size (and mysql_bin_log.max_size).
  */

1386 1387 1388
  if (open_log(&rli->relay_log, glob_hostname, opt_relay_logname,
	       "-relay-bin", opt_relaylog_index_name,
	       LOG_BIN, 1 /* read_append cache */,
1389 1390
	       1 /* no auto events */,
               max_relay_log_size ? max_relay_log_size : max_binlog_size))
1391 1392
  {
    sql_print_error("Failed in open_log() called from init_relay_log_info()");
1393
    DBUG_RETURN(1);
1394
  }
1395

1396
  /* if file does not exist */
unknown's avatar
unknown committed
1397
  if (access(fname,F_OK))
1398
  {
unknown's avatar
unknown committed
1399 1400 1401 1402
    /*
      If someone removed the file from underneath our feet, just close
      the old descriptor and re-create the old file
    */
1403 1404
    if (info_fd >= 0)
      my_close(info_fd, MYF(MY_WME));
1405
    if ((info_fd = my_open(fname, O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0)
1406
    {
1407 1408 1409 1410 1411 1412 1413
      sql_print_error("Failed to create a new relay log info file (\
file '%s', errno %d)", fname, my_errno);
      msg= current_thd->net.last_error;
      goto err;
    }
    if (init_io_cache(&rli->info_file, info_fd, IO_SIZE*2, READ_CACHE, 0L,0,
		      MYF(MY_WME))) 
1414
    {
1415 1416
      sql_print_error("Failed to create a cache on relay log info file '%s'",
		      fname);
1417 1418
      msg= current_thd->net.last_error;
      goto err;
1419
    }
1420 1421 1422

    /* Init relay log with first entry in the relay index file */
    if (init_relay_log_pos(rli,NullS,BIN_LOG_HEADER_SIZE,0 /* no data lock */,
unknown's avatar
unknown committed
1423
			   &msg))
1424
    {
1425
      sql_print_error("Failed to open the relay log 'FIRST' (relay_log_pos 4)");
1426
      goto err;
1427
    }
1428 1429
    rli->group_master_log_name[0]= 0;
    rli->group_master_log_pos= 0;		
1430
    rli->info_fd= info_fd;
1431 1432 1433
  }
  else // file exists
  {
unknown's avatar
unknown committed
1434
    if (info_fd >= 0)
1435
      reinit_io_cache(&rli->info_file, READ_CACHE, 0L,0,0);
1436
    else 
1437
    {
1438 1439 1440
      int error=0;
      if ((info_fd = my_open(fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0)
      {
1441 1442 1443
        sql_print_error("\
Failed to open the existing relay log info file '%s' (errno %d)",
			fname, my_errno);
1444 1445 1446 1447 1448
        error= 1;
      }
      else if (init_io_cache(&rli->info_file, info_fd,
                             IO_SIZE*2, READ_CACHE, 0L, 0, MYF(MY_WME)))
      {
1449 1450
        sql_print_error("Failed to create a cache on relay log info file '%s'",
			fname);
1451 1452 1453 1454 1455 1456 1457
        error= 1;
      }
      if (error)
      {
        if (info_fd >= 0)
          my_close(info_fd, MYF(0));
        rli->info_fd= -1;
1458
        rli->relay_log.close(LOG_CLOSE_INDEX | LOG_CLOSE_STOP_EVENT);
1459 1460 1461
        pthread_mutex_unlock(&rli->data_lock);
        DBUG_RETURN(1);
      }
1462
    }
1463
         
1464
    rli->info_fd = info_fd;
1465
    int relay_log_pos, master_log_pos;
1466 1467
    if (init_strvar_from_file(rli->group_relay_log_name,
			      sizeof(rli->group_relay_log_name), &rli->info_file,
unknown's avatar
unknown committed
1468
			      "") ||
1469
       init_intvar_from_file(&relay_log_pos,
unknown's avatar
unknown committed
1470
			     &rli->info_file, BIN_LOG_HEADER_SIZE) ||
1471 1472
       init_strvar_from_file(rli->group_master_log_name,
			     sizeof(rli->group_master_log_name), &rli->info_file,
unknown's avatar
unknown committed
1473
			     "") ||
1474
       init_intvar_from_file(&master_log_pos, &rli->info_file, 0))
1475 1476 1477 1478
    {
      msg="Error reading slave log configuration";
      goto err;
    }
1479 1480 1481 1482
    strmake(rli->event_relay_log_name,rli->group_relay_log_name,
            sizeof(rli->event_relay_log_name)-1);
    rli->group_relay_log_pos= rli->event_relay_log_pos= relay_log_pos;
    rli->group_master_log_pos= master_log_pos;
1483

1484
    if (init_relay_log_pos(rli,
1485 1486
			   rli->group_relay_log_name,
			   rli->group_relay_log_pos,
1487 1488
			   0 /* no data lock*/,
			   &msg))
1489 1490
    {
      char llbuf[22];
1491
      sql_print_error("Failed to open the relay log '%s' (relay_log_pos %s)",
unknown's avatar
unknown committed
1492 1493
		      rli->group_relay_log_name,
		      llstr(rli->group_relay_log_pos, llbuf));
1494
      goto err;
1495
    }
1496
  }
1497 1498
  DBUG_ASSERT(rli->event_relay_log_pos >= BIN_LOG_HEADER_SIZE);
  DBUG_ASSERT(my_b_tell(rli->cur_log) == rli->event_relay_log_pos);
unknown's avatar
unknown committed
1499 1500 1501 1502
  /*
    Now change the cache from READ to WRITE - must do this
    before flush_relay_log_info
  */
1503
  reinit_io_cache(&rli->info_file, WRITE_CACHE,0L,0,1);
1504 1505
  if ((error= flush_relay_log_info(rli)))
    sql_print_error("Failed to flush relay log info file");
unknown's avatar
unknown committed
1506 1507 1508 1509 1510
  if (count_relay_log_space(rli))
  {
    msg="Error counting relay log space";
    goto err;
  }
1511
  rli->inited= 1;
1512
  pthread_mutex_unlock(&rli->data_lock);
unknown's avatar
unknown committed
1513
  DBUG_RETURN(error);
1514 1515 1516 1517

err:
  sql_print_error(msg);
  end_io_cache(&rli->info_file);
1518 1519
  if (info_fd >= 0)
    my_close(info_fd, MYF(0));
unknown's avatar
unknown committed
1520
  rli->info_fd= -1;
1521
  rli->relay_log.close(LOG_CLOSE_INDEX | LOG_CLOSE_STOP_EVENT);
1522
  pthread_mutex_unlock(&rli->data_lock);
unknown's avatar
unknown committed
1523
  DBUG_RETURN(1);
1524 1525
}

1526

unknown's avatar
unknown committed
1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540
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)))
  {
    sql_print_error("log %s listed in the index, but failed to stat",
		    linfo->log_file_name);
    DBUG_RETURN(1);
  }
  rli->log_space_total += s.st_size;
#ifndef DBUG_OFF
  char buf[22];
  DBUG_PRINT("info",("log_space_total: %s", llstr(rli->log_space_total,buf)));
1541
#endif  
unknown's avatar
unknown committed
1542 1543 1544
  DBUG_RETURN(0);
}

1545

unknown's avatar
unknown committed
1546 1547
static bool wait_for_relay_log_space(RELAY_LOG_INFO* rli)
{
1548
  bool slave_killed=0;
unknown's avatar
unknown committed
1549
  MASTER_INFO* mi = rli->mi;
unknown's avatar
unknown committed
1550
  const char *save_proc_info;
unknown's avatar
unknown committed
1551
  THD* thd = mi->io_thd;
1552

unknown's avatar
unknown committed
1553
  DBUG_ENTER("wait_for_relay_log_space");
1554

unknown's avatar
unknown committed
1555
  pthread_mutex_lock(&rli->log_space_lock);
unknown's avatar
unknown committed
1556 1557
  save_proc_info= thd->enter_cond(&rli->log_space_cond,
				  &rli->log_space_lock, 
unknown's avatar
unknown committed
1558
				  "\
1559
Waiting for the slave SQL thread to free enough relay log space");
unknown's avatar
unknown committed
1560
  while (rli->log_space_limit < rli->log_space_total &&
1561 1562
	 !(slave_killed=io_slave_killed(thd,mi)) &&
         !rli->ignore_log_space_limit)
unknown's avatar
unknown committed
1563
    pthread_cond_wait(&rli->log_space_cond, &rli->log_space_lock);
unknown's avatar
unknown committed
1564
  thd->exit_cond(save_proc_info);
unknown's avatar
unknown committed
1565 1566 1567 1568
  pthread_mutex_unlock(&rli->log_space_lock);
  DBUG_RETURN(slave_killed);
}

unknown's avatar
unknown committed
1569

unknown's avatar
unknown committed
1570 1571 1572 1573
static int count_relay_log_space(RELAY_LOG_INFO* rli)
{
  LOG_INFO linfo;
  DBUG_ENTER("count_relay_log_space");
1574
  rli->log_space_total= 0;
1575
  if (rli->relay_log.find_log_pos(&linfo, NullS, 1))
unknown's avatar
unknown committed
1576 1577 1578 1579
  {
    sql_print_error("Could not find first log while counting relay log space");
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
1580
  do
unknown's avatar
unknown committed
1581 1582 1583
  {
    if (add_relay_log(rli,&linfo))
      DBUG_RETURN(1);
1584
  } while (!rli->relay_log.find_next_log(&linfo, 1));
1585 1586 1587 1588 1589 1590
  /* 
     As we have counted everything, including what may have written in a
     preceding write, we must reset bytes_written, or we may count some space 
     twice.
  */
  rli->relay_log.reset_bytes_written();
unknown's avatar
unknown committed
1591 1592
  DBUG_RETURN(0);
}
unknown's avatar
unknown committed
1593

1594

unknown's avatar
unknown committed
1595 1596 1597 1598 1599 1600 1601 1602 1603 1604
void init_master_info_with_options(MASTER_INFO* mi)
{
  mi->master_log_name[0] = 0;
  mi->master_log_pos = BIN_LOG_HEADER_SIZE;		// skip magic number
  
  if (master_host)
    strmake(mi->host, master_host, sizeof(mi->host) - 1);
  if (master_user)
    strmake(mi->user, master_user, sizeof(mi->user) - 1);
  if (master_password)
unknown's avatar
unknown committed
1605
    strmake(mi->password, master_password, MAX_PASSWORD_LENGTH);
unknown's avatar
unknown committed
1606 1607
  mi->port = master_port;
  mi->connect_retry = master_connect_retry;
unknown's avatar
unknown committed
1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619
  
  mi->ssl= master_ssl;
  if (master_ssl_ca)
    strmake(mi->ssl_ca, master_ssl_ca, sizeof(mi->ssl_ca)-1);
  if (master_ssl_capath)
    strmake(mi->ssl_capath, master_ssl_capath, sizeof(mi->ssl_capath)-1);
  if (master_ssl_cert)
    strmake(mi->ssl_cert, master_ssl_cert, sizeof(mi->ssl_cert)-1);
  if (master_ssl_cipher)
    strmake(mi->ssl_cipher, master_ssl_cipher, sizeof(mi->ssl_cipher)-1);
  if (master_ssl_key)
    strmake(mi->ssl_key, master_ssl_key, sizeof(mi->ssl_key)-1);
unknown's avatar
unknown committed
1620 1621
}

unknown's avatar
unknown committed
1622
static void clear_slave_error(RELAY_LOG_INFO* rli)
unknown's avatar
unknown committed
1623
{
unknown's avatar
unknown committed
1624 1625 1626
  /* Clear the errors displayed by SHOW SLAVE STATUS */
  rli->last_slave_error[0]= 0;
  rli->last_slave_errno= 0;
unknown's avatar
unknown committed
1627
}
1628

unknown's avatar
unknown committed
1629 1630 1631 1632 1633
void clear_slave_error_timestamp(RELAY_LOG_INFO* rli)
{
  rli->last_master_timestamp= 0;
  clear_slave_error(rli);
}
unknown's avatar
unknown committed
1634

1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648
/*
    Reset UNTIL condition for RELAY_LOG_INFO
   SYNOPSYS
    clear_until_condition()
      rli - RELAY_LOG_INFO structure where UNTIL condition should be reset
 */
void clear_until_condition(RELAY_LOG_INFO* rli)
{
  rli->until_condition= RELAY_LOG_INFO::UNTIL_NONE;
  rli->until_log_name[0]= 0;
  rli->until_log_pos= 0;
}


unknown's avatar
unknown committed
1649
#define LINES_IN_MASTER_INFO_WITH_SSL 14
1650

unknown's avatar
unknown committed
1651

1652
int init_master_info(MASTER_INFO* mi, const char* master_info_fname,
1653 1654
		     const char* slave_info_fname,
		     bool abort_if_no_master_info_file)
unknown's avatar
unknown committed
1655
{
unknown's avatar
unknown committed
1656 1657 1658 1659
  int fd,error;
  char fname[FN_REFLEN+128];
  DBUG_ENTER("init_master_info");

unknown's avatar
unknown committed
1660
  if (mi->inited)
unknown's avatar
unknown committed
1661
    DBUG_RETURN(0);
unknown's avatar
unknown committed
1662 1663
  mi->mysql=0;
  mi->file_id=1;
1664
  fn_format(fname, master_info_fname, mysql_data_home, "", 4+32);
unknown's avatar
unknown committed
1665

unknown's avatar
unknown committed
1666 1667 1668 1669
  /*
    We need a mutex while we are changing master info parameters to
    keep other threads from reading bogus info
  */
unknown's avatar
unknown committed
1670

1671
  pthread_mutex_lock(&mi->data_lock);
unknown's avatar
unknown committed
1672
  fd = mi->fd;
1673 1674

  /* does master.info exist ? */
unknown's avatar
unknown committed
1675
  
1676
  if (access(fname,F_OK))
unknown's avatar
unknown committed
1677
  {
1678 1679 1680 1681 1682
    if (abort_if_no_master_info_file)
    {
      pthread_mutex_unlock(&mi->data_lock);
      DBUG_RETURN(0);
    }
unknown's avatar
unknown committed
1683 1684 1685 1686
    /*
      if someone removed the file from underneath our feet, just close
      the old descriptor and re-create the old file
    */
unknown's avatar
unknown committed
1687 1688
    if (fd >= 0)
      my_close(fd, MYF(MY_WME));
1689 1690 1691 1692 1693 1694 1695
    if ((fd = my_open(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);
      goto err;
    }
    if (init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L,0,
unknown's avatar
unknown committed
1696
		      MYF(MY_WME)))
1697 1698 1699
    {
      sql_print_error("Failed to create a cache on master info file (\
file '%s')", fname);
unknown's avatar
unknown committed
1700
      goto err;
1701
    }
unknown's avatar
unknown committed
1702

unknown's avatar
unknown committed
1703
    mi->fd = fd;
unknown's avatar
unknown committed
1704 1705
    init_master_info_with_options(mi);

unknown's avatar
unknown committed
1706
  }
1707
  else // file exists
unknown's avatar
unknown committed
1708
  {
unknown's avatar
unknown committed
1709
    if (fd >= 0)
unknown's avatar
unknown committed
1710
      reinit_io_cache(&mi->file, READ_CACHE, 0L,0,0);
1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726
    else 
    {
      if ((fd = my_open(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);
        goto err;
      }
      if (init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L,
                        0, MYF(MY_WME)))
      {
        sql_print_error("Failed to create a cache on master info file (\
file '%s')", fname);
        goto err;
      }
    }
unknown's avatar
unknown committed
1727

unknown's avatar
unknown committed
1728
    mi->fd = fd;
unknown's avatar
unknown committed
1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754
    int port, connect_retry, master_log_pos, ssl= 0, lines;
    char *first_non_digit;
    
    /*
       Starting from 4.1.x master.info has new format. Now its
       first line contains number of lines in file. By reading this 
       number we will be always distinguish to which version our 
       master.info corresponds to. We can't simply count lines in 
       file since versions before 4.1.x could generate files with more
       lines than needed.
       If first line doesn't contain a number or contain number less than 
       14 then such file is treated like file from pre 4.1.1 version.
       There is no ambiguity when reading an old master.info, as before 
       4.1.1, the first line contained the binlog's name, which is either
       empty or has an extension (contains a '.'), so can't be confused 
       with an integer.

       So we're just reading first line and trying to figure which version 
       is this.
    */
    
    /* 
       The first row is temporarily stored in mi->master_log_name, 
       if it is line count and not binlog name (new format) it will be 
       overwritten by the second row later.
    */
1755
    if (init_strvar_from_file(mi->master_log_name,
unknown's avatar
unknown committed
1756
			      sizeof(mi->master_log_name), &mi->file,
unknown's avatar
unknown committed
1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772
			      ""))
      goto errwithmsg;
    
    lines= strtoul(mi->master_log_name, &first_non_digit, 10);

    if (mi->master_log_name[0]!='\0' && 
        *first_non_digit=='\0' && lines >= LINES_IN_MASTER_INFO_WITH_SSL)
    {                                          // Seems to be new format
      if (init_strvar_from_file(mi->master_log_name,     
            sizeof(mi->master_log_name), &mi->file, ""))
        goto errwithmsg;
    }
    else
      lines= 7;
    
    if (init_intvar_from_file(&master_log_pos, &mi->file, 4) ||
unknown's avatar
unknown committed
1773 1774 1775 1776
	init_strvar_from_file(mi->host, sizeof(mi->host), &mi->file,
			      master_host) ||
	init_strvar_from_file(mi->user, sizeof(mi->user), &mi->file,
			      master_user) || 
1777 1778
        init_strvar_from_file(mi->password, SCRAMBLED_PASSWORD_CHAR_LENGTH+1,
                              &mi->file, master_password) ||
1779 1780
	init_intvar_from_file(&port, &mi->file, master_port) ||
	init_intvar_from_file(&connect_retry, &mi->file,
unknown's avatar
unknown committed
1781
			      master_connect_retry))
unknown's avatar
unknown committed
1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809
      goto errwithmsg;

    /* 
       If file has ssl part use it even if we have server without 
       SSL support. But these option will be ignored later when 
       slave will try connect to master, so in this case warning 
       is printed.
     */
    if (lines >= LINES_IN_MASTER_INFO_WITH_SSL && 
        (init_intvar_from_file(&ssl, &mi->file, master_ssl) ||
         init_strvar_from_file(mi->ssl_ca, sizeof(mi->ssl_ca), 
                               &mi->file, master_ssl_ca) ||
         init_strvar_from_file(mi->ssl_capath, sizeof(mi->ssl_capath), 
                               &mi->file, master_ssl_capath) ||
         init_strvar_from_file(mi->ssl_cert, sizeof(mi->ssl_cert),
                               &mi->file, master_ssl_cert) ||
         init_strvar_from_file(mi->ssl_cipher, sizeof(mi->ssl_cipher),
                               &mi->file, master_ssl_cipher) ||
         init_strvar_from_file(mi->ssl_key, sizeof(mi->ssl_key),
                              &mi->file, master_ssl_key)))
      goto errwithmsg;
#ifndef HAVE_OPENSSL
    if (ssl)
      sql_print_error("SSL information in the master info file "
                      "('%s') are ignored because this MySQL slave was compiled "
                      "without SSL support.", fname);
#endif /* HAVE_OPENSSL */
    
1810 1811 1812 1813 1814 1815 1816
    /*
      This has to be handled here as init_intvar_from_file can't handle
      my_off_t types
    */
    mi->master_log_pos= (my_off_t) master_log_pos;
    mi->port= (uint) port;
    mi->connect_retry= (uint) connect_retry;
unknown's avatar
unknown committed
1817
    mi->ssl= (my_bool) ssl;
unknown's avatar
unknown committed
1818
  }
1819 1820 1821
  DBUG_PRINT("master_info",("log_file_name: %s  position: %ld",
			    mi->master_log_name,
			    (ulong) mi->master_log_pos));
1822 1823 1824 1825 1826

  if (init_relay_log_info(&mi->rli, slave_info_fname))
    goto err;
  mi->rli.mi = mi;

unknown's avatar
unknown committed
1827
  mi->inited = 1;
unknown's avatar
unknown committed
1828
  // now change cache READ -> WRITE - must do this before flush_master_info
1829
  reinit_io_cache(&mi->file, WRITE_CACHE,0L,0,1);
unknown's avatar
unknown committed
1830
  if ((error=test(flush_master_info(mi, 1))))
1831
    sql_print_error("Failed to flush master info file");
1832
  pthread_mutex_unlock(&mi->data_lock);
unknown's avatar
unknown committed
1833
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1834 1835 1836 1837
  
errwithmsg:
  sql_print_error("Error reading master configuration");
  
1838
err:
unknown's avatar
unknown committed
1839 1840 1841 1842 1843 1844
  if (fd >= 0)
  {
    my_close(fd, MYF(0));
    end_io_cache(&mi->file);
  }
  mi->fd= -1;
1845
  pthread_mutex_unlock(&mi->data_lock);
unknown's avatar
unknown committed
1846
  DBUG_RETURN(1);
unknown's avatar
unknown committed
1847 1848
}

1849

1850 1851
int register_slave_on_master(MYSQL* mysql)
{
1852 1853
  char buf[1024], *pos= buf;
  uint report_host_len, report_user_len=0, report_password_len=0;
1854

1855
  if (!report_host)
1856
    return 0;
1857
  report_host_len= strlen(report_host);
1858
  if (report_user)
1859
    report_user_len= strlen(report_user);
unknown's avatar
unknown committed
1860
  if (report_password)
1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875
    report_password_len= strlen(report_password);
  /* 30 is a good safety margin */
  if (report_host_len + report_user_len + report_password_len + 30 >
      sizeof(buf))
    return 0;					// safety

  int4store(pos, server_id); pos+= 4;
  pos= net_store_data(pos, report_host, report_host_len); 
  pos= net_store_data(pos, report_user, report_user_len);
  pos= net_store_data(pos, report_password, report_password_len);
  int2store(pos, (uint16) report_port); pos+= 2;
  int4store(pos, rpl_recovery_rank);	pos+= 4;
  /* The master will fill in master_id */
  int4store(pos, 0);			pos+= 4;

unknown's avatar
SCRUM  
unknown committed
1876
  if (simple_command(mysql, COM_REGISTER_SLAVE, (char*) buf,
1877
			(uint) (pos- buf), 0))
1878
  {
1879
    sql_print_error("Error on COM_REGISTER_SLAVE: %d '%s'",
unknown's avatar
SCRUM  
unknown committed
1880 1881
		    mysql_errno(mysql),
		    mysql_error(mysql));
1882 1883 1884 1885 1886
    return 1;
  }
  return 0;
}

1887

1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929
/*
  Builds a String from a HASH of TABLE_RULE_ENT. Cannot be used for any other 
  hash, as it assumes that the hash entries are TABLE_RULE_ENT.

  SYNOPSIS
    table_rule_ent_hash_to_str()
    s               pointer to the String to fill
    h               pointer to the HASH to read

  RETURN VALUES
    none
*/

void table_rule_ent_hash_to_str(String* s, HASH* h)
{
  s->length(0);
  for (uint i=0 ; i < h->records ; i++)
  {
    TABLE_RULE_ENT* e= (TABLE_RULE_ENT*) hash_element(h, i);
    if (s->length())
      s->append(',');
    s->append(e->db,e->key_len);
  }
}

/*
  Mostly the same thing as above
*/

void table_rule_ent_dynamic_array_to_str(String* s, DYNAMIC_ARRAY* a)
{
  s->length(0);
  for (uint i=0 ; i < a->elements ; i++)
  {
    TABLE_RULE_ENT* e;
    get_dynamic(a, (gptr)&e, i);
    if (s->length())
      s->append(',');
    s->append(e->db,e->key_len);
  }
}

1930
int show_master_info(THD* thd, MASTER_INFO* mi)
unknown's avatar
unknown committed
1931
{
1932
  // TODO: fix this for multi-master
unknown's avatar
unknown committed
1933
  List<Item> field_list;
1934 1935 1936
  Protocol *protocol= thd->protocol;
  DBUG_ENTER("show_master_info");

unknown's avatar
unknown committed
1937 1938
  field_list.push_back(new Item_empty_string("Slave_IO_State",
						     14));
unknown's avatar
unknown committed
1939
  field_list.push_back(new Item_empty_string("Master_Host",
1940
						     sizeof(mi->host)));
unknown's avatar
unknown committed
1941
  field_list.push_back(new Item_empty_string("Master_User",
1942
						     sizeof(mi->user)));
1943 1944
  field_list.push_back(new Item_return_int("Master_Port", 7,
					   MYSQL_TYPE_LONG));
1945
  field_list.push_back(new Item_return_int("Connect_Retry", 10,
1946
					   MYSQL_TYPE_LONG));
1947
  field_list.push_back(new Item_empty_string("Master_Log_File",
1948 1949 1950
					     FN_REFLEN));
  field_list.push_back(new Item_return_int("Read_Master_Log_Pos", 10,
					   MYSQL_TYPE_LONGLONG));
1951
  field_list.push_back(new Item_empty_string("Relay_Log_File",
1952 1953 1954
					     FN_REFLEN));
  field_list.push_back(new Item_return_int("Relay_Log_Pos", 10,
					   MYSQL_TYPE_LONGLONG));
1955
  field_list.push_back(new Item_empty_string("Relay_Master_Log_File",
1956
					     FN_REFLEN));
1957 1958
  field_list.push_back(new Item_empty_string("Slave_IO_Running", 3));
  field_list.push_back(new Item_empty_string("Slave_SQL_Running", 3));
1959 1960 1961 1962 1963 1964
  field_list.push_back(new Item_empty_string("Replicate_Do_DB", 20));
  field_list.push_back(new Item_empty_string("Replicate_Ignore_DB", 20));
  field_list.push_back(new Item_empty_string("Replicate_Do_Table", 20));
  field_list.push_back(new Item_empty_string("Replicate_Ignore_Table", 23));
  field_list.push_back(new Item_empty_string("Replicate_Wild_Do_Table", 24));
  field_list.push_back(new Item_empty_string("Replicate_Wild_Ignore_Table",
1965
					     28));
1966 1967 1968
  field_list.push_back(new Item_return_int("Last_Errno", 4, MYSQL_TYPE_LONG));
  field_list.push_back(new Item_empty_string("Last_Error", 20));
  field_list.push_back(new Item_return_int("Skip_Counter", 10,
1969
					   MYSQL_TYPE_LONG));
1970
  field_list.push_back(new Item_return_int("Exec_Master_Log_Pos", 10,
1971
					   MYSQL_TYPE_LONGLONG));
1972
  field_list.push_back(new Item_return_int("Relay_Log_Space", 10,
1973
					   MYSQL_TYPE_LONGLONG));
1974
  field_list.push_back(new Item_empty_string("Until_Condition", 6));
1975
  field_list.push_back(new Item_empty_string("Until_Log_File", FN_REFLEN));
1976
  field_list.push_back(new Item_return_int("Until_Log_Pos", 10, 
1977
                                           MYSQL_TYPE_LONGLONG));
unknown's avatar
unknown committed
1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988
  field_list.push_back(new Item_empty_string("Master_SSL_Allowed", 7));
  field_list.push_back(new Item_empty_string("Master_SSL_CA_File",
                                             sizeof(mi->ssl_ca)));
  field_list.push_back(new Item_empty_string("Master_SSL_CA_Path", 
                                             sizeof(mi->ssl_capath)));
  field_list.push_back(new Item_empty_string("Master_SSL_Cert", 
                                             sizeof(mi->ssl_cert)));
  field_list.push_back(new Item_empty_string("Master_SSL_Cipher", 
                                             sizeof(mi->ssl_cipher)));
  field_list.push_back(new Item_empty_string("Master_SSL_Key", 
                                             sizeof(mi->ssl_key)));
1989
  field_list.push_back(new Item_return_int("Seconds_Behind_Master", 10,
unknown's avatar
unknown committed
1990
                                           MYSQL_TYPE_LONGLONG));
unknown's avatar
unknown committed
1991
  
1992
  if (protocol->send_fields(&field_list, 1))
unknown's avatar
unknown committed
1993 1994
    DBUG_RETURN(-1);

1995 1996
  if (mi->host[0])
  {
1997
    DBUG_PRINT("info",("host is set: '%s'", mi->host));
1998
    String *packet= &thd->packet;
1999
    protocol->prepare_for_resend();
unknown's avatar
unknown committed
2000
  
2001 2002
    pthread_mutex_lock(&mi->data_lock);
    pthread_mutex_lock(&mi->rli.data_lock);
unknown's avatar
unknown committed
2003 2004

    protocol->store(mi->io_thd ? mi->io_thd->proc_info : "", &my_charset_bin);
2005 2006
    protocol->store(mi->host, &my_charset_bin);
    protocol->store(mi->user, &my_charset_bin);
2007 2008
    protocol->store((uint32) mi->port);
    protocol->store((uint32) mi->connect_retry);
2009
    protocol->store(mi->master_log_name, &my_charset_bin);
2010
    protocol->store((ulonglong) mi->master_log_pos);
2011
    protocol->store(mi->rli.group_relay_log_name +
2012 2013
		    dirname_length(mi->rli.group_relay_log_name),
		    &my_charset_bin);
2014 2015
    protocol->store((ulonglong) mi->rli.group_relay_log_pos);
    protocol->store(mi->rli.group_master_log_name, &my_charset_bin);
2016 2017
    protocol->store(mi->slave_running ? "Yes":"No", &my_charset_bin);
    protocol->store(mi->rli.slave_running ? "Yes":"No", &my_charset_bin);
2018 2019
    protocol->store(&replicate_do_db);
    protocol->store(&replicate_ignore_db);
2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036
    /*
      We can't directly use some protocol->store for 
      replicate_*_table,
      as Protocol doesn't know the TABLE_RULE_ENT struct.
      We first build Strings and then pass them to protocol->store.
    */
    char buf[256];
    String tmp(buf, sizeof(buf), &my_charset_bin);
    table_rule_ent_hash_to_str(&tmp, &replicate_do_table);
    protocol->store(&tmp);
    table_rule_ent_hash_to_str(&tmp, &replicate_ignore_table);
    protocol->store(&tmp);
    table_rule_ent_dynamic_array_to_str(&tmp, &replicate_wild_do_table);
    protocol->store(&tmp);
    table_rule_ent_dynamic_array_to_str(&tmp, &replicate_wild_ignore_table);
    protocol->store(&tmp);

2037
    protocol->store((uint32) mi->rli.last_slave_errno);
2038
    protocol->store(mi->rli.last_slave_error, &my_charset_bin);
2039
    protocol->store((uint32) mi->rli.slave_skip_counter);
2040
    protocol->store((ulonglong) mi->rli.group_master_log_pos);
2041
    protocol->store((ulonglong) mi->rli.log_space_total);
2042 2043 2044 2045 2046 2047 2048 2049

    protocol->store(
      mi->rli.until_condition==RELAY_LOG_INFO::UNTIL_NONE ? "None": 
        ( mi->rli.until_condition==RELAY_LOG_INFO::UNTIL_MASTER_POS? "Master":
          "Relay"), &my_charset_bin);
    protocol->store(mi->rli.until_log_name, &my_charset_bin);
    protocol->store((ulonglong) mi->rli.until_log_pos);
    
unknown's avatar
unknown committed
2050 2051 2052 2053 2054 2055 2056 2057 2058 2059
#ifdef HAVE_OPENSSL 
    protocol->store(mi->ssl? "Yes":"No", &my_charset_bin);
#else
    protocol->store(mi->ssl? "Ignored":"No", &my_charset_bin);
#endif
    protocol->store(mi->ssl_ca, &my_charset_bin);
    protocol->store(mi->ssl_capath, &my_charset_bin);
    protocol->store(mi->ssl_cert, &my_charset_bin);
    protocol->store(mi->ssl_cipher, &my_charset_bin);
    protocol->store(mi->ssl_key, &my_charset_bin);
unknown's avatar
unknown committed
2060 2061 2062 2063 2064 2065 2066 2067 2068

    if (mi->rli.last_master_timestamp)
      protocol->store((ulonglong) 
                      (long)((time_t)time((time_t*) 0)
                             - mi->rli.last_master_timestamp)
                      - mi->clock_diff_with_master);
    else
      protocol->store_null();

2069 2070
    pthread_mutex_unlock(&mi->rli.data_lock);
    pthread_mutex_unlock(&mi->data_lock);
unknown's avatar
unknown committed
2071
  
2072 2073 2074
    if (my_net_write(&thd->net, (char*)thd->packet.ptr(), packet->length()))
      DBUG_RETURN(-1);
  }
2075
  send_eof(thd);
unknown's avatar
unknown committed
2076 2077 2078
  DBUG_RETURN(0);
}

2079

unknown's avatar
unknown committed
2080
bool flush_master_info(MASTER_INFO* mi, bool flush_relay_log_cache)
unknown's avatar
unknown committed
2081
{
unknown's avatar
unknown committed
2082
  IO_CACHE* file = &mi->file;
unknown's avatar
unknown committed
2083
  char lbuf[22];
2084 2085 2086
  DBUG_ENTER("flush_master_info");
  DBUG_PRINT("enter",("master_pos: %ld", (long) mi->master_log_pos));

2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110
  /*
    Flush the relay log to disk. If we don't do it, then the relay log while
    have some part (its last kilobytes) in memory only, so if the slave server
    dies now, with, say, from master's position 100 to 150 in memory only (not
    on disk), and with position 150 in master.info, then when the slave
    restarts, the I/O thread will fetch binlogs from 150, so in the relay log
    we will have "[0, 100] U [150, infinity[" and nobody will notice it, so the
    SQL thread will jump from 100 to 150, and replication will silently break.

    When we come to this place in code, relay log may or not be initialized;
    the caller is responsible for setting 'flush_relay_log_cache' accordingly.
  */
  if (flush_relay_log_cache)
    flush_io_cache(mi->rli.relay_log.get_log_file());

  /*
    We flushed the relay log BEFORE the master.info file, because if we crash
    now, we will get a duplicate event in the relay log at restart. If we
    flushed in the other order, we would get a hole in the relay log.
    And duplicate is better than hole (with a duplicate, in later versions we
    can add detection and scrap one event; with a hole there's nothing we can
    do).
  */

unknown's avatar
unknown committed
2111 2112 2113 2114 2115 2116 2117 2118
  /*
     In certain cases this code may create master.info files that seems 
     corrupted, because of extra lines filled with garbage in the end 
     file (this happens if new contents take less space than previous 
     contents of file). But because of number of lines in the first line 
     of file we don't care about this garbage.
  */
  
unknown's avatar
unknown committed
2119
  my_b_seek(file, 0L);
unknown's avatar
unknown committed
2120 2121 2122
  my_b_printf(file, "%u\n%s\n%s\n%s\n%s\n%s\n%d\n%d\n%d\n%s\n%s\n%s\n%s\n%s\n",
	      LINES_IN_MASTER_INFO_WITH_SSL,
              mi->master_log_name, llstr(mi->master_log_pos, lbuf),
2123
	      mi->host, mi->user,
unknown's avatar
unknown committed
2124 2125 2126
	      mi->password, mi->port, mi->connect_retry,
              (int)(mi->ssl), mi->ssl_ca, mi->ssl_capath, mi->ssl_cert,
              mi->ssl_cipher, mi->ssl_key);
unknown's avatar
unknown committed
2127
  flush_io_cache(file);
2128
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2129 2130
}

2131

unknown's avatar
unknown committed
2132
st_relay_log_info::st_relay_log_info()
2133 2134
  :info_fd(-1), cur_log_fd(-1), save_temporary_tables(0),
   cur_log_old_open_count(0), group_master_log_pos(0), log_space_total(0),
unknown's avatar
unknown committed
2135 2136 2137 2138
   ignore_log_space_limit(0), last_master_timestamp(0), slave_skip_counter(0),
   abort_pos_wait(0), slave_run_id(0), sql_thd(0), last_slave_errno(0),
   inited(0), abort_slave(0), slave_running(0), until_condition(UNTIL_NONE),
   until_log_pos(0)
2139 2140
{
  group_relay_log_name[0]= event_relay_log_name[0]= group_master_log_name[0]= 0;
2141 2142
  last_slave_error[0]=0; until_log_name[0]= 0;

unknown's avatar
unknown committed
2143 2144
  bzero((char*) &info_file, sizeof(info_file));
  bzero((char*) &cache_buf, sizeof(cache_buf));
unknown's avatar
unknown committed
2145 2146 2147 2148 2149 2150 2151
  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);
unknown's avatar
unknown committed
2152
  relay_log.init_pthread_objects();
unknown's avatar
unknown committed
2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166
}


st_relay_log_info::~st_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);
}

2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190
/*
  Waits until the SQL thread reaches (has executed up to) the
  log/position or timed out.

  SYNOPSIS
    wait_for_pos()
    thd             client thread that sent SELECT MASTER_POS_WAIT
    log_name        log name to wait for
    log_pos         position to wait for 
    timeout         timeout in seconds before giving up waiting

  NOTES
    timeout is longlong whereas it should be ulong ; but this is
    to catch if the user submitted a negative timeout.

  RETURN VALUES
    -2          improper arguments (log_pos<0)
                or slave not running, or master info changed
                during the function's execution,
                or client thread killed. -2 is translated to NULL by caller
    -1          timed out
    >=0         number of log events the function had to wait
                before reaching the desired log/position
 */
2191

2192
int st_relay_log_info::wait_for_pos(THD* thd, String* log_name,
2193 2194
                                    longlong log_pos,
                                    longlong timeout)
unknown's avatar
unknown committed
2195
{
2196 2197
  if (!inited)
    return -1;
unknown's avatar
unknown committed
2198
  int event_count = 0;
2199
  ulong init_abort_pos_wait;
2200 2201 2202 2203
  int error=0;
  struct timespec abstime; // for timeout checking
  set_timespec(abstime,timeout);

2204
  DBUG_ENTER("wait_for_pos");
2205 2206
  DBUG_PRINT("enter",("group_master_log_name: '%s'  pos: %lu timeout: %ld",
                      group_master_log_name, (ulong) group_master_log_pos, 
2207
                      (long) timeout));
2208

2209
  pthread_mutex_lock(&data_lock);
2210
  /* 
unknown's avatar
unknown committed
2211 2212 2213 2214 2215 2216 2217 2218
     This function will abort when it notices that some CHANGE MASTER or
     RESET MASTER has changed the master info.
     To catch this, these commands modify abort_pos_wait ; We just monitor
     abort_pos_wait and see if it has changed.
     Why do we have this mechanism instead of simply monitoring slave_running
     in the loop (we do this too), as CHANGE MASTER/RESET SLAVE require that
     the SQL thread be stopped?
     This is becasue if someones does:
2219
     STOP SLAVE;CHANGE MASTER/RESET SLAVE; START SLAVE;
unknown's avatar
unknown committed
2220 2221
     the change may happen very quickly and we may not notice that
     slave_running briefly switches between 1/0/1.
2222
  */
2223
  init_abort_pos_wait= abort_pos_wait;
2224

2225 2226 2227 2228 2229 2230 2231 2232
  /*
    We'll need to 
    handle all possible log names comparisons (e.g. 999 vs 1000).
    We use ulong for string->number conversion ; this is no 
    stronger limitation than in find_uniq_filename in sql/log.cc
  */
  ulong log_name_extension;
  char log_name_tmp[FN_REFLEN]; //make a char[] from String
unknown's avatar
unknown committed
2233 2234
  char *end= strmake(log_name_tmp, log_name->ptr(), min(log_name->length(),
							FN_REFLEN-1));
2235 2236 2237 2238 2239 2240 2241
  char *p= fn_ext(log_name_tmp);
  char *p_end;
  if (!*p || log_pos<0)   
  {
    error= -2; //means improper arguments
    goto err;
  }
unknown's avatar
unknown committed
2242
  /* p points to '.' */
2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254
  log_name_extension= strtoul(++p, &p_end, 10);
  /*
    p_end points to the first invalid character.
    If it equals to p, no digits were found, error.
    If it contains '\0' it means conversion went ok.
  */
  if (p_end==p || *p_end)
  {
    error= -2;
    goto err;
  }    

unknown's avatar
unknown committed
2255
  /* The "compare and wait" main loop */
2256
  while (!thd->killed &&
2257
         init_abort_pos_wait == abort_pos_wait &&
2258
         slave_running)
unknown's avatar
unknown committed
2259
  {
2260 2261
    bool pos_reached;
    int cmp_result= 0;
2262 2263
    DBUG_ASSERT(*group_master_log_name || group_master_log_pos == 0);
    if (*group_master_log_name)
unknown's avatar
unknown committed
2264
    {
2265
      char *basename= group_master_log_name + dirname_length(group_master_log_name);
unknown's avatar
unknown committed
2266
      /*
2267 2268 2269 2270
        First compare the parts before the extension.
        Find the dot in the master's log basename,
        and protect against user's input error :
        if the names do not match up to '.' included, return error
2271
      */
2272 2273 2274 2275 2276 2277 2278 2279
      char *q= (char*)(fn_ext(basename)+1);
      if (strncmp(basename, log_name_tmp, (int)(q-basename)))
      {
        error= -2;
        break;
      }
      // Now compare extensions.
      char *q_end;
2280 2281
      ulong group_master_log_name_extension= strtoul(q, &q_end, 10);
      if (group_master_log_name_extension < log_name_extension)
2282 2283
        cmp_result = -1 ;
      else
2284
        cmp_result= (group_master_log_name_extension > log_name_extension) ? 1 : 0 ;
unknown's avatar
unknown committed
2285
    }
2286
    pos_reached = ((!cmp_result && group_master_log_pos >= (ulonglong)log_pos) ||
2287
                   cmp_result > 0);
unknown's avatar
unknown committed
2288 2289
    if (pos_reached || thd->killed)
      break;
2290 2291

    //wait for master update, with optional timeout.
2292
    
unknown's avatar
unknown committed
2293
    DBUG_PRINT("info",("Waiting for master update"));
2294
    const char* msg = thd->enter_cond(&data_cond, &data_lock,
2295
                                      "Waiting for the slave SQL thread to \
2296
advance position");
2297 2298 2299 2300
    /*
      We are going to pthread_cond_(timed)wait(); if the SQL thread stops it
      will wake us up.
    */
2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317
    if (timeout > 0)
    {
      /*
        Note that pthread_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
        even if its condition is always immediately signaled (case of a loaded
        master).
      */
      error=pthread_cond_timedwait(&data_cond, &data_lock, &abstime);
    }
    else
      pthread_cond_wait(&data_cond, &data_lock);
2318
    DBUG_PRINT("info",("Got signal of master update"));
2319
    thd->exit_cond(msg);
2320 2321 2322 2323 2324
    if (error == ETIMEDOUT || error == ETIME)
    {
      error= -1;
      break;
    }
unknown's avatar
unknown committed
2325
    error=0;
2326
    event_count++;
2327
    DBUG_PRINT("info",("Testing if killed or SQL thread not running"));
2328
  }
2329 2330

err:
2331
  pthread_mutex_unlock(&data_lock);
2332
  DBUG_PRINT("exit",("killed: %d  abort: %d  slave_running: %d \
unknown's avatar
unknown committed
2333
improper_arguments: %d  timed_out: %d",
2334 2335
                     (int) thd->killed,
                     (int) (init_abort_pos_wait != abort_pos_wait),
2336
                     (int) slave_running,
2337 2338 2339
                     (int) (error == -2),
                     (int) (error == -1)));
  if (thd->killed || init_abort_pos_wait != abort_pos_wait ||
2340
      !slave_running) 
2341 2342 2343 2344
  {
    error= -2;
  }
  DBUG_RETURN( error ? error : event_count );
unknown's avatar
unknown committed
2345 2346
}

2347

unknown's avatar
unknown committed
2348
/*
2349
  init_slave_thread()
unknown's avatar
unknown committed
2350
*/
2351

2352
static int init_slave_thread(THD* thd, SLAVE_THD_TYPE thd_type)
unknown's avatar
unknown committed
2353 2354 2355
{
  DBUG_ENTER("init_slave_thread");
  thd->system_thread = thd->bootstrap = 1;
2356
  thd->host_or_ip= "";
unknown's avatar
unknown committed
2357 2358
  thd->client_capabilities = 0;
  my_net_init(&thd->net, 0);
unknown's avatar
unknown committed
2359
  thd->net.read_timeout = slave_net_timeout;
unknown's avatar
unknown committed
2360 2361
  thd->master_access= ~0;
  thd->priv_user = 0;
2362
  thd->slave_thread = 1;
2363
  thd->options = ((opt_log_slave_updates) ? OPTION_BIN_LOG:0) |
2364 2365
    OPTION_AUTO_IS_NULL;
  /* 
2366
     It's nonsense to constrain the slave threads with max_join_size; if a
2367 2368 2369
     query succeeded on master, we HAVE to execute it.
  */
  thd->variables.max_join_size= HA_POS_ERROR;    
unknown's avatar
unknown committed
2370
  thd->client_capabilities = CLIENT_LOCAL_FILES;
2371
  thd->real_id=pthread_self();
unknown's avatar
unknown committed
2372 2373 2374 2375
  pthread_mutex_lock(&LOCK_thread_count);
  thd->thread_id = thread_id++;
  pthread_mutex_unlock(&LOCK_thread_count);

2376
  if (init_thr_lock() || thd->store_globals())
unknown's avatar
unknown committed
2377
  {
2378 2379
    thd->cleanup();
    delete thd;
unknown's avatar
unknown committed
2380 2381 2382
    DBUG_RETURN(-1);
  }

unknown's avatar
unknown committed
2383
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
2384 2385 2386 2387 2388
  sigset_t set;
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
#endif

2389
  if (thd_type == SLAVE_THD_SQL)
2390
    thd->proc_info= "Waiting for the next event in relay log";
2391
  else
2392
    thd->proc_info= "Waiting for master update";
unknown's avatar
unknown committed
2393 2394 2395 2396 2397
  thd->version=refresh_version;
  thd->set_time();
  DBUG_RETURN(0);
}

2398

2399 2400
static int safe_sleep(THD* thd, int sec, CHECK_KILLED_FUNC thread_killed,
		      void* thread_killed_arg)
unknown's avatar
unknown committed
2401
{
2402
  int nap_time;
unknown's avatar
unknown committed
2403 2404 2405 2406 2407
  thr_alarm_t alarmed;
  thr_alarm_init(&alarmed);
  time_t start_time= time((time_t*) 0);
  time_t end_time= start_time+sec;

2408
  while ((nap_time= (int) (end_time - start_time)) > 0)
unknown's avatar
unknown committed
2409
  {
2410
    ALARM alarm_buff;
unknown's avatar
unknown committed
2411
    /*
2412
      The only reason we are asking for alarm is so that
unknown's avatar
unknown committed
2413 2414 2415
      we will be woken up in case of murder, so if we do not get killed,
      set the alarm so it goes off after we wake up naturally
    */
2416
    thr_alarm(&alarmed, 2 * nap_time, &alarm_buff);
unknown's avatar
unknown committed
2417
    sleep(nap_time);
2418
    thr_end_alarm(&alarmed);
unknown's avatar
unknown committed
2419
    
2420
    if ((*thread_killed)(thd,thread_killed_arg))
unknown's avatar
unknown committed
2421 2422 2423 2424 2425 2426
      return 1;
    start_time=time((time_t*) 0);
  }
  return 0;
}

2427

unknown's avatar
unknown committed
2428 2429
static int request_dump(MYSQL* mysql, MASTER_INFO* mi,
			bool *suppress_warnings)
unknown's avatar
unknown committed
2430
{
2431
  char buf[FN_REFLEN + 10];
unknown's avatar
unknown committed
2432 2433
  int len;
  int binlog_flags = 0; // for now
2434
  char* logname = mi->master_log_name;
2435 2436
  DBUG_ENTER("request_dump");

unknown's avatar
unknown committed
2437 2438
  // TODO if big log files: Change next to int8store()
  int4store(buf, (longlong) mi->master_log_pos);
unknown's avatar
unknown committed
2439
  int2store(buf + 4, binlog_flags);
2440
  int4store(buf + 6, server_id);
unknown's avatar
unknown committed
2441
  len = (uint) strlen(logname);
2442
  memcpy(buf + 10, logname,len);
unknown's avatar
SCRUM  
unknown committed
2443
  if (simple_command(mysql, COM_BINLOG_DUMP, buf, len + 10, 1))
unknown's avatar
unknown committed
2444
  {
unknown's avatar
unknown committed
2445 2446 2447 2448 2449
    /*
      Something went wrong, so we will just reconnect and retry later
      in the future, we should do a better error analysis, but for
      now we just fill up the error log :-)
    */
unknown's avatar
SCRUM  
unknown committed
2450
    if (mysql_errno(mysql) == ER_NET_READ_INTERRUPTED)
unknown's avatar
unknown committed
2451 2452
      *suppress_warnings= 1;			// Suppress reconnect warning
    else
2453
      sql_print_error("Error on COM_BINLOG_DUMP: %d  %s, will retry in %d secs",
unknown's avatar
SCRUM  
unknown committed
2454
		      mysql_errno(mysql), mysql_error(mysql),
2455 2456
		      master_connect_retry);
    DBUG_RETURN(1);
unknown's avatar
unknown committed
2457
  }
unknown's avatar
unknown committed
2458

2459
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2460 2461
}

2462

2463
static int request_table_dump(MYSQL* mysql, const char* db, const char* table)
unknown's avatar
unknown committed
2464 2465 2466
{
  char buf[1024];
  char * p = buf;
unknown's avatar
unknown committed
2467 2468
  uint table_len = (uint) strlen(table);
  uint db_len = (uint) strlen(db);
unknown's avatar
unknown committed
2469
  if (table_len + db_len > sizeof(buf) - 2)
unknown's avatar
unknown committed
2470 2471 2472 2473
  {
    sql_print_error("request_table_dump: Buffer overrun");
    return 1;
  } 
unknown's avatar
unknown committed
2474 2475 2476 2477 2478 2479 2480
  
  *p++ = db_len;
  memcpy(p, db, db_len);
  p += db_len;
  *p++ = table_len;
  memcpy(p, table, table_len);
  
unknown's avatar
SCRUM  
unknown committed
2481
  if (simple_command(mysql, COM_TABLE_DUMP, buf, p - buf + table_len, 1))
unknown's avatar
unknown committed
2482 2483
  {
    sql_print_error("request_table_dump: Error sending the table dump \
unknown's avatar
unknown committed
2484
command");
unknown's avatar
unknown committed
2485 2486
    return 1;
  }
unknown's avatar
unknown committed
2487 2488 2489 2490

  return 0;
}

2491

unknown's avatar
unknown committed
2492
/*
2493
  Read one event from the master
unknown's avatar
unknown committed
2494 2495 2496 2497 2498 2499 2500 2501 2502
  
  SYNOPSIS
    read_event()
    mysql		MySQL connection
    mi			Master connection information
    suppress_warnings	TRUE when a normal net read timeout has caused us to
			try a reconnect.  We do not want to print anything to
			the error log in this case because this a anormal
			event in an idle server.
2503

unknown's avatar
unknown committed
2504 2505 2506 2507 2508 2509
    RETURN VALUES
    'packet_error'	Error
    number		Length of packet
*/

static ulong read_event(MYSQL* mysql, MASTER_INFO *mi, bool* suppress_warnings)
unknown's avatar
unknown committed
2510
{
2511
  ulong len;
unknown's avatar
unknown committed
2512

2513
  *suppress_warnings= 0;
unknown's avatar
unknown committed
2514 2515 2516
  /*
    my_real_read() will time us out
    We check if we were told to die, and if not, try reading again
2517 2518

    TODO:  Move 'events_till_disconnect' to the MASTER_INFO structure
unknown's avatar
unknown committed
2519
  */
unknown's avatar
unknown committed
2520
#ifndef DBUG_OFF
unknown's avatar
unknown committed
2521
  if (disconnect_slave_event_count && !(events_till_disconnect--))
unknown's avatar
unknown committed
2522 2523 2524
    return packet_error;      
#endif
  
unknown's avatar
SCRUM  
unknown committed
2525
  len = net_safe_read(mysql);
2526
  if (len == packet_error || (long) len < 1)
unknown's avatar
unknown committed
2527
  {
unknown's avatar
SCRUM  
unknown committed
2528
    if (mysql_errno(mysql) == ER_NET_READ_INTERRUPTED)
unknown's avatar
unknown committed
2529 2530 2531 2532 2533 2534 2535 2536 2537 2538
    {
      /*
	We are trying a normal reconnect after a read timeout;
	we suppress prints to .err file as long as the reconnect
	happens without problems
      */
      *suppress_warnings= TRUE;
    }
    else
      sql_print_error("Error reading packet from server: %s (\
unknown's avatar
unknown committed
2539
server_errno=%d)",
unknown's avatar
SCRUM  
unknown committed
2540
		      mysql_error(mysql), mysql_errno(mysql));
unknown's avatar
unknown committed
2541 2542 2543
    return packet_error;
  }

2544 2545
  /* Check if eof packet */
  if (len < 8 && mysql->net.read_pos[0] == 254)
unknown's avatar
unknown committed
2546
  {
2547
     sql_print_error("Slave: received end packet from server, apparent\
unknown's avatar
unknown committed
2548
 master shutdown: %s",
unknown's avatar
SCRUM  
unknown committed
2549
		     mysql_error(mysql));
unknown's avatar
unknown committed
2550
     return packet_error;
unknown's avatar
unknown committed
2551
  }
unknown's avatar
unknown committed
2552 2553
  
  DBUG_PRINT("info",( "len=%u, net->read_pos[4] = %d\n",
2554
		      len, mysql->net.read_pos[4]));
unknown's avatar
unknown committed
2555 2556 2557
  return len - 1;   
}

unknown's avatar
unknown committed
2558

2559
int check_expected_error(THD* thd, RELAY_LOG_INFO* rli, int expected_error)
2560
{
unknown's avatar
unknown committed
2561 2562 2563 2564 2565
  switch (expected_error) {
  case ER_NET_READ_ERROR:
  case ER_NET_ERROR_ON_WRITE:  
  case ER_SERVER_SHUTDOWN:  
  case ER_NEW_ABORTING_CONNECTION:
2566 2567
    slave_print_error(rli,expected_error, 
                      "query '%s' partially completed on the master \
2568 2569
and was aborted. There is a chance that your master is inconsistent at this \
point. If you are sure that your master is ok, run this query manually on the\
2570
 slave and then restart the slave with SET GLOBAL SQL_SLAVE_SKIP_COUNTER=1;\
2571 2572
 SLAVE START; .", thd->query);
    thd->query_error= 1;
unknown's avatar
unknown committed
2573 2574 2575 2576
    return 1;
  default:
    return 0;
  }
2577
}
2578

2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667
/*
     Check if condition stated in UNTIL clause of START SLAVE is reached.
   SYNOPSYS
     st_relay_log_info::is_until_satisfied()
   DESCRIPTION
     Checks if UNTIL condition is reached. Uses caching result of last 
     comparison of current log file name and target log file name. So cached 
     value should be invalidated if current log file name changes 
     (see st_relay_log_info::notify_... functions).
     
     This caching is needed to avoid of expensive string comparisons and 
     strtol() conversions needed for log names comparison. We don't need to
     compare them each time this function is called, we only need to do this 
     when current log name changes. If we have UNTIL_MASTER_POS condition we 
     need to do this only after Rotate_log_event::exec_event() (which is 
     rare, so caching gives real benifit), and if we have UNTIL_RELAY_POS 
     condition then we should invalidate cached comarison value after 
     inc_group_relay_log_pos() which called for each group of events (so we
     have some benefit if we have something like queries that use 
     autoincrement or if we have transactions).
     
     Should be called ONLY if until_condition != UNTIL_NONE !
   RETURN VALUE
     true - condition met or error happened (condition seems to have 
            bad log file name)
     false - condition not met
*/

bool st_relay_log_info::is_until_satisfied()
{
  const char *log_name;
  ulonglong log_pos;

  DBUG_ASSERT(until_condition != UNTIL_NONE);
  
  if (until_condition == UNTIL_MASTER_POS)
  {
    log_name= group_master_log_name;
    log_pos= group_master_log_pos;
  }
  else
  { /* until_condition == UNTIL_RELAY_POS */
    log_name= group_relay_log_name;
    log_pos= group_relay_log_pos;
  }
  
  if (until_log_names_cmp_result == UNTIL_LOG_NAMES_CMP_UNKNOWN)
  {
    /* 
       We have no cached comaprison results so we should compare log names
       and cache result
    */

    DBUG_ASSERT(*log_name || log_pos == 0);
    
    if (*log_name)
    {
      const char *basename= log_name + dirname_length(log_name);
      
      const char *q= (const char*)(fn_ext(basename)+1);
      if (strncmp(basename, until_log_name, (int)(q-basename)) == 0)
      {
        /* Now compare extensions. */
        char *q_end;
        ulong log_name_extension= strtoul(q, &q_end, 10);
        if (log_name_extension < until_log_name_extension)
          until_log_names_cmp_result= UNTIL_LOG_NAMES_CMP_LESS;
        else
          until_log_names_cmp_result= 
            (log_name_extension > until_log_name_extension) ? 
            UNTIL_LOG_NAMES_CMP_GREATER : UNTIL_LOG_NAMES_CMP_EQUAL ;
      }
      else  
      {
        /* Probably error so we aborting */
        sql_print_error("Slave SQL thread is stopped because UNTIL "
                        "condition is bad.");
        return true;
      }
    }
    else
      return until_log_pos == 0;
  }
    
  return ((until_log_names_cmp_result == UNTIL_LOG_NAMES_CMP_EQUAL && 
           log_pos >= until_log_pos) ||
          until_log_names_cmp_result == UNTIL_LOG_NAMES_CMP_GREATER);
}

2668

2669
static int exec_relay_log_event(THD* thd, RELAY_LOG_INFO* rli)
unknown's avatar
unknown committed
2670
{
2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691
  /*
     We acquire this mutex since we need it for all operations except
     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);
  
  if (rli->until_condition!=RELAY_LOG_INFO::UNTIL_NONE && 
      rli->is_until_satisfied()) 
  {
    sql_print_error("Slave SQL thread stopped because it reached its"
                    " UNTIL position");
    /* 
      Setting abort_slave flag because we do not want additional message about
      error in query execution to be printed.
    */
    rli->abort_slave= 1;
    pthread_mutex_unlock(&rli->data_lock);
    return 1;
  }
  
2692
  Log_event * ev = next_event(rli);
2693
  
2694
  DBUG_ASSERT(rli->sql_thd==thd);
2695
  
2696
  if (sql_slave_killed(thd,rli))
2697
  {
2698
    pthread_mutex_unlock(&rli->data_lock);
unknown's avatar
unknown committed
2699
    delete ev;
2700
    return 1;
2701
  }
2702 2703
  if (ev)
  {
2704
    int type_code = ev->get_type_code();
2705
    int exec_res;
2706 2707 2708 2709 2710 2711 2712 2713 2714

    /*
      Skip queries originating from this server or number of
      queries specified by the user in slave_skip_counter
      We can't however skip event's that has something to do with the
      log files themselves.
    */

    if (ev->server_id == (uint32) ::server_id ||
2715
	(rli->slave_skip_counter && type_code != ROTATE_EVENT))
unknown's avatar
unknown committed
2716
    {
2717
      /* TODO: I/O thread should not even log events with the same server id */
2718
      rli->inc_group_relay_log_pos(ev->get_event_len(),
2719
		   type_code != STOP_EVENT ? ev->log_pos : LL(0),
2720 2721
		   1/* skip lock*/);
      flush_relay_log_info(rli);
unknown's avatar
unknown committed
2722 2723 2724 2725 2726 2727 2728 2729

      /*
	Protect against common user error of setting the counter to 1
	instead of 2 while recovering from an failed auto-increment insert
      */
      if (rli->slave_skip_counter && 
	  !((type_code == INTVAR_EVENT || type_code == STOP_EVENT) &&
	    rli->slave_skip_counter == 1))
2730 2731
        --rli->slave_skip_counter;
      pthread_mutex_unlock(&rli->data_lock);
unknown's avatar
unknown committed
2732 2733
      delete ev;     
      return 0;					// avoid infinite update loops
2734
    } 
2735
    pthread_mutex_unlock(&rli->data_lock);
2736 2737
  
    thd->server_id = ev->server_id; // use the original server id for logging
unknown's avatar
unknown committed
2738
    thd->set_time();				// time the query
2739
    thd->lex.current_select= 0;
unknown's avatar
unknown committed
2740
    if (!ev->when)
unknown's avatar
unknown committed
2741
      ev->when = time(NULL);
2742
    ev->thd = thd;
2743 2744
    exec_res = ev->exec_event(rli);
    DBUG_ASSERT(rli->sql_thd==thd);
2745 2746
    delete ev;
    return exec_res;
2747
  }
unknown's avatar
unknown committed
2748
  else
2749
  {
2750
    pthread_mutex_unlock(&rli->data_lock);
unknown's avatar
unknown committed
2751
    slave_print_error(rli, 0, "\
2752 2753 2754 2755 2756 2757 2758
Could not parse relay log event entry. The possible reasons are: the master's \
binary log is corrupted (you can check this by running 'mysqlbinlog' on the \
binary log), the slave's relay log is corrupted (you can check this by running \
'mysqlbinlog' on the relay log), a network problem, or a bug in the master's \
or slave's MySQL code. If you want to check the master's binary log or slave's \
relay log, you will be able to know their names by issuing 'SHOW SLAVE STATUS' \
on this slave.\
unknown's avatar
unknown committed
2759
");
2760 2761
    return 1;
  }
unknown's avatar
unknown committed
2762 2763
}

2764

unknown's avatar
unknown committed
2765
/* Slave I/O Thread entry point */
2766

2767
extern "C" pthread_handler_decl(handle_slave_io,arg)
unknown's avatar
unknown committed
2768
{
unknown's avatar
unknown committed
2769 2770 2771 2772 2773 2774 2775 2776
  THD *thd; // needs to be first for thread_stack
  MYSQL *mysql;
  MASTER_INFO *mi = (MASTER_INFO*)arg; 
  char llbuff[22];
  uint retry_count;
  
  // needs to call my_thread_init(), otherwise we get a coredump in DBUG_ stuff
  my_thread_init();
2777
  DBUG_ENTER("handle_slave_io");
unknown's avatar
unknown committed
2778

unknown's avatar
unknown committed
2779
#ifndef DBUG_OFF
unknown's avatar
unknown committed
2780
slave_begin:
unknown's avatar
unknown committed
2781
#endif  
2782
  DBUG_ASSERT(mi->inited);
unknown's avatar
unknown committed
2783 2784 2785
  mysql= NULL ;
  retry_count= 0;

2786
  pthread_mutex_lock(&mi->run_lock);
unknown's avatar
unknown committed
2787 2788 2789
  /* Inform waiting threads that slave has started */
  mi->slave_run_id++;

2790
#ifndef DBUG_OFF  
2791
  mi->events_till_abort = abort_slave_event_count;
2792
#endif  
unknown's avatar
unknown committed
2793
  
2794
  thd= new THD; // note that contructor of THD uses DBUG_ !
2795
  THD_CHECK_SENTRY(thd);
unknown's avatar
unknown committed
2796 2797

  pthread_detach_this_thread();
2798
  if (init_slave_thread(thd, SLAVE_THD_IO))
unknown's avatar
unknown committed
2799 2800 2801 2802 2803 2804
  {
    pthread_cond_broadcast(&mi->start_cond);
    pthread_mutex_unlock(&mi->run_lock);
    sql_print_error("Failed during slave I/O thread initialization");
    goto err;
  }
2805
  mi->io_thd = thd;
unknown's avatar
unknown committed
2806
  thd->thread_stack = (char*)&thd; // remember where our stack is
2807
  pthread_mutex_lock(&LOCK_thread_count);
unknown's avatar
unknown committed
2808
  threads.append(thd);
2809
  pthread_mutex_unlock(&LOCK_thread_count);
2810 2811 2812
  mi->slave_running = 1;
  mi->abort_slave = 0;
  pthread_mutex_unlock(&mi->run_lock);
2813
  pthread_cond_broadcast(&mi->start_cond);
unknown's avatar
unknown committed
2814
  
2815 2816 2817
  DBUG_PRINT("master_info",("log_file_name: '%s'  position: %s",
			    mi->master_log_name,
			    llstr(mi->master_log_pos,llbuff)));
unknown's avatar
unknown committed
2818
  
unknown's avatar
SCRUM  
unknown committed
2819
  if (!(mi->mysql = mysql = mysql_init(NULL)))
unknown's avatar
unknown committed
2820
  {
unknown's avatar
unknown committed
2821
    sql_print_error("Slave I/O thread: error in mysql_init()");
unknown's avatar
unknown committed
2822 2823
    goto err;
  }
unknown's avatar
unknown committed
2824
  
unknown's avatar
unknown committed
2825

2826
  thd->proc_info = "Connecting to master";
2827
  // we can get killed during safe_connect
2828
  if (!safe_connect(thd, mysql, mi))
unknown's avatar
unknown committed
2829
    sql_print_error("Slave I/O thread: connected to master '%s@%s:%d',\
2830
  replication started in log '%s' at position %s", mi->user,
unknown's avatar
unknown committed
2831 2832 2833
		    mi->host, mi->port,
		    IO_RPL_LOG_NAME,
		    llstr(mi->master_log_pos,llbuff));
2834
  else
unknown's avatar
unknown committed
2835
  {
2836
    sql_print_error("Slave I/O thread killed while connecting to master");
unknown's avatar
unknown committed
2837 2838
    goto err;
  }
2839

2840
connected:
2841

2842
  thd->slave_net = &mysql->net;
2843
  thd->proc_info = "Checking master version";
unknown's avatar
unknown committed
2844
  if (get_master_version_and_clock(mysql, mi))
2845
    goto err;
2846
  if (!mi->old_format)
2847
  {
unknown's avatar
unknown committed
2848 2849 2850 2851 2852
    /*
      Register ourselves with the master.
      If fails, this is not fatal - we just print the error message and go
      on with life.
    */
2853
    thd->proc_info = "Registering slave on master";
2854
    if (register_slave_on_master(mysql) ||  update_slave_list(mysql, mi))
2855 2856
      goto err;
  }
unknown's avatar
unknown committed
2857
  
2858
  DBUG_PRINT("info",("Starting reading binary log from master"));
2859
  while (!io_slave_killed(thd,mi))
unknown's avatar
unknown committed
2860
  {
unknown's avatar
unknown committed
2861
    bool suppress_warnings= 0;    
unknown's avatar
unknown committed
2862
    thd->proc_info = "Requesting binlog dump";
unknown's avatar
unknown committed
2863
    if (request_dump(mysql, mi, &suppress_warnings))
unknown's avatar
unknown committed
2864 2865
    {
      sql_print_error("Failed on request_dump()");
unknown's avatar
unknown committed
2866
      if (io_slave_killed(thd,mi))
unknown's avatar
unknown committed
2867 2868
      {
	sql_print_error("Slave I/O thread killed while requesting master \
unknown's avatar
unknown committed
2869
dump");
unknown's avatar
unknown committed
2870 2871
	goto err;
      }
unknown's avatar
unknown committed
2872
	  
2873
      thd->proc_info= "Waiting to reconnect after a failed binlog dump request";
unknown's avatar
SCRUM  
unknown committed
2874
      end_server(mysql);
unknown's avatar
unknown committed
2875 2876 2877 2878 2879
      /*
	First time retry immediately, assuming that we can recover
	right away - if first time fails, sleep between re-tries
	hopefuly the admin can fix the problem sometime
      */
2880 2881 2882 2883
      if (retry_count++)
      {
	if (retry_count > master_retry_count)
	  goto err;				// Don't retry forever
2884 2885
	safe_sleep(thd,mi->connect_retry,(CHECK_KILLED_FUNC)io_slave_killed,
		   (void*)mi);
2886
      }
2887
      if (io_slave_killed(thd,mi))
unknown's avatar
unknown committed
2888 2889
      {
	sql_print_error("Slave I/O thread killed while retrying master \
unknown's avatar
unknown committed
2890
dump");
unknown's avatar
unknown committed
2891 2892
	goto err;
      }
unknown's avatar
unknown committed
2893

2894
      thd->proc_info = "Reconnecting after a failed binlog dump request";
unknown's avatar
unknown committed
2895 2896
      if (!suppress_warnings)
	sql_print_error("Slave I/O thread: failed dump request, \
2897
reconnecting to try again, log '%s' at postion %s", IO_RPL_LOG_NAME,
unknown's avatar
unknown committed
2898 2899 2900
			llstr(mi->master_log_pos,llbuff));
      if (safe_reconnect(thd, mysql, mi, suppress_warnings) ||
	  io_slave_killed(thd,mi))
unknown's avatar
unknown committed
2901 2902
      {
	sql_print_error("Slave I/O thread killed during or \
2903
after reconnect");
unknown's avatar
unknown committed
2904 2905
	goto err;
      }
unknown's avatar
unknown committed
2906

unknown's avatar
unknown committed
2907 2908
      goto connected;
    }
unknown's avatar
unknown committed
2909

2910
    while (!io_slave_killed(thd,mi))
unknown's avatar
unknown committed
2911
    {
unknown's avatar
unknown committed
2912
      bool suppress_warnings= 0;    
2913 2914 2915 2916 2917 2918 2919
      /* 
         We say "waiting" because read_event() will wait if there's nothing to
         read. But if there's something to read, it will not wait. The important
         thing is to not confuse users by saying "reading" whereas we're in fact
         receiving nothing.
      */
      thd->proc_info = "Waiting for master to send event";
unknown's avatar
unknown committed
2920
      ulong event_len = read_event(mysql, mi, &suppress_warnings);
2921
      if (io_slave_killed(thd,mi))
unknown's avatar
unknown committed
2922
      {
2923 2924
	if (global_system_variables.log_warnings)
	  sql_print_error("Slave I/O thread killed while reading event");
unknown's avatar
unknown committed
2925 2926
	goto err;
      }
2927
	  	  
unknown's avatar
unknown committed
2928 2929
      if (event_len == packet_error)
      {
unknown's avatar
SCRUM  
unknown committed
2930
	uint mysql_error_number= mysql_errno(mysql);
2931
	if (mysql_error_number == ER_NET_PACKET_TOO_LARGE)
unknown's avatar
unknown committed
2932
	{
2933 2934 2935 2936
	  sql_print_error("\
Log entry on master is longer than max_allowed_packet (%ld) on \
slave. If the entry is correct, restart the server with a higher value of \
max_allowed_packet",
unknown's avatar
unknown committed
2937
			  thd->variables.max_allowed_packet);
unknown's avatar
unknown committed
2938 2939
	  goto err;
	}
2940 2941 2942
	if (mysql_error_number == ER_MASTER_FATAL_ERROR_READING_BINLOG)
	{
	  sql_print_error(ER(mysql_error_number), mysql_error_number,
unknown's avatar
SCRUM  
unknown committed
2943
			  mysql_error(mysql));
2944 2945
	  goto err;
	}
unknown's avatar
unknown committed
2946
	thd->proc_info = "Waiting to reconnect after a failed master event read";
unknown's avatar
SCRUM  
unknown committed
2947
	end_server(mysql);
2948 2949 2950 2951
	if (retry_count++)
	{
	  if (retry_count > master_retry_count)
	    goto err;				// Don't retry forever
2952
	  safe_sleep(thd,mi->connect_retry,(CHECK_KILLED_FUNC)io_slave_killed,
2953 2954
		     (void*) mi);
	}	    
2955
	if (io_slave_killed(thd,mi))
unknown's avatar
unknown committed
2956
	{
2957 2958
	  if (global_system_variables.log_warnings)
	    sql_print_error("Slave I/O thread killed while waiting to \
unknown's avatar
unknown committed
2959
reconnect after a failed read");
unknown's avatar
unknown committed
2960 2961
	  goto err;
	}
2962
	thd->proc_info = "Reconnecting after a failed master event read";
unknown's avatar
unknown committed
2963 2964
	if (!suppress_warnings)
	  sql_print_error("Slave I/O thread: Failed reading log event, \
2965
reconnecting to retry, log '%s' position %s", IO_RPL_LOG_NAME,
unknown's avatar
unknown committed
2966 2967 2968
			  llstr(mi->master_log_pos, llbuff));
	if (safe_reconnect(thd, mysql, mi, suppress_warnings) ||
	    io_slave_killed(thd,mi))
unknown's avatar
unknown committed
2969
	{
2970 2971
	  if (global_system_variables.log_warnings)
	    sql_print_error("Slave I/O thread killed during or after a \
unknown's avatar
unknown committed
2972
reconnect done to recover from failed read");
unknown's avatar
unknown committed
2973 2974 2975
	  goto err;
	}
	goto connected;
unknown's avatar
unknown committed
2976
      } // if (event_len == packet_error)
unknown's avatar
unknown committed
2977
	  
2978
      retry_count=0;			// ok event, reset retry counter
2979
      thd->proc_info = "Queueing master event to the relay log";
unknown's avatar
unknown committed
2980 2981 2982
      if (queue_event(mi,(const char*)mysql->net.read_pos + 1,
		      event_len))
      {
2983
	sql_print_error("Slave I/O thread could not queue event from master");
unknown's avatar
unknown committed
2984 2985
	goto err;
      }
unknown's avatar
unknown committed
2986
      flush_master_info(mi, 1); /* sure that we can flush the relay log */
2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998
      /*
        See if the relay logs take too much space.
        We don't lock mi->rli.log_space_lock here; this dirty read saves time
        and does not introduce any problem:
        - if mi->rli.ignore_log_space_limit is 1 but becomes 0 just after (so
        the clean value is 0), then we are reading only one more event as we
        should, and we'll block only at the next event. No big deal.
        - if mi->rli.ignore_log_space_limit is 0 but becomes 1 just after (so
        the clean value is 1), then we are going into wait_for_relay_log_space()
        for no reason, but this function will do a clean read, notice the clean
        value and exit immediately.
      */
2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009
#ifndef DBUG_OFF
      {
        char llbuf1[22], llbuf2[22];
        DBUG_PRINT("info", ("log_space_limit=%s log_space_total=%s \
ignore_log_space_limit=%d",
                            llstr(mi->rli.log_space_limit,llbuf1),
                            llstr(mi->rli.log_space_total,llbuf2),
                            (int) mi->rli.ignore_log_space_limit)); 
      }
#endif

unknown's avatar
unknown committed
3010
      if (mi->rli.log_space_limit && mi->rli.log_space_limit <
3011 3012
	  mi->rli.log_space_total &&
          !mi->rli.ignore_log_space_limit)
unknown's avatar
unknown committed
3013 3014 3015 3016 3017 3018
	if (wait_for_relay_log_space(&mi->rli))
	{
	  sql_print_error("Slave I/O thread aborted while waiting for relay \
log space");
	  goto err;
	}
unknown's avatar
unknown committed
3019
      // TODO: check debugging abort code
3020
#ifndef DBUG_OFF
unknown's avatar
unknown committed
3021 3022 3023 3024 3025
      if (abort_slave_event_count && !--events_till_abort)
      {
	sql_print_error("Slave I/O thread: debugging abort");
	goto err;
      }
3026
#endif
3027
    } 
3028
  }
unknown's avatar
unknown committed
3029

unknown's avatar
unknown committed
3030
  // error = 0;
unknown's avatar
unknown committed
3031
err:
3032 3033 3034
  // print the current replication position
  sql_print_error("Slave I/O thread exiting, read up to log '%s', position %s",
		  IO_RPL_LOG_NAME, llstr(mi->master_log_pos,llbuff));
3035
  VOID(pthread_mutex_lock(&LOCK_thread_count));
unknown's avatar
unknown committed
3036
  thd->query = thd->db = 0; // extra safety
3037
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
3038 3039
  if (mysql)
  {
unknown's avatar
SCRUM  
unknown committed
3040
    mysql_close(mysql);
unknown's avatar
unknown committed
3041 3042
    mi->mysql=0;
  }
unknown's avatar
unknown committed
3043
  thd->proc_info = "Waiting for slave mutex on exit";
3044 3045 3046 3047
  pthread_mutex_lock(&mi->run_lock);
  mi->slave_running = 0;
  mi->io_thd = 0;
  // TODO: make rpl_status part of MASTER_INFO
3048
  change_rpl_status(RPL_ACTIVE_SLAVE,RPL_IDLE_SLAVE);
3049 3050
  mi->abort_slave = 0; // TODO: check if this is needed
  DBUG_ASSERT(thd->net.buff != 0);
unknown's avatar
unknown committed
3051
  net_end(&thd->net); // destructor will not free it, because net.vio is 0
3052
  pthread_mutex_lock(&LOCK_thread_count);
3053
  THD_CHECK_SENTRY(thd);
unknown's avatar
unknown committed
3054
  delete thd;
3055
  pthread_mutex_unlock(&LOCK_thread_count);
unknown's avatar
unknown committed
3056
  pthread_cond_broadcast(&mi->stop_cond);	// tell the world we are done
3057
  pthread_mutex_unlock(&mi->run_lock);
unknown's avatar
unknown committed
3058
#ifndef DBUG_OFF
unknown's avatar
unknown committed
3059
  if (abort_slave_event_count && !events_till_abort)
unknown's avatar
unknown committed
3060 3061
    goto slave_begin;
#endif  
unknown's avatar
unknown committed
3062
  my_thread_end();
unknown's avatar
unknown committed
3063 3064 3065 3066
  pthread_exit(0);
  DBUG_RETURN(0);				// Can't return anything here
}

unknown's avatar
unknown committed
3067

unknown's avatar
unknown committed
3068
/* Slave SQL Thread entry point */
unknown's avatar
unknown committed
3069

3070
extern "C" pthread_handler_decl(handle_slave_sql,arg)
3071
{
3072
  THD *thd;			/* needs to be first for thread_stack */
3073 3074
  char llbuff[22],llbuff1[22];
  RELAY_LOG_INFO* rli = &((MASTER_INFO*)arg)->rli; 
unknown's avatar
unknown committed
3075 3076 3077 3078
  const char *errmsg;

  // needs to call my_thread_init(), otherwise we get a coredump in DBUG_ stuff
  my_thread_init();
3079
  DBUG_ENTER("handle_slave_sql");
unknown's avatar
unknown committed
3080 3081 3082 3083 3084

#ifndef DBUG_OFF
slave_begin:  
#endif  

3085 3086 3087
  DBUG_ASSERT(rli->inited);
  pthread_mutex_lock(&rli->run_lock);
  DBUG_ASSERT(!rli->slave_running);
unknown's avatar
unknown committed
3088
  errmsg= 0;
3089 3090 3091
#ifndef DBUG_OFF  
  rli->events_till_abort = abort_slave_event_count;
#endif  
3092

unknown's avatar
unknown committed
3093
  thd = new THD; // note that contructor of THD uses DBUG_ !
3094 3095
  thd->thread_stack = (char*)&thd; // remember where our stack is
  
unknown's avatar
unknown committed
3096 3097 3098
  /* Inform waiting threads that slave has started */
  rli->slave_run_id++;

3099 3100
  pthread_detach_this_thread();
  if (init_slave_thread(thd, SLAVE_THD_SQL))
unknown's avatar
unknown committed
3101 3102 3103 3104 3105 3106 3107 3108 3109 3110
  {
    /*
      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);
    sql_print_error("Failed during slave thread initialization");
    goto err;
  }
3111
  thd->init_for_queries();
3112
  rli->sql_thd= thd;
3113
  thd->temporary_tables = rli->save_temporary_tables; // restore temp tables
3114
  pthread_mutex_lock(&LOCK_thread_count);
3115
  threads.append(thd);
3116
  pthread_mutex_unlock(&LOCK_thread_count);
3117 3118 3119
  rli->slave_running = 1;
  rli->abort_slave = 0;
  pthread_mutex_unlock(&rli->run_lock);
3120
  pthread_cond_broadcast(&rli->start_cond);
3121

unknown's avatar
unknown committed
3122 3123 3124
  /*
    Reset errors for a clean start (otherwise, if the master is idle, the SQL
    thread may execute no Query_log_event, so the error will remain even
unknown's avatar
unknown committed
3125
    though there's no problem anymore). Do not reset the master timestamp
3126 3127 3128 3129
    (imagine the slave has caught everything, the STOP SLAVE and START SLAVE:
    as we are not sure that we are going to receive a query, we want to
    remember the last master timestamp (to say how many seconds behind we are
    now.
unknown's avatar
unknown committed
3130
    But the master timestamp is reset by RESET SLAVE & CHANGE MASTER.
unknown's avatar
unknown committed
3131
  */
unknown's avatar
unknown committed
3132
  clear_slave_error(rli);
3133 3134

  //tell the I/O thread to take relay_log_space_limit into account from now on
3135
  pthread_mutex_lock(&rli->log_space_lock);
3136
  rli->ignore_log_space_limit= 0;
3137
  pthread_mutex_unlock(&rli->log_space_lock);
3138

3139
  if (init_relay_log_pos(rli,
3140 3141
			 rli->group_relay_log_name,
			 rli->group_relay_log_pos,
3142
			 1 /*need data lock*/, &errmsg))
3143 3144 3145 3146 3147
  {
    sql_print_error("Error initializing relay log position: %s",
		    errmsg);
    goto err;
  }
3148
  THD_CHECK_SENTRY(thd);
3149 3150
  DBUG_ASSERT(rli->event_relay_log_pos >= BIN_LOG_HEADER_SIZE);
  DBUG_ASSERT(my_b_tell(rli->cur_log) == rli->event_relay_log_pos);
3151
  DBUG_ASSERT(rli->sql_thd == thd);
3152 3153

  DBUG_PRINT("master_info",("log_file_name: %s  position: %s",
3154 3155
			    rli->group_master_log_name,
			    llstr(rli->group_master_log_pos,llbuff)));
3156 3157
  if (global_system_variables.log_warnings)
    sql_print_error("Slave SQL thread initialized, starting replication in \
unknown's avatar
unknown committed
3158
log '%s' at position %s, relay log '%s' position: %s", RPL_LOG_NAME,
3159 3160
		    llstr(rli->group_master_log_pos,llbuff),rli->group_relay_log_name,
		    llstr(rli->group_relay_log_pos,llbuff1));
3161 3162 3163

  /* Read queries from the IO/THREAD until this thread is killed */

3164
  while (!sql_slave_killed(thd,rli))
3165
  {
3166
    thd->proc_info = "Reading event from the relay log"; 
3167
    DBUG_ASSERT(rli->sql_thd == thd);
3168
    THD_CHECK_SENTRY(thd);
3169 3170 3171
    if (exec_relay_log_event(thd,rli))
    {
      // do not scare the user if SQL thread was simply killed or stopped
3172
      if (!sql_slave_killed(thd,rli))
3173 3174
        sql_print_error("\
Error running query, slave SQL thread aborted. Fix the problem, and restart \
unknown's avatar
unknown committed
3175
the slave SQL thread with \"SLAVE START\". We stopped at log \
3176
'%s' position %s",
3177
		      RPL_LOG_NAME, llstr(rli->group_master_log_pos, llbuff));
3178 3179
      goto err;
    }
3180
  }
3181

3182
  /* Thread stopped. Print the current replication position to the log */
3183 3184
  sql_print_error("Slave SQL thread exiting, replication stopped in log \
 '%s' at position %s",
3185
		  RPL_LOG_NAME, llstr(rli->group_master_log_pos,llbuff));
3186 3187

 err:
3188
  VOID(pthread_mutex_lock(&LOCK_thread_count));
3189
  thd->query = thd->db = 0; // extra safety
3190
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
3191 3192
  thd->proc_info = "Waiting for slave mutex on exit";
  pthread_mutex_lock(&rli->run_lock);
3193 3194
  /* We need data_lock, at least to wake up any waiting master_pos_wait() */
  pthread_mutex_lock(&rli->data_lock);
3195
  DBUG_ASSERT(rli->slave_running == 1); // tracking buffer overrun
3196 3197
  /* When master_pos_wait() wakes up it will check this and terminate */
  rli->slave_running= 0; 
unknown's avatar
unknown committed
3198 3199 3200 3201 3202
  /* 
     Going out of the transaction. Necessary to mark it, in case the user
     restarts replication from a non-transactional statement (with CHANGE
     MASTER).
  */
3203 3204 3205 3206
  /* Wake up master_pos_wait() */
  pthread_mutex_unlock(&rli->data_lock);
  DBUG_PRINT("info",("Signaling possibly waiting master_pos_wait() functions"));
  pthread_cond_broadcast(&rli->data_cond);
unknown's avatar
unknown committed
3207
  rli->ignore_log_space_limit= 0; /* don't need any lock */
3208
  rli->save_temporary_tables = thd->temporary_tables;
unknown's avatar
unknown committed
3209 3210 3211 3212 3213

  /*
    TODO: see if we can do this conditionally in next_event() instead
    to avoid unneeded position re-init
  */
3214 3215 3216 3217
  thd->temporary_tables = 0; // remove tempation from destructor to close them
  DBUG_ASSERT(thd->net.buff != 0);
  net_end(&thd->net); // destructor will not free it, because we are weird
  DBUG_ASSERT(rli->sql_thd == thd);
3218
  THD_CHECK_SENTRY(thd);
3219
  rli->sql_thd= 0;
3220
  pthread_mutex_lock(&LOCK_thread_count);
3221
  THD_CHECK_SENTRY(thd);
3222 3223 3224 3225 3226 3227 3228 3229 3230
  delete thd;
  pthread_mutex_unlock(&LOCK_thread_count);
  pthread_cond_broadcast(&rli->stop_cond);
  // tell the world we are done
  pthread_mutex_unlock(&rli->run_lock);
#ifndef DBUG_OFF // TODO: reconsider the code below
  if (abort_slave_event_count && !rli->events_till_abort)
    goto slave_begin;
#endif  
unknown's avatar
unknown committed
3231
  my_thread_end();
3232 3233 3234
  pthread_exit(0);
  DBUG_RETURN(0);				// Can't return anything here
}
unknown's avatar
unknown committed
3235

3236

unknown's avatar
unknown committed
3237
/*
3238
  process_io_create_file()
unknown's avatar
unknown committed
3239
*/
3240

unknown's avatar
unknown committed
3241 3242 3243 3244 3245
static int process_io_create_file(MASTER_INFO* mi, Create_file_log_event* cev)
{
  int error = 1;
  ulong num_bytes;
  bool cev_not_written;
3246 3247
  THD *thd = mi->io_thd;
  NET *net = &mi->mysql->net;
unknown's avatar
unknown committed
3248
  DBUG_ENTER("process_io_create_file");
unknown's avatar
unknown committed
3249 3250

  if (unlikely(!cev->is_valid()))
unknown's avatar
unknown committed
3251
    DBUG_RETURN(1);
unknown's avatar
unknown committed
3252 3253 3254 3255 3256 3257
  /*
    TODO: fix to honor table rules, not only db rules
  */
  if (!db_ok(cev->db, replicate_do_db, replicate_ignore_db))
  {
    skip_load_data_infile(net);
unknown's avatar
unknown committed
3258
    DBUG_RETURN(0);
unknown's avatar
unknown committed
3259 3260 3261
  }
  DBUG_ASSERT(cev->inited_from_old);
  thd->file_id = cev->file_id = mi->file_id++;
3262
  thd->server_id = cev->server_id;
unknown's avatar
unknown committed
3263 3264 3265 3266 3267 3268 3269 3270 3271
  cev_not_written = 1;
  
  if (unlikely(net_request_file(net,cev->fname)))
  {
    sql_print_error("Slave I/O: failed requesting download of '%s'",
		    cev->fname);
    goto err;
  }

unknown's avatar
unknown committed
3272 3273 3274 3275
  /*
    This dummy block is so we could instantiate Append_block_log_event
    once and then modify it slightly instead of doing it multiple times
    in the loop
unknown's avatar
unknown committed
3276 3277
  */
  {
3278
    Append_block_log_event aev(thd,0,0,0,0);
unknown's avatar
unknown committed
3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289
  
    for (;;)
    {
      if (unlikely((num_bytes=my_net_read(net)) == packet_error))
      {
	sql_print_error("Network read error downloading '%s' from master",
			cev->fname);
	goto err;
      }
      if (unlikely(!num_bytes)) /* eof */
      {
3290
	net_write_command(net, 0, "", 0, "", 0);/* 3.23 master wants it */
unknown's avatar
unknown committed
3291
	Execute_load_log_event xev(thd,0,0);
3292
	xev.log_pos = mi->master_log_pos;
unknown's avatar
unknown committed
3293 3294 3295 3296 3297 3298
	if (unlikely(mi->rli.relay_log.append(&xev)))
	{
	  sql_print_error("Slave I/O: error writing Exec_load event to \
relay log");
	  goto err;
	}
unknown's avatar
unknown committed
3299
	mi->rli.relay_log.harvest_bytes_written(&mi->rli.log_space_total);
unknown's avatar
unknown committed
3300 3301 3302 3303 3304 3305
	break;
      }
      if (unlikely(cev_not_written))
      {
	cev->block = (char*)net->read_pos;
	cev->block_len = num_bytes;
3306
	cev->log_pos = mi->master_log_pos;
unknown's avatar
unknown committed
3307 3308 3309 3310 3311 3312 3313
	if (unlikely(mi->rli.relay_log.append(cev)))
	{
	  sql_print_error("Slave I/O: error writing Create_file event to \
relay log");
	  goto err;
	}
	cev_not_written=0;
unknown's avatar
unknown committed
3314
	mi->rli.relay_log.harvest_bytes_written(&mi->rli.log_space_total);
unknown's avatar
unknown committed
3315 3316 3317 3318 3319
      }
      else
      {
	aev.block = (char*)net->read_pos;
	aev.block_len = num_bytes;
3320
	aev.log_pos = mi->master_log_pos;
unknown's avatar
unknown committed
3321 3322 3323 3324 3325 3326
	if (unlikely(mi->rli.relay_log.append(&aev)))
	{
	  sql_print_error("Slave I/O: error writing Append_block event to \
relay log");
	  goto err;
	}
unknown's avatar
unknown committed
3327
	mi->rli.relay_log.harvest_bytes_written(&mi->rli.log_space_total) ;
unknown's avatar
unknown committed
3328 3329 3330 3331 3332
      }
    }
  }
  error=0;
err:
unknown's avatar
unknown committed
3333
  DBUG_RETURN(error);
unknown's avatar
unknown committed
3334
}
unknown's avatar
unknown committed
3335

3336

unknown's avatar
unknown committed
3337
/*
unknown's avatar
unknown committed
3338 3339 3340 3341 3342 3343 3344 3345
  Start using a new binary log on the master

  SYNOPSIS
    process_io_rotate()
    mi			master_info for the slave
    rev			The rotate log event read from the binary log

  DESCRIPTION
3346
    Updates the master info with the place in the next binary
unknown's avatar
unknown committed
3347 3348 3349 3350 3351 3352 3353 3354
    log where we should start reading.

  NOTES
    We assume we already locked mi->data_lock

  RETURN VALUES
    0		ok
    1	        Log event is illegal
unknown's avatar
unknown committed
3355 3356 3357

*/

unknown's avatar
unknown committed
3358
static int process_io_rotate(MASTER_INFO *mi, Rotate_log_event *rev)
3359
{
unknown's avatar
unknown committed
3360
  int return_val= 1;
3361
  DBUG_ENTER("process_io_rotate");
unknown's avatar
unknown committed
3362
  safe_mutex_assert_owner(&mi->data_lock);
3363

unknown's avatar
unknown committed
3364
  if (unlikely(!rev->is_valid()))
3365
    DBUG_RETURN(1);
unknown's avatar
unknown committed
3366 3367 3368 3369 3370

  memcpy(mi->master_log_name, rev->new_log_ident, rev->ident_len+1);
  mi->master_log_pos= rev->pos;
  DBUG_PRINT("info", ("master_log_pos: '%s' %d",
		      mi->master_log_name, (ulong) mi->master_log_pos));
3371
#ifndef DBUG_OFF
unknown's avatar
unknown committed
3372 3373 3374 3375 3376 3377
  /*
    If we do not do this, we will be getting the first
    rotate event forever, so we need to not disconnect after one.
  */
  if (disconnect_slave_event_count)
    events_till_disconnect++;
3378
#endif
3379
  DBUG_RETURN(0);
3380 3381
}

3382

unknown's avatar
unknown committed
3383
/*
3384 3385
  queue_old_event()

3386 3387
  Writes a 3.23 event to the relay log.

unknown's avatar
unknown committed
3388 3389 3390
  TODO: 
    Test this code before release - it has to be tested on a separate
    setup with 3.23 master 
unknown's avatar
unknown committed
3391 3392 3393 3394
*/

static int queue_old_event(MASTER_INFO *mi, const char *buf,
			   ulong event_len)
3395
{
unknown's avatar
unknown committed
3396
  const char *errmsg = 0;
unknown's avatar
unknown committed
3397 3398 3399 3400
  ulong inc_pos;
  bool ignore_event= 0;
  char *tmp_buf = 0;
  RELAY_LOG_INFO *rli= &mi->rli;
unknown's avatar
unknown committed
3401 3402
  DBUG_ENTER("queue_old_event");

unknown's avatar
unknown committed
3403 3404 3405
  /*
    If we get Load event, we need to pass a non-reusable buffer
    to read_log_event, so we do a trick
unknown's avatar
unknown committed
3406 3407 3408 3409 3410 3411
  */
  if (buf[EVENT_TYPE_OFFSET] == LOAD_EVENT)
  {
    if (unlikely(!(tmp_buf=(char*)my_malloc(event_len+1,MYF(MY_WME)))))
    {
      sql_print_error("Slave I/O: out of memory for Load event");
unknown's avatar
unknown committed
3412
      DBUG_RETURN(1);
unknown's avatar
unknown committed
3413 3414 3415 3416 3417
    }
    memcpy(tmp_buf,buf,event_len);
    tmp_buf[event_len]=0; // Create_file constructor wants null-term buffer
    buf = (const char*)tmp_buf;
  }
3418 3419 3420 3421 3422 3423
  /*
    This will transform LOAD_EVENT into CREATE_FILE_EVENT, ask the master to
    send the loaded file, and write it to the relay log in the form of
    Append_block/Exec_load (the SQL thread needs the data, as that thread is not
    connected to the master).
  */
unknown's avatar
unknown committed
3424 3425
  Log_event *ev = Log_event::read_log_event(buf,event_len, &errmsg,
					    1 /*old format*/ );
3426
  if (unlikely(!ev))
3427 3428
  {
    sql_print_error("Read invalid event from master: '%s',\
unknown's avatar
unknown committed
3429
 master could be corrupt but a more likely cause of this is a bug",
3430
		    errmsg);
unknown's avatar
unknown committed
3431 3432
    my_free((char*) tmp_buf, MYF(MY_ALLOW_ZERO_PTR));
    DBUG_RETURN(1);
3433
  }
3434
  pthread_mutex_lock(&mi->data_lock);
3435
  ev->log_pos = mi->master_log_pos;
unknown's avatar
unknown committed
3436
  switch (ev->get_type_code()) {
unknown's avatar
unknown committed
3437
  case STOP_EVENT:
3438
    ignore_event= 1;
unknown's avatar
unknown committed
3439 3440
    inc_pos= event_len;
    break;
3441
  case ROTATE_EVENT:
3442
    if (unlikely(process_io_rotate(mi,(Rotate_log_event*)ev)))
3443 3444
    {
      delete ev;
3445
      pthread_mutex_unlock(&mi->data_lock);
unknown's avatar
unknown committed
3446
      DBUG_RETURN(1);
3447
    }
unknown's avatar
unknown committed
3448
    inc_pos= 0;
3449
    break;
unknown's avatar
unknown committed
3450
  case CREATE_FILE_EVENT:
3451 3452 3453 3454 3455 3456
    /*
      Yes it's possible to have CREATE_FILE_EVENT here, even if we're in
      queue_old_event() which is for 3.23 events which don't comprise
      CREATE_FILE_EVENT. This is because read_log_event() above has just
      transformed LOAD_EVENT into CREATE_FILE_EVENT.
    */
unknown's avatar
unknown committed
3457
  {
unknown's avatar
unknown committed
3458 3459
    /* We come here when and only when tmp_buf != 0 */
    DBUG_ASSERT(tmp_buf);
unknown's avatar
unknown committed
3460
    int error = process_io_create_file(mi,(Create_file_log_event*)ev);
3461
    delete ev;
unknown's avatar
unknown committed
3462
    mi->master_log_pos += event_len;
3463
    DBUG_PRINT("info", ("master_log_pos: %d", (ulong) mi->master_log_pos));
3464
    pthread_mutex_unlock(&mi->data_lock);
unknown's avatar
unknown committed
3465
    my_free((char*)tmp_buf, MYF(0));
unknown's avatar
unknown committed
3466
    DBUG_RETURN(error);
unknown's avatar
unknown committed
3467
  }
3468
  default:
unknown's avatar
unknown committed
3469
    inc_pos= event_len;
3470 3471
    break;
  }
unknown's avatar
unknown committed
3472
  if (likely(!ignore_event))
3473
  {
unknown's avatar
unknown committed
3474
    if (unlikely(rli->relay_log.append(ev)))
3475 3476 3477
    {
      delete ev;
      pthread_mutex_unlock(&mi->data_lock);
unknown's avatar
unknown committed
3478
      DBUG_RETURN(1);
3479
    }
unknown's avatar
unknown committed
3480
    rli->relay_log.harvest_bytes_written(&rli->log_space_total);
3481 3482
  }
  delete ev;
unknown's avatar
unknown committed
3483
  mi->master_log_pos+= inc_pos;
3484
  DBUG_PRINT("info", ("master_log_pos: %d", (ulong) mi->master_log_pos));
3485
  pthread_mutex_unlock(&mi->data_lock);
unknown's avatar
unknown committed
3486
  DBUG_RETURN(0);
3487 3488
}

3489

unknown's avatar
unknown committed
3490
/*
3491 3492
  queue_event()

unknown's avatar
unknown committed
3493 3494 3495
*/

int queue_event(MASTER_INFO* mi,const char* buf, ulong event_len)
3496
{
unknown's avatar
unknown committed
3497 3498 3499
  int error= 0;
  ulong inc_pos;
  RELAY_LOG_INFO *rli= &mi->rli;
unknown's avatar
unknown committed
3500 3501
  DBUG_ENTER("queue_event");

3502
  if (mi->old_format)
unknown's avatar
unknown committed
3503
    DBUG_RETURN(queue_old_event(mi,buf,event_len));
3504 3505

  pthread_mutex_lock(&mi->data_lock);
unknown's avatar
unknown committed
3506

unknown's avatar
unknown committed
3507 3508
  /*
    TODO: figure out if other events in addition to Rotate
3509 3510
    require special processing.
    Guilhem 2003-06 : I don't think so.
unknown's avatar
unknown committed
3511 3512
  */
  switch (buf[EVENT_TYPE_OFFSET]) {
3513
  case STOP_EVENT:
3514 3515
    /*
      We needn't write this event to the relay log. Indeed, it just indicates a
unknown's avatar
unknown committed
3516 3517 3518 3519
      master server shutdown. The only thing this does is cleaning. But
      cleaning is already done on a per-master-thread basis (as the master
      server is shutting down cleanly, it has written all DROP TEMPORARY TABLE
      and DO RELEASE_LOCK; prepared statements' deletion are TODO).
3520
      
unknown's avatar
unknown committed
3521 3522 3523 3524
      We don't even increment mi->master_log_pos, because we may be just after
      a Rotate event. Btw, in a few milliseconds we are going to have a Start
      event from the next binlog (unless the master is presently running
      without --log-bin).
3525 3526
    */
    goto err;
3527 3528 3529
  case ROTATE_EVENT:
  {
    Rotate_log_event rev(buf,event_len,0);
3530
    if (unlikely(process_io_rotate(mi,&rev)))
unknown's avatar
unknown committed
3531
    {
3532 3533
      error= 1;
      goto err;
unknown's avatar
unknown committed
3534
    }
3535 3536 3537 3538
    /*
      Now the I/O thread has just changed its mi->master_log_name, so
      incrementing mi->master_log_pos is nonsense.
    */
unknown's avatar
unknown committed
3539
    inc_pos= 0;
3540 3541 3542
    break;
  }
  default:
unknown's avatar
unknown committed
3543
    inc_pos= event_len;
3544 3545
    break;
  }
3546 3547 3548 3549

  /* 
     If this event is originating from this server, don't queue it. 
     We don't check this for 3.23 events because it's simpler like this; 3.23
unknown's avatar
unknown committed
3550 3551
     will be filtered anyway by the SQL slave thread which also tests the
     server id (we must also keep this test in the SQL thread, in case somebody
3552 3553 3554 3555 3556 3557 3558 3559 3560
     upgrades a 4.0 slave which has a not-filtered relay log).

     ANY event coming from ourselves can be ignored: it is obvious for queries;
     for STOP_EVENT/ROTATE_EVENT/START_EVENT: these cannot come from ourselves
     (--log-slave-updates would not log that) unless this slave is also its
     direct master (an unsupported, useless setup!).
  */

  if (uint4korr(buf + SERVER_ID_OFFSET) == ::server_id)
3561
  {
3562 3563 3564 3565 3566 3567
    /*
      Do not write it to the relay log.
      We still want to increment, so that we won't re-read this event from the
      master if the slave IO thread is now stopped/restarted (more efficient if
      the events we are ignoring are big LOAD DATA INFILE).
    */
unknown's avatar
unknown committed
3568
    mi->master_log_pos+= inc_pos;
3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579
    DBUG_PRINT("info", ("master_log_pos: %d, event originating from the same server, ignored", (ulong) mi->master_log_pos));
  }  
  else /* write the event to the relay log */
    if (likely(!(error= rli->relay_log.appendv(buf,event_len,0))))
    {
      mi->master_log_pos+= inc_pos;
      DBUG_PRINT("info", ("master_log_pos: %d", (ulong) mi->master_log_pos));
      rli->relay_log.harvest_bytes_written(&rli->log_space_total);
    }

err:
3580
  pthread_mutex_unlock(&mi->data_lock);
unknown's avatar
unknown committed
3581
  DBUG_RETURN(error);
3582 3583
}

3584

3585 3586
void end_relay_log_info(RELAY_LOG_INFO* rli)
{
3587 3588
  DBUG_ENTER("end_relay_log_info");

3589
  if (!rli->inited)
3590
    DBUG_VOID_RETURN;
3591
  if (rli->info_fd >= 0)
unknown's avatar
unknown committed
3592 3593
  {
    end_io_cache(&rli->info_file);
3594
    (void) my_close(rli->info_fd, MYF(MY_WME));
unknown's avatar
unknown committed
3595 3596
    rli->info_fd = -1;
  }
3597
  if (rli->cur_log_fd >= 0)
unknown's avatar
unknown committed
3598 3599 3600 3601 3602
  {
    end_io_cache(&rli->cache_buf);
    (void)my_close(rli->cur_log_fd, MYF(MY_WME));
    rli->cur_log_fd = -1;
  }
3603
  rli->inited = 0;
3604
  rli->relay_log.close(LOG_CLOSE_INDEX | LOG_CLOSE_STOP_EVENT);
unknown's avatar
unknown committed
3605 3606 3607 3608 3609 3610
  /*
    Delete the slave's temporary tables from memory.
    In the future there will be other actions than this, to ensure persistance
    of slave's temp tables after shutdown.
  */
  rli->close_temporary_tables();
3611
  DBUG_VOID_RETURN;
3612 3613
}

unknown's avatar
unknown committed
3614 3615
/*
  Try to connect until successful or slave killed
3616

unknown's avatar
unknown committed
3617 3618 3619 3620 3621
  SYNPOSIS
    safe_connect()
    thd			Thread handler for slave
    mysql		MySQL connection handle
    mi			Replication handle
3622

unknown's avatar
unknown committed
3623 3624 3625 3626
  RETURN
    0	ok
    #	Error
*/
3627

3628
static int safe_connect(THD* thd, MYSQL* mysql, MASTER_INFO* mi)
unknown's avatar
unknown committed
3629
{
unknown's avatar
unknown committed
3630
  return connect_to_master(thd, mysql, mi, 0, 0);
unknown's avatar
unknown committed
3631 3632
}

3633

3634
/*
unknown's avatar
unknown committed
3635 3636
  SYNPOSIS
    connect_to_master()
unknown's avatar
unknown committed
3637

unknown's avatar
unknown committed
3638 3639 3640
  IMPLEMENTATION
    Try to connect until successful or slave killed or we have retried
    master_retry_count times
3641
*/
unknown's avatar
unknown committed
3642

unknown's avatar
unknown committed
3643
static int connect_to_master(THD* thd, MYSQL* mysql, MASTER_INFO* mi,
unknown's avatar
unknown committed
3644
			     bool reconnect, bool suppress_warnings)
unknown's avatar
unknown committed
3645
{
3646
  int slave_was_killed;
3647 3648
  int last_errno= -2;				// impossible error
  ulong err_count=0;
unknown's avatar
unknown committed
3649
  char llbuff[22];
3650
  DBUG_ENTER("connect_to_master");
unknown's avatar
unknown committed
3651

unknown's avatar
unknown committed
3652 3653 3654
#ifndef DBUG_OFF
  events_till_disconnect = disconnect_slave_event_count;
#endif
3655
  ulong client_flag= CLIENT_REMEMBER_OPTIONS;
3656 3657 3658
  if (opt_slave_compressed_protocol)
    client_flag=CLIENT_COMPRESS;		/* We will use compression */

3659 3660
  mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, (char *) &slave_net_timeout);
  mysql_options(mysql, MYSQL_OPT_READ_TIMEOUT, (char *) &slave_net_timeout);
unknown's avatar
unknown committed
3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671
 
#ifdef HAVE_OPENSSL
  if (mi->ssl)
    mysql_ssl_set(mysql, 
                  mi->ssl_key[0]?mi->ssl_key:0,
                  mi->ssl_cert[0]?mi->ssl_cert:0, 
                  mi->ssl_ca[0]?mi->ssl_ca:0,
                  mi->ssl_capath[0]?mi->ssl_capath:0,
                  mi->ssl_cipher[0]?mi->ssl_cipher:0);
#endif

3672 3673 3674 3675
  mysql_options(mysql, MYSQL_SET_CHARSET_NAME, default_charset_info->csname);
  /* This one is not strictly needed but we have it here for completeness */
  mysql_options(mysql, MYSQL_SET_CHARSET_DIR, (char *) charsets_dir);

3676
  while (!(slave_was_killed = io_slave_killed(thd,mi)) &&
3677 3678 3679
	 (reconnect ? mysql_reconnect(mysql) != 0 :
	  mysql_real_connect(mysql, mi->host, mi->user, mi->password, 0,
			     mi->port, 0, client_flag) == 0))
unknown's avatar
unknown committed
3680
  {
3681
    /* Don't repeat last error */
unknown's avatar
SCRUM  
unknown committed
3682
    if ((int)mysql_errno(mysql) != last_errno)
3683
    {
unknown's avatar
SCRUM  
unknown committed
3684
      last_errno=mysql_errno(mysql);
unknown's avatar
unknown committed
3685
      suppress_warnings= 0;
3686
      sql_print_error("Slave I/O thread: error %s to master \
3687
'%s@%s:%d': \
3688
Error: '%s'  errno: %d  retry-time: %d  retries: %d",
3689
		      (reconnect ? "reconnecting" : "connecting"),
3690
		      mi->user,mi->host,mi->port,
unknown's avatar
SCRUM  
unknown committed
3691
		      mysql_error(mysql), last_errno,
3692 3693
		      mi->connect_retry,
		      master_retry_count);
3694
    }
unknown's avatar
unknown committed
3695 3696 3697
    /*
      By default we try forever. The reason is that failure will trigger
      master election, so if the user did not set master_retry_count we
3698
      do not want to have election triggered on the first failure to
unknown's avatar
unknown committed
3699
      connect
3700
    */
3701
    if (++err_count == master_retry_count)
3702 3703
    {
      slave_was_killed=1;
unknown's avatar
unknown committed
3704 3705
      if (reconnect)
        change_rpl_status(RPL_ACTIVE_SLAVE,RPL_LOST_SOLDIER);
3706 3707
      break;
    }
3708 3709
    safe_sleep(thd,mi->connect_retry,(CHECK_KILLED_FUNC)io_slave_killed,
	       (void*)mi);
unknown's avatar
unknown committed
3710
  }
3711

3712 3713
  if (!slave_was_killed)
  {
unknown's avatar
unknown committed
3714
    if (reconnect)
unknown's avatar
unknown committed
3715
    { 
3716
      if (!suppress_warnings && global_system_variables.log_warnings)
unknown's avatar
unknown committed
3717
	sql_print_error("Slave: connected to master '%s@%s:%d',\
3718
replication resumed in log '%s' at position %s", mi->user,
unknown's avatar
unknown committed
3719 3720 3721 3722
			mi->host, mi->port,
			IO_RPL_LOG_NAME,
			llstr(mi->master_log_pos,llbuff));
    }
unknown's avatar
unknown committed
3723 3724 3725 3726
    else
    {
      change_rpl_status(RPL_IDLE_SLAVE,RPL_ACTIVE_SLAVE);
      mysql_log.write(thd, COM_CONNECT_OUT, "%s@%s:%d",
unknown's avatar
unknown committed
3727
		      mi->user, mi->host, mi->port);
unknown's avatar
unknown committed
3728
    }
3729
#ifdef SIGNAL_WITH_VIO_CLOSE
3730
    thd->set_active_vio(mysql->net.vio);
3731
#endif      
3732
  }
3733 3734
  DBUG_PRINT("exit",("slave_was_killed: %d", slave_was_killed));
  DBUG_RETURN(slave_was_killed);
unknown's avatar
unknown committed
3735 3736
}

3737

unknown's avatar
unknown committed
3738
/*
3739
  safe_reconnect()
unknown's avatar
unknown committed
3740

unknown's avatar
unknown committed
3741 3742 3743
  IMPLEMENTATION
    Try to connect until successful or slave killed or we have retried
    master_retry_count times
unknown's avatar
unknown committed
3744 3745
*/

unknown's avatar
unknown committed
3746 3747
static int safe_reconnect(THD* thd, MYSQL* mysql, MASTER_INFO* mi,
			  bool suppress_warnings)
unknown's avatar
unknown committed
3748
{
unknown's avatar
unknown committed
3749 3750
  DBUG_ENTER("safe_reconnect");
  DBUG_RETURN(connect_to_master(thd, mysql, mi, 1, suppress_warnings));
unknown's avatar
unknown committed
3751 3752
}

unknown's avatar
unknown committed
3753

3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783
/*
  Store the file and position where the execute-slave thread are in the
  relay log.

  SYNOPSIS
    flush_relay_log_info()
    rli			Relay log information

  NOTES
    - As this is only called by the slave thread, we don't need to
      have a lock on this.
    - If there is an active transaction, then we don't update the position
      in the relay log.  This is to ensure that we re-execute statements
      if we die in the middle of an transaction that was rolled back.
    - As a transaction never spans binary logs, we don't have to handle the
      case where we do a relay-log-rotation in the middle of the transaction.
      If this would not be the case, we would have to ensure that we
      don't delete the relay log file where the transaction started when
      we switch to a new relay log file.

  TODO
    - Change the log file information to a binary format to avoid calling
      longlong2str.

  RETURN VALUES
    0	ok
    1	write error
*/

bool flush_relay_log_info(RELAY_LOG_INFO* rli)
3784
{
3785 3786 3787 3788
  bool error=0;
  IO_CACHE *file = &rli->info_file;
  char buff[FN_REFLEN*2+22*2+4], *pos;

3789
  my_b_seek(file, 0L);
3790
  pos=strmov(buff, rli->group_relay_log_name);
3791
  *pos++='\n';
3792
  pos=longlong2str(rli->group_relay_log_pos, pos, 10);
3793
  *pos++='\n';
3794
  pos=strmov(pos, rli->group_master_log_name);
3795
  *pos++='\n';
3796
  pos=longlong2str(rli->group_master_log_pos, pos, 10);
3797
  *pos='\n';
3798
  if (my_b_write(file, (byte*) buff, (ulong) (pos-buff)+1))
3799 3800 3801 3802
    error=1;
  if (flush_io_cache(file))
    error=1;
  return error;
3803 3804
}

3805

unknown's avatar
unknown committed
3806
/*
3807
  Called when we notice that the current "hot" log got rotated under our feet.
unknown's avatar
unknown committed
3808 3809 3810
*/

static IO_CACHE *reopen_relay_log(RELAY_LOG_INFO *rli, const char **errmsg)
3811 3812 3813
{
  DBUG_ASSERT(rli->cur_log != &rli->cache_buf);
  DBUG_ASSERT(rli->cur_log_fd == -1);
unknown's avatar
unknown committed
3814 3815 3816
  DBUG_ENTER("reopen_relay_log");

  IO_CACHE *cur_log = rli->cur_log=&rli->cache_buf;
3817
  if ((rli->cur_log_fd=open_binlog(cur_log,rli->event_relay_log_name,
unknown's avatar
unknown committed
3818
				   errmsg)) <0)
unknown's avatar
unknown committed
3819
    DBUG_RETURN(0);
3820 3821 3822 3823 3824
  /*
    We want to start exactly where we was before:
    relay_log_pos	Current log pos
    pending		Number of bytes already processed from the event
  */
3825
  my_b_seek(cur_log,rli->event_relay_log_pos);
unknown's avatar
unknown committed
3826
  DBUG_RETURN(cur_log);
3827 3828
}

unknown's avatar
unknown committed
3829

3830 3831 3832 3833
Log_event* next_event(RELAY_LOG_INFO* rli)
{
  Log_event* ev;
  IO_CACHE* cur_log = rli->cur_log;
3834
  pthread_mutex_t *log_lock = rli->relay_log.get_log_lock(); 
3835 3836
  const char* errmsg=0;
  THD* thd = rli->sql_thd;
3837
  
unknown's avatar
unknown committed
3838
  DBUG_ENTER("next_event");
3839 3840
  DBUG_ASSERT(thd != 0);

unknown's avatar
unknown committed
3841 3842
  /*
    For most operations we need to protect rli members with data_lock,
3843 3844 3845 3846
    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
unknown's avatar
unknown committed
3847
  */
3848
  safe_mutex_assert_owner(&rli->data_lock);
3849
  
3850
  while (!sql_slave_killed(thd,rli))
unknown's avatar
unknown committed
3851 3852 3853
  {
    /*
      We can have two kinds of log reading:
unknown's avatar
unknown committed
3854 3855 3856 3857 3858 3859 3860 3861
      hot_log:
        rli->cur_log points at the IO_CACHE of relay_log, which
        is actively being updated by the I/O thread. We need to be careful
        in this case and make sure that we are not looking at a stale log that
        has already been rotated. If it has been, we reopen the log.

      The other case is much simpler:
        We just have a read only log that nobody else will be updating.
unknown's avatar
unknown committed
3862
    */
3863 3864 3865 3866 3867
    bool hot_log;
    if ((hot_log = (cur_log != &rli->cache_buf)))
    {
      DBUG_ASSERT(rli->cur_log_fd == -1); // foreign descriptor
      pthread_mutex_lock(log_lock);
unknown's avatar
unknown committed
3868 3869

      /*
unknown's avatar
unknown committed
3870
	Reading xxx_file_id is safe because the log will only
unknown's avatar
unknown committed
3871 3872
	be rotated when we hold relay_log.LOCK_log
      */
unknown's avatar
unknown committed
3873
      if (rli->relay_log.get_open_count() != rli->cur_log_old_open_count)
3874
      {
unknown's avatar
unknown committed
3875 3876 3877 3878
	// 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);
	if (!cur_log)				// No more log files
3879
	  goto err;
unknown's avatar
unknown committed
3880
	hot_log=0;				// Using old binary log
3881 3882
      }
    }
3883 3884 3885
#ifndef DBUG_OFF
    {
      char llbuf1[22], llbuf2[22];
unknown's avatar
unknown committed
3886 3887 3888 3889 3890 3891
      DBUG_ASSERT(my_b_tell(cur_log) >= BIN_LOG_HEADER_SIZE);
      /*
	The next assertion sometimes (very rarely) fails, let's try to track
	it
      */
      DBUG_PRINT("info", ("\
unknown's avatar
unknown committed
3892
Before assert, my_b_tell(cur_log)=%s  rli->event_relay_log_pos=%s",
3893
                          llstr(my_b_tell(cur_log),llbuf1), 
unknown's avatar
unknown committed
3894
                          llstr(rli->group_relay_log_pos,llbuf2)));
unknown's avatar
unknown committed
3895
       DBUG_ASSERT(my_b_tell(cur_log) == rli->event_relay_log_pos);
3896 3897
    }
#endif
unknown's avatar
unknown committed
3898 3899 3900
    /*
      Relay log is always in new format - if the master is 3.23, the
      I/O thread will convert the format for us
unknown's avatar
unknown committed
3901
    */
unknown's avatar
unknown committed
3902
    if ((ev=Log_event::read_log_event(cur_log,0,(bool)0 /* new format */)))
3903 3904 3905 3906
    {
      DBUG_ASSERT(thd==rli->sql_thd);
      if (hot_log)
	pthread_mutex_unlock(log_lock);
unknown's avatar
unknown committed
3907
      DBUG_RETURN(ev);
3908 3909
    }
    DBUG_ASSERT(thd==rli->sql_thd);
unknown's avatar
unknown committed
3910
    if (opt_reckless_slave)			// For mysql-test
unknown's avatar
unknown committed
3911
      cur_log->error = 0;
unknown's avatar
unknown committed
3912
    if (cur_log->error < 0)
unknown's avatar
unknown committed
3913 3914
    {
      errmsg = "slave SQL thread aborted because of I/O error";
unknown's avatar
unknown committed
3915 3916
      if (hot_log)
	pthread_mutex_unlock(log_lock);
unknown's avatar
unknown committed
3917 3918
      goto err;
    }
3919 3920
    if (!cur_log->error) /* EOF */
    {
unknown's avatar
unknown committed
3921 3922 3923 3924 3925
      /*
	On a hot log, EOF means that there are no more updates to
	process and we must block until I/O thread adds some and
	signals us to continue
      */
3926 3927
      if (hot_log)
      {
unknown's avatar
unknown committed
3928
	DBUG_ASSERT(rli->relay_log.get_open_count() == rli->cur_log_old_open_count);
unknown's avatar
unknown committed
3929 3930 3931 3932
	/*
	  We can, and should release data_lock while we are waiting for
	  update. If we do not, show slave status will block
	*/
3933
	pthread_mutex_unlock(&rli->data_lock);
3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955

        /*
          Possible deadlock : 
          - the I/O thread has reached log_space_limit
          - the SQL thread has read all relay logs, but cannot purge for some
          reason:
            * it has already purged all logs except the current one
            * there are other logs than the current one but they're involved in
            a transaction that finishes in the current one (or is not finished)
          Solution :
          Wake up the possibly waiting I/O thread, and set a boolean asking
          the I/O thread to temporarily ignore the log_space_limit
          constraint, because we do not want the I/O thread to block because of
          space (it's ok if it blocks for any other reason (e.g. because the
          master does not send anything). Then the I/O thread stops waiting 
          and reads more events.
          The SQL thread decides when the I/O thread should take log_space_limit
          into account again : ignore_log_space_limit is reset to 0 
          in purge_first_log (when the SQL thread purges the just-read relay
          log), and also when the SQL thread starts. We should also reset
          ignore_log_space_limit to 0 when the user does RESET SLAVE, but in
          fact, no need as RESET SLAVE requires that the slave
unknown's avatar
unknown committed
3956 3957
          be stopped, and the SQL thread sets ignore_log_space_limit to 0 when
          it stops.
3958 3959 3960 3961
        */
        pthread_mutex_lock(&rli->log_space_lock);
        // prevent the I/O thread from blocking next times
        rli->ignore_log_space_limit= 1; 
3962 3963 3964 3965 3966 3967
        /*
          If the I/O thread is blocked, unblock it.
          Ok to broadcast after unlock, because the mutex is only destroyed in
          ~st_relay_log_info(), i.e. when rli is destroyed, and rli will not be
          destroyed before we exit the present function.
        */
3968
        pthread_mutex_unlock(&rli->log_space_lock);
3969
        pthread_cond_broadcast(&rli->log_space_cond);
3970
        // Note that wait_for_update unlocks lock_log !
3971
        rli->relay_log.wait_for_update(rli->sql_thd, 1);
3972 3973
        // re-acquire data lock since we released it earlier
        pthread_mutex_lock(&rli->data_lock);
3974 3975
	continue;
      }
unknown's avatar
unknown committed
3976 3977 3978 3979 3980 3981 3982 3983 3984 3985
      /*
	If the log was not hot, we need to move to the next log in
	sequence. The next log could be hot or cold, we deal with both
	cases separately after doing some common initialization
      */
      end_io_cache(cur_log);
      DBUG_ASSERT(rli->cur_log_fd >= 0);
      my_close(rli->cur_log_fd, MYF(MY_WME));
      rli->cur_log_fd = -1;
	
3986
      if (relay_log_purge)
unknown's avatar
unknown committed
3987
      {
3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002
	/*
          purge_first_log will properly set up relay log coordinates in rli.
          If the group's coordinates are equal to the event's coordinates
          (i.e. the relay log was not rotated in the middle of a group),
          we can purge this relay log too.
          We do ulonglong and string comparisons, this may be slow but
          - purging the last relay log is nice (it can save 1GB of disk), so we
          like to detect the case where we can do it, and given this,
          - I see no better detection method
          - purge_first_log is not called that often
        */
	if (rli->relay_log.purge_first_log
            (rli,
             rli->group_relay_log_pos == rli->event_relay_log_pos
             && !strcmp(rli->group_relay_log_name,rli->event_relay_log_name)))
unknown's avatar
unknown committed
4003
	{
4004
	  errmsg = "Error purging processed logs";
unknown's avatar
unknown committed
4005 4006 4007
	  goto err;
	}
      }
4008 4009
      else
      {
unknown's avatar
unknown committed
4010
	/*
4011 4012 4013 4014 4015
	  If hot_log is set, then we already have a lock on
	  LOCK_log.  If not, we have to get the lock.

	  According to Sasha, the only time this code will ever be executed
	  is if we are recovering from a bug.
unknown's avatar
unknown committed
4016
	*/
4017
	if (rli->relay_log.find_next_log(&rli->linfo, !hot_log))
4018
	{
unknown's avatar
unknown committed
4019 4020
	  errmsg = "error switching to the next log";
	  goto err;
4021
	}
4022 4023 4024
	rli->event_relay_log_pos = BIN_LOG_HEADER_SIZE;
	strmake(rli->event_relay_log_name,rli->linfo.log_file_name,
		sizeof(rli->event_relay_log_name)-1);
unknown's avatar
unknown committed
4025 4026
	flush_relay_log_info(rli);
      }
4027
	
unknown's avatar
unknown committed
4028 4029 4030
      // next log is hot 
      if (rli->relay_log.is_active(rli->linfo.log_file_name))
      {
4031
#ifdef EXTRA_DEBUG
unknown's avatar
unknown committed
4032 4033
	sql_print_error("next log '%s' is currently active",
			rli->linfo.log_file_name);
4034
#endif	  
unknown's avatar
unknown committed
4035 4036 4037
	rli->cur_log= cur_log= rli->relay_log.get_log_file();
	rli->cur_log_old_open_count= rli->relay_log.get_open_count();
	DBUG_ASSERT(rli->cur_log_fd == -1);
4038
	  
unknown's avatar
unknown committed
4039
	/*
unknown's avatar
unknown committed
4040 4041
	  Read pointer has to be at the start since we are the only
	  reader
unknown's avatar
unknown committed
4042
	*/
unknown's avatar
unknown committed
4043
	if (check_binlog_magic(cur_log,&errmsg))
4044
	  goto err;
unknown's avatar
unknown committed
4045
	continue;
4046
      }
unknown's avatar
unknown committed
4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058
      /*
	if we get here, the log was not hot, so we will have to
	open it ourselves
      */
#ifdef EXTRA_DEBUG
      sql_print_error("next log '%s' is not active",
		      rli->linfo.log_file_name);
#endif	  
      // open_binlog() will check the magic header
      if ((rli->cur_log_fd=open_binlog(cur_log,rli->linfo.log_file_name,
				       &errmsg)) <0)
	goto err;
4059
    }
unknown's avatar
unknown committed
4060
    else
4061
    {
unknown's avatar
unknown committed
4062 4063 4064 4065 4066 4067
      /*
	Read failed with a non-EOF error.
	TODO: come up with something better to handle this error
      */
      if (hot_log)
	pthread_mutex_unlock(log_lock);
4068
      sql_print_error("Slave SQL thread: I/O error reading \
unknown's avatar
unknown committed
4069
event(errno: %d  cur_log->error: %d)",
4070
		      my_errno,cur_log->error);
unknown's avatar
unknown committed
4071
      // set read position to the beginning of the event
4072
      my_b_seek(cur_log,rli->event_relay_log_pos);
unknown's avatar
unknown committed
4073 4074
      /* otherwise, we have had a partial read */
      errmsg = "Aborting slave SQL thread because of partial event read";
4075
      break;					// To end of function
4076 4077
    }
  }
4078
  if (!errmsg && global_system_variables.log_warnings)
4079
    errmsg = "slave SQL thread was killed";
unknown's avatar
unknown committed
4080

4081
err:
4082 4083
  if (errmsg)
    sql_print_error("Error reading relay log event: %s", errmsg);
unknown's avatar
unknown committed
4084
  DBUG_RETURN(0);
4085 4086
}

4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097
/*
  Rotate a relay log (this is used only by FLUSH LOGS; the automatic rotation
  because of size is simpler because when we do it we already have all relevant
  locks; here we don't, so this function is mainly taking locks). 
  Returns nothing as we cannot catch any error (MYSQL_LOG::new_file() is void).
*/

void rotate_relay_log(MASTER_INFO* mi)
{
  DBUG_ENTER("rotate_relay_log");
  RELAY_LOG_INFO* rli= &mi->rli;
unknown's avatar
unknown committed
4098 4099 4100 4101 4102 4103 4104

  lock_slave_threads(mi);
  pthread_mutex_lock(&rli->data_lock);
  /* 
     We need to test inited because otherwise, new_file() will attempt to lock
     LOCK_log, which may not be inited (if we're not a slave).
  */
4105 4106
  if (!rli->inited)
  {
unknown's avatar
unknown committed
4107
    DBUG_PRINT("info", ("rli->inited == 0"));
unknown's avatar
unknown committed
4108
    goto end;
4109
  }
unknown's avatar
unknown committed
4110

4111 4112
  /* If the relay log is closed, new_file() will do nothing. */
  rli->relay_log.new_file(1);
unknown's avatar
unknown committed
4113

4114 4115 4116 4117
  /*
    We harvest now, because otherwise BIN_LOG_HEADER_SIZE will not immediately
    be counted, so imagine a succession of FLUSH LOGS  and assume the slave
    threads are started:
unknown's avatar
unknown committed
4118 4119 4120 4121 4122 4123
    relay_log_space decreases by the size of the deleted relay log, but does
    not increase, so flush-after-flush we may become negative, which is wrong.
    Even if this will be corrected as soon as a query is replicated on the
    slave (because the I/O thread will then call harvest_bytes_written() which
    will harvest all these BIN_LOG_HEADER_SIZE we forgot), it may give strange
    output in SHOW SLAVE STATUS meanwhile. So we harvest now.
4124 4125 4126 4127
    If the log is closed, then this will just harvest the last writes, probably
    0 as they probably have been harvested.
  */
  rli->relay_log.harvest_bytes_written(&rli->log_space_total);
unknown's avatar
unknown committed
4128
end:
4129 4130 4131 4132 4133
  pthread_mutex_unlock(&rli->data_lock);
  unlock_slave_threads(mi);
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
4134

unknown's avatar
unknown committed
4135 4136
#ifdef __GNUC__
template class I_List_iterator<i_string>;
unknown's avatar
unknown committed
4137
template class I_List_iterator<i_string_pair>;
unknown's avatar
unknown committed
4138
#endif
4139

unknown's avatar
SCRUM  
unknown committed
4140
#endif /* HAVE_REPLICATION */