sql_repl.cc 51.6 KB
Newer Older
1
/* Copyright (C) 2000-2006 MySQL AB & Sasha
2 3 4

   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
5
   the Free Software Foundation; version 2 of the License.
6 7 8 9 10 11 12 13 14 15 16

   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"
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
17 18
#ifdef HAVE_REPLICATION

19
#include "rpl_mi.h"
20 21
#include "sql_repl.h"
#include "log_event.h"
lars@mysql.com's avatar
lars@mysql.com committed
22
#include "rpl_filter.h"
23
#include <my_dir.h>
24

25
int max_binlog_dump_events = 0; // unlimited
26
my_bool opt_sporadic_binlog_dump_fail = 0;
27
#ifndef DBUG_OFF
28
static int binlog_dump_count = 0;
29
#endif
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
30

31
/*
32 33 34 35
    fake_rotate_event() builds a fake (=which does not exist physically in any
    binlog) Rotate event, which contains the name of the binlog we are going to
    send to the slave (because the slave may not know it if it just asked for
    MASTER_LOG_FILE='', MASTER_LOG_POS=4).
36 37
    < 4.0.14, fake_rotate_event() was called only if the requested pos was 4.
    After this version we always call it, so that a 3.23.58 slave can rely on
38 39 40 41 42
    it to detect if the master is 4.0 (and stop) (the _fake_ Rotate event has
    zeros in the good positions which, by chance, make it possible for the 3.23
    slave to detect that this event is unexpected) (this is luck which happens
    because the master and slave disagree on the size of the header of
    Log_event).
43 44 45 46

    Relying on the event length of the Rotate event instead of these
    well-placed zeros was not possible as Rotate events have a variable-length
    part.
47 48
*/

49
static int fake_rotate_event(NET* net, String* packet, char* log_file_name,
50
                             ulonglong position, const char** errmsg)
51
{
52
  DBUG_ENTER("fake_rotate_event");
53 54 55 56 57 58
  char header[LOG_EVENT_HEADER_LEN], buf[ROTATE_HEADER_LEN+100];
  /*
    'when' (the timestamp) is set to 0 so that slave could distinguish between
    real and fake Rotate events (if necessary)
  */
  memset(header, 0, 4);
59 60
  header[EVENT_TYPE_OFFSET] = ROTATE_EVENT;

61
  char* p = log_file_name+dirname_length(log_file_name);
62
  uint ident_len = (uint) strlen(p);
63
  ulong event_len = ident_len + LOG_EVENT_HEADER_LEN + ROTATE_HEADER_LEN;
64
  int4store(header + SERVER_ID_OFFSET, server_id);
65
  int4store(header + EVENT_LEN_OFFSET, event_len);
66
  int2store(header + FLAGS_OFFSET, 0);
67

68 69
  // TODO: check what problems this may cause and fix them
  int4store(header + LOG_POS_OFFSET, 0);
70

71
  packet->append(header, sizeof(header));
72
  int8store(buf+R_POS_OFFSET,position);
73
  packet->append(buf, ROTATE_HEADER_LEN);
74
  packet->append(p,ident_len);
75
  if (my_net_write(net, (uchar*) packet->ptr(), packet->length()))
76 77
  {
    *errmsg = "failed on my_net_write()";
78
    DBUG_RETURN(-1);
79
  }
80
  DBUG_RETURN(0);
81 82
}

83 84 85
static int send_file(THD *thd)
{
  NET* net = &thd->net;
86 87
  int fd = -1, error = 1;
  size_t bytes;
88 89
  char fname[FN_REFLEN+1];
  const char *errmsg = 0;
90
  int old_timeout;
ndbdev@dl145b.mysql.com's avatar
ndbdev@dl145b.mysql.com committed
91
  unsigned long packet_len;
92
  uchar buf[IO_SIZE];				// It's safe to alloc this
93 94
  DBUG_ENTER("send_file");

95 96 97 98
  /*
    The client might be slow loading the data, give him wait_timeout to do
    the job
  */
99
  old_timeout= net->read_timeout;
100
  my_net_set_read_timeout(net, thd->variables.net_wait_timeout);
101 102 103 104 105

  /*
    We need net_flush here because the client will not know it needs to send
    us the file name until it has processed the load event entry
  */
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
106
  if (net_flush(net) || (packet_len = my_net_read(net)) == packet_error)
107
  {
108
    errmsg = "while reading file name";
109 110 111
    goto err;
  }

112 113 114
  // terminate with \0 for fn_format
  *((char*)net->read_pos +  packet_len) = 0;
  fn_format(fname, (char*) net->read_pos + 1, "", "", 4);
115 116 117 118
  // this is needed to make replicate-ignore-db
  if (!strcmp(fname,"/dev/null"))
    goto end;

119
  if ((fd = my_open(fname, O_RDONLY, MYF(0))) < 0)
120
  {
121
    errmsg = "on open of file";
122 123 124
    goto err;
  }

125
  while ((long) (bytes= my_read(fd, buf, IO_SIZE, MYF(0))) > 0)
126 127 128
  {
    if (my_net_write(net, buf, bytes))
    {
129
      errmsg = "while writing data to client";
130 131 132 133 134
      goto err;
    }
  }

 end:
135
  if (my_net_write(net, (uchar*) "", 0) || net_flush(net) ||
136 137
      (my_net_read(net) == packet_error))
  {
138
    errmsg = "while negotiating file transfer close";
139 140 141 142 143
    goto err;
  }
  error = 0;

 err:
144
  my_net_set_read_timeout(net, old_timeout);
145 146
  if (fd >= 0)
    (void) my_close(fd, MYF(0));
147 148
  if (errmsg)
  {
149
    sql_print_error("Failed in send_file() %s", errmsg);
150 151 152 153 154
    DBUG_PRINT("error", (errmsg));
  }
  DBUG_RETURN(error);
}

155

156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
/*
  Adjust the position pointer in the binary log file for all running slaves

  SYNOPSIS
    adjust_linfo_offsets()
    purge_offset	Number of bytes removed from start of log index file

  NOTES
    - This is called when doing a PURGE when we delete lines from the
      index log file

  REQUIREMENTS
    - Before calling this function, we have to ensure that no threads are
      using any binary log file before purge_offset.a

  TODO
    - Inform the slave threads that they should sync the position
      in the binary log file with flush_relay_log_info.
      Now they sync is done for next read.
*/

177 178 179
void adjust_linfo_offsets(my_off_t purge_offset)
{
  THD *tmp;
180

181 182 183
  pthread_mutex_lock(&LOCK_thread_count);
  I_List_iterator<THD> it(threads);

184 185 186 187 188 189
  while ((tmp=it++))
  {
    LOG_INFO* linfo;
    if ((linfo = tmp->current_linfo))
    {
      pthread_mutex_lock(&linfo->lock);
190 191 192 193
      /*
	Index file offset can be less that purge offset only if
	we just started reading the index file. In that case
	we have nothing to adjust
194
      */
195 196 197 198 199 200 201
      if (linfo->index_file_offset < purge_offset)
	linfo->fatal = (linfo->index_file_offset != 0);
      else
	linfo->index_file_offset -= purge_offset;
      pthread_mutex_unlock(&linfo->lock);
    }
  }
202 203 204
  pthread_mutex_unlock(&LOCK_thread_count);
}

monty@narttu.mysql.fi's avatar
merge  
monty@narttu.mysql.fi committed
205

206 207 208 209 210
bool log_in_use(const char* log_name)
{
  int log_name_len = strlen(log_name) + 1;
  THD *tmp;
  bool result = 0;
211

212 213
  pthread_mutex_lock(&LOCK_thread_count);
  I_List_iterator<THD> it(threads);
214 215 216 217 218

  while ((tmp=it++))
  {
    LOG_INFO* linfo;
    if ((linfo = tmp->current_linfo))
219
    {
220
      pthread_mutex_lock(&linfo->lock);
221 222
      result = !bcmp((uchar*) log_name, (uchar*) linfo->log_file_name,
                     log_name_len);
223
      pthread_mutex_unlock(&linfo->lock);
224 225
      if (result)
	break;
226 227
    }
  }
228 229 230 231 232

  pthread_mutex_unlock(&LOCK_thread_count);
  return result;
}

233
bool purge_error_message(THD* thd, int res)
234
{
235
  uint errmsg= 0;
236

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
237
  switch (res)  {
238
  case 0: break;
239 240 241 242 243 244 245
  case LOG_INFO_EOF:	errmsg= ER_UNKNOWN_TARGET_BINLOG; break;
  case LOG_INFO_IO:	errmsg= ER_IO_ERR_LOG_INDEX_READ; break;
  case LOG_INFO_INVALID:errmsg= ER_BINLOG_PURGE_PROHIBITED; break;
  case LOG_INFO_SEEK:	errmsg= ER_FSEEK_FAIL; break;
  case LOG_INFO_MEM:	errmsg= ER_OUT_OF_RESOURCES; break;
  case LOG_INFO_FATAL:	errmsg= ER_BINLOG_PURGE_FATAL_ERR; break;
  case LOG_INFO_IN_USE: errmsg= ER_LOG_IN_USE; break;
246
  case LOG_INFO_EMFILE: errmsg= ER_BINLOG_PURGE_EMFILE; break;
247
  default:		errmsg= ER_LOG_PURGE_UNKNOWN_ERR; break;
248 249 250 251
  }

  if (errmsg)
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
252
    my_message(errmsg, ER(errmsg), MYF(0));
253
    return TRUE;
254
  }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
255
  send_ok(thd);
256
  return FALSE;
257 258
}

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
259

260
bool purge_master_logs(THD* thd, const char* to_log)
261 262
{
  char search_file_name[FN_REFLEN];
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
263 264
  if (!mysql_bin_log.is_open())
  {
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
265
    send_ok(thd);
266
    return FALSE;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
267
  }
268 269

  mysql_bin_log.make_log_name(search_file_name, to_log);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
270 271
  return purge_error_message(thd,
			     mysql_bin_log.purge_logs(search_file_name, 0, 1,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
272
						      1, NULL));
273 274 275
}


276
bool purge_master_logs_before_date(THD* thd, time_t purge_time)
277
{
278 279
  if (!mysql_bin_log.is_open())
  {
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
280
    send_ok(thd);
281 282 283 284
    return 0;
  }
  return purge_error_message(thd,
                             mysql_bin_log.purge_logs_before_date(purge_time));
285 286
}

287
int test_for_non_eof_log_read_errors(int error, const char **errmsg)
288
{
289
  if (error == LOG_READ_EOF)
290 291 292 293
    return 0;
  my_errno= ER_MASTER_FATAL_ERROR_READING_BINLOG;
  switch (error) {
  case LOG_READ_BOGUS:
294
    *errmsg = "bogus data in log event";
295 296
    break;
  case LOG_READ_TOO_LARGE:
297
    *errmsg = "log event entry exceeded max_allowed_packet; \
298 299 300
Increase max_allowed_packet on master";
    break;
  case LOG_READ_IO:
301
    *errmsg = "I/O error reading log event";
302 303
    break;
  case LOG_READ_MEM:
304
    *errmsg = "memory allocation failed reading log event";
305 306
    break;
  case LOG_READ_TRUNC:
307
    *errmsg = "binlog truncated in the middle of event";
308 309
    break;
  default:
310
    *errmsg = "unknown error reading log event on the master";
311 312 313 314 315 316
    break;
  }
  return error;
}


317 318 319
/*
  TODO: Clean up loop to only have one call to send_file()
*/
monty@narttu.mysql.fi's avatar
merge  
monty@narttu.mysql.fi committed
320

321 322
void mysql_binlog_send(THD* thd, char* log_ident, my_off_t pos,
		       ushort flags)
323 324 325
{
  LOG_INFO linfo;
  char *log_file_name = linfo.log_file_name;
326
  char search_file_name[FN_REFLEN], *name;
327 328
  IO_CACHE log;
  File file = -1;
329 330 331 332
  String* packet = &thd->packet;
  int error;
  const char *errmsg = "Unknown error";
  NET* net = &thd->net;
333
  pthread_mutex_t *log_lock;
334
  bool binlog_can_be_corrupted= FALSE;
335 336
#ifndef DBUG_OFF
  int left_events = max_binlog_dump_events;
337
#endif
338
  DBUG_ENTER("mysql_binlog_send");
339 340
  DBUG_PRINT("enter",("log_ident: '%s'  pos: %ld", log_ident, (long) pos));

341
  bzero((char*) &log,sizeof(log));
342

sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
343
#ifndef DBUG_OFF
344 345 346
  if (opt_sporadic_binlog_dump_fail && (binlog_dump_count++ % 2))
  {
    errmsg = "Master failed COM_BINLOG_DUMP to test if slave can recover";
347
    my_errno= ER_UNKNOWN_ERROR;
348 349
    goto err;
  }
350
#endif
351

352
  if (!mysql_bin_log.is_open())
353 354
  {
    errmsg = "Binary log is not open";
355
    my_errno= ER_MASTER_FATAL_ERROR_READING_BINLOG;
356 357
    goto err;
  }
358 359 360
  if (!server_id_supplied)
  {
    errmsg = "Misconfigured master - server id was not set";
361
    my_errno= ER_MASTER_FATAL_ERROR_READING_BINLOG;
362 363 364
    goto err;
  }

365
  name=search_file_name;
366
  if (log_ident[0])
367 368
    mysql_bin_log.make_log_name(search_file_name, log_ident);
  else
369
    name=0;					// Find first log
370

371
  linfo.index_file_offset = 0;
372

373
  if (mysql_bin_log.find_log_pos(&linfo, name, 1))
374
  {
375
    errmsg = "Could not find first log file name in binary log index file";
376
    my_errno= ER_MASTER_FATAL_ERROR_READING_BINLOG;
377 378
    goto err;
  }
379

380 381 382 383
  pthread_mutex_lock(&LOCK_thread_count);
  thd->current_linfo = &linfo;
  pthread_mutex_unlock(&LOCK_thread_count);

384
  if ((file=open_binlog(&log, log_file_name, &errmsg)) < 0)
385 386
  {
    my_errno= ER_MASTER_FATAL_ERROR_READING_BINLOG;
387
    goto err;
388 389
  }
  if (pos < BIN_LOG_HEADER_SIZE || pos > my_b_filelength(&log))
390
  {
391
    errmsg= "Client requested master to start replication from \
392
impossible position";
393
    my_errno= ER_MASTER_FATAL_ERROR_READING_BINLOG;
394 395
    goto err;
  }
396

397 398
  /*
    We need to start a packet with something other than 255
399
    to distinguish it from error
400
  */
401
  packet->set("\0", 1, &my_charset_bin); /* This is the start of a new packet */
402

403
  /*
404
    Tell the client about the log name with a fake Rotate event;
405 406 407 408 409 410 411 412 413
    this is needed even if we also send a Format_description_log_event
    just after, because that event does not contain the binlog's name.
    Note that as this Rotate event is sent before
    Format_description_log_event, the slave cannot have any info to
    understand this event's format, so the header len of
    Rotate_log_event is FROZEN (so in 5.0 it will have a header shorter
    than other events except FORMAT_DESCRIPTION_EVENT).
    Before 4.0.14 we called fake_rotate_event below only if (pos ==
    BIN_LOG_HEADER_SIZE), because if this is false then the slave
414
    already knows the binlog's name.
415 416 417 418 419 420 421
    Since, we always call fake_rotate_event; if the slave already knew
    the log's name (ex: CHANGE MASTER TO MASTER_LOG_FILE=...) this is
    useless but does not harm much. It is nice for 3.23 (>=.58) slaves
    which test Rotate events to see if the master is 4.0 (then they
    choose to stop because they can't replicate 4.0); by always calling
    fake_rotate_event we are sure that 3.23.58 and newer will detect the
    problem as soon as replication starts (BUG#198).
422
    Always calling fake_rotate_event makes sending of normal
423 424 425 426 427 428 429
    (=from-binlog) Rotate events a priori unneeded, but it is not so
    simple: the 2 Rotate events are not equivalent, the normal one is
    before the Stop event, the fake one is after. If we don't send the
    normal one, then the Stop event will be interpreted (by existing 4.0
    slaves) as "the master stopped", which is wrong. So for safety,
    given that we want minimum modification of 4.0, we send the normal
    and fake Rotates.
430
  */
431
  if (fake_rotate_event(net, packet, log_file_name, pos, &errmsg))
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
432
  {
433 434 435 436
    /*
       This error code is not perfect, as fake_rotate_event() does not
       read anything from the binlog; if it fails it's because of an
       error in my_net_write(), fortunately it will say so in errmsg.
437
    */
438 439
    my_errno= ER_MASTER_FATAL_ERROR_READING_BINLOG;
    goto err;
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
440
  }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
441
  packet->set("\0", 1, &my_charset_bin);
442 443 444 445 446
  /*
    Adding MAX_LOG_EVENT_HEADER_LEN, since a binlog event can become
    this larger than the corresponding packet (query) sent 
    from client to master.
  */
447
  thd->variables.max_allowed_packet+= MAX_LOG_EVENT_HEADER;
448

449
  /*
450 451 452
    We can set log_lock now, it does not move (it's a member of
    mysql_bin_log, and it's already inited, and it will be destroyed
    only at shutdown).
453
  */
454
  log_lock = mysql_bin_log.get_log_lock();
455
  if (pos > BIN_LOG_HEADER_SIZE)
456 457 458 459 460
  {
     /*
       Try to find a Format_description_log_event at the beginning of
       the binlog
     */
461 462 463
     if (!(error = Log_event::read_log_event(&log, packet, log_lock)))
     {
       /*
464 465
         The packet has offsets equal to the normal offsets in a binlog
         event +1 (the first character is \0).
466 467 468 469 470 471
       */
       DBUG_PRINT("info",
                  ("Looked for a Format_description_log_event, found event type %d",
                   (*packet)[EVENT_TYPE_OFFSET+1]));
       if ((*packet)[EVENT_TYPE_OFFSET+1] == FORMAT_DESCRIPTION_EVENT)
       {
472 473
         binlog_can_be_corrupted= test((*packet)[FLAGS_OFFSET+1] &
                                       LOG_EVENT_BINLOG_IN_USE_F);
serg@serg.mylan's avatar
serg@serg.mylan committed
474
         (*packet)[FLAGS_OFFSET+1] &= ~LOG_EVENT_BINLOG_IN_USE_F;
475 476 477 478 479
         /*
           mark that this event with "log_pos=0", so the slave
           should not increment master's binlog position
           (rli->group_master_log_pos)
         */
480
         int4store((char*) packet->ptr()+LOG_POS_OFFSET+1, 0);
481 482 483 484 485 486
         /*
           if reconnect master sends FD event with `created' as 0
           to avoid destroying temp tables.
          */
         int4store((char*) packet->ptr()+LOG_EVENT_MINIMAL_HEADER_LEN+
                   ST_CREATED_OFFSET+1, (ulong) 0);
487
         /* send it */
488
         if (my_net_write(net, (uchar*) packet->ptr(), packet->length()))
489 490 491 492 493
         {
           errmsg = "Failed on my_net_write()";
           my_errno= ER_UNKNOWN_ERROR;
           goto err;
         }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
494

495
         /*
496 497 498 499
           No need to save this event. We are only doing simple reads
           (no real parsing of the events) so we don't need it. And so
           we don't need the artificial Format_description_log_event of
           3.23&4.x.
500 501 502 503
         */
       }
     }
     else
504
     {
505
       if (test_for_non_eof_log_read_errors(error, &errmsg))
506
         goto err;
507 508 509 510 511
       /*
         It's EOF, nothing to do, go on reading next events, the
         Format_description_log_event will be found naturally if it is written.
       */
     }
512 513
     /* reset the packet as we wrote to it in any case */
     packet->set("\0", 1, &my_charset_bin);
514 515 516 517 518
  } /* end of if (pos > BIN_LOG_HEADER_SIZE); */
  else
  {
    /* The Format_description_log_event event will be found naturally. */
  }
519

520 521 522
  /* seek to the requested position, to start the requested dump */
  my_b_seek(&log, pos);			// Seek will done on next read

monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
523
  while (!net->error && net->vio != 0 && !thd->killed)
524 525 526
  {
    while (!(error = Log_event::read_log_event(&log, packet, log_lock)))
    {
527
#ifndef DBUG_OFF
528
      if (max_binlog_dump_events && !left_events--)
529 530 531
      {
	net_flush(net);
	errmsg = "Debugging binlog dump abort";
532
	my_errno= ER_UNKNOWN_ERROR;
533 534
	goto err;
      }
535
#endif
536 537

      if ((*packet)[EVENT_TYPE_OFFSET+1] == FORMAT_DESCRIPTION_EVENT)
serg@serg.mylan's avatar
serg@serg.mylan committed
538
      {
539 540
        binlog_can_be_corrupted= test((*packet)[FLAGS_OFFSET+1] &
                                      LOG_EVENT_BINLOG_IN_USE_F);
serg@serg.mylan's avatar
serg@serg.mylan committed
541 542
        (*packet)[FLAGS_OFFSET+1] &= ~LOG_EVENT_BINLOG_IN_USE_F;
      }
543 544 545
      else if ((*packet)[EVENT_TYPE_OFFSET+1] == STOP_EVENT)
        binlog_can_be_corrupted= FALSE;

546
      if (my_net_write(net, (uchar*) packet->ptr(), packet->length()))
547 548
      {
	errmsg = "Failed on my_net_write()";
549
	my_errno= ER_UNKNOWN_ERROR;
550 551
	goto err;
      }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
552

553 554
      DBUG_PRINT("info", ("log event code %d",
			  (*packet)[LOG_EVENT_OFFSET+1] ));
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
555
      if ((*packet)[LOG_EVENT_OFFSET+1] == LOAD_EVENT)
556
      {
557
	if (send_file(thd))
558
	{
559
	  errmsg = "failed in send_file()";
560
	  my_errno= ER_UNKNOWN_ERROR;
561 562
	  goto err;
	}
563
      }
564
      packet->set("\0", 1, &my_charset_bin);
565
    }
566 567 568 569 570 571 572

    /*
      here we were reading binlog that was not closed properly (as a result
      of a crash ?). treat any corruption as EOF
    */
    if (binlog_can_be_corrupted && error != LOG_READ_MEM)
      error=LOG_READ_EOF;
573 574
    /*
      TODO: now that we are logging the offset, check to make sure
575
      the recorded offset and the actual match.
576 577 578
      Guilhem 2003-06: this is not true if this master is a slave
      <4.0.15 running with --log-slave-updates, because then log_pos may
      be the offset in the-master-of-this-master's binlog.
579
    */
580
    if (test_for_non_eof_log_read_errors(error, &errmsg))
581
      goto err;
582

583
    if (!(flags & BINLOG_DUMP_NON_BLOCK) &&
584
        mysql_bin_log.is_active(log_file_name))
585
    {
586 587 588
      /*
	Block until there is more data in the log
      */
589
      if (net_flush(net))
590 591
      {
	errmsg = "failed on net_flush()";
592
	my_errno= ER_UNKNOWN_ERROR;
593 594
	goto err;
      }
595

596 597 598 599 600 601
      /*
	We may have missed the update broadcast from the log
	that has just happened, let's try to catch it if it did.
	If we did not miss anything, we just wait for other threads
	to signal us.
      */
602 603 604 605
      {
	log.error=0;
	bool read_packet = 0, fatal_error = 0;

606
#ifndef DBUG_OFF
607
	if (max_binlog_dump_events && !left_events--)
608 609
	{
	  errmsg = "Debugging binlog dump abort";
610
	  my_errno= ER_UNKNOWN_ERROR;
611 612
	  goto err;
	}
613
#endif
614

615 616 617 618
	/*
	  No one will update the log while we are reading
	  now, but we'll be quick and just read one record

619
	  TODO:
620 621 622
          Add an counter that is incremented for each time we update the
          binary log.  We can avoid the following read if the counter
          has not been updated since last read.
623
	*/
624

monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
625
	pthread_mutex_lock(log_lock);
626
	switch (Log_event::read_log_event(&log, packet, (pthread_mutex_t*)0)) {
627
	case 0:
628
	  /* we read successfully, so we'll need to send it to the slave */
629
	  pthread_mutex_unlock(log_lock);
630 631
	  read_packet = 1;
	  break;
632

633
	case LOG_READ_EOF:
634
	  DBUG_PRINT("wait",("waiting for data in binary log"));
635
	  if (thd->server_id==0) // for mysqlbinlog (mysqlbinlog.server_id==0)
vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
636 637 638 639
	  {
	    pthread_mutex_unlock(log_lock);
	    goto end;
	  }
640
	  if (!thd->killed)
641 642
	  {
	    /* Note that the following call unlocks lock_log */
643
	    mysql_bin_log.wait_for_update(thd, 0);
644 645 646
	  }
	  else
	    pthread_mutex_unlock(log_lock);
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
647
	  DBUG_PRINT("wait",("binary log received update"));
648 649 650
	  break;

	default:
651
	  pthread_mutex_unlock(log_lock);
652 653
	  fatal_error = 1;
	  break;
654
	}
655

656
	if (read_packet)
657
	{
658
	  thd->proc_info = "Sending binlog event to slave";
659
	  if (my_net_write(net, (uchar*) packet->ptr(), packet->length()) )
660 661
	  {
	    errmsg = "Failed on my_net_write()";
662
	    my_errno= ER_UNKNOWN_ERROR;
663 664
	    goto err;
	  }
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
665

666
	  if ((*packet)[LOG_EVENT_OFFSET+1] == LOAD_EVENT)
667
	  {
668
	    if (send_file(thd))
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
669
	    {
670
	      errmsg = "failed in send_file()";
671
	      my_errno= ER_UNKNOWN_ERROR;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
672 673
	      goto err;
	    }
674
	  }
675
	  packet->set("\0", 1, &my_charset_bin);
676 677 678 679
	  /*
	    No need to net_flush because we will get to flush later when
	    we hit EOF pretty quick
	  */
680
	}
681

682
	if (fatal_error)
683 684
	{
	  errmsg = "error reading log entry";
685
          my_errno= ER_MASTER_FATAL_ERROR_READING_BINLOG;
686
	  goto err;
687
	}
688 689
	log.error=0;
      }
690
    }
691 692 693
    else
    {
      bool loop_breaker = 0;
694
      /* need this to break out of the for loop from switch */
695

696
      thd->proc_info = "Finished reading one binlog; switching to next binlog";
697
      switch (mysql_bin_log.find_next_log(&linfo, 1)) {
698 699 700 701 702 703 704
      case LOG_INFO_EOF:
	loop_breaker = (flags & BINLOG_DUMP_NON_BLOCK);
	break;
      case 0:
	break;
      default:
	errmsg = "could not find next log";
705
	my_errno= ER_MASTER_FATAL_ERROR_READING_BINLOG;
706 707 708
	goto err;
      }

709 710
      if (loop_breaker)
        break;
grog@mysql.com[grog]'s avatar
foo1  
grog@mysql.com[grog] committed
711

712 713
      end_io_cache(&log);
      (void) my_close(file, MYF(MY_WME));
714

715
      /*
716 717 718 719 720 721 722
        Call fake_rotate_event() in case the previous log (the one which
        we have just finished reading) did not contain a Rotate event
        (for example (I don't know any other example) the previous log
        was the last one before the master was shutdown & restarted).
        This way we tell the slave about the new log's name and
        position.  If the binlog is 5.0, the next event we are going to
        read and send is Format_description_log_event.
723
      */
724
      if ((file=open_binlog(&log, log_file_name, &errmsg)) < 0 ||
725 726
	  fake_rotate_event(net, packet, log_file_name, BIN_LOG_HEADER_SIZE,
                            &errmsg))
727 728
      {
	my_errno= ER_MASTER_FATAL_ERROR_READING_BINLOG;
729
	goto err;
730
      }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
731

732
      packet->length(0);
733
      packet->append('\0');
734
    }
735
  }
736

vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
737
end:
738 739
  end_io_cache(&log);
  (void)my_close(file, MYF(MY_WME));
740

741
  send_eof(thd);
742
  thd->proc_info = "Waiting to finalize termination";
743 744 745
  pthread_mutex_lock(&LOCK_thread_count);
  thd->current_linfo = 0;
  pthread_mutex_unlock(&LOCK_thread_count);
746
  DBUG_VOID_RETURN;
747

vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
748
err:
749
  thd->proc_info = "Waiting to finalize termination";
750
  end_io_cache(&log);
751 752 753 754 755 756 757
  /*
    Exclude  iteration through thread list
    this is needed for purge_logs() - it will iterate through
    thread list and update thd->current_linfo->index_file_offset
    this mutex will make sure that it never tried to update our linfo
    after we return from this stack frame
  */
758
  pthread_mutex_lock(&LOCK_thread_count);
759 760
  thd->current_linfo = 0;
  pthread_mutex_unlock(&LOCK_thread_count);
761 762
  if (file >= 0)
    (void) my_close(file, MYF(MY_WME));
763

764
  my_message(my_errno, errmsg, MYF(0));
765 766 767
  DBUG_VOID_RETURN;
}

768
int start_slave(THD* thd , Master_info* mi,  bool net_report)
769
{
770
  int slave_errno= 0;
771
  int thread_mask;
772
  DBUG_ENTER("start_slave");
773

774
  if (check_access(thd, SUPER_ACL, any_db,0,0,0,0))
775
    DBUG_RETURN(1);
776
  lock_slave_threads(mi);  // this allows us to cleanly read slave_running
777
  // Get a mask of _stopped_ threads
778
  init_thread_mask(&thread_mask,mi,1 /* inverse */);
779
  /*
780 781 782 783
    Below we will start all stopped threads.  But if the user wants to
    start only one thread, do as if the other thread was running (as we
    don't wan't to touch the other thread), so set the bit to 0 for the
    other thread
784
  */
785
  if (thd->lex->slave_thd_opt)
786
    thread_mask&= thd->lex->slave_thd_opt;
787
  if (thread_mask) //some threads are stopped, start them
788
  {
789 790
    if (init_master_info(mi,master_info_file,relay_log_info_file, 0,
			 thread_mask))
791 792
      slave_errno=ER_MASTER_INFO;
    else if (server_id_supplied && *mi->host)
793
    {
794
      /*
795 796 797
        If we will start SQL thread we will care about UNTIL options If
        not and they are specified we will ignore them and warn user
        about this fact.
798 799 800 801 802
      */
      if (thread_mask & SLAVE_SQL)
      {
        pthread_mutex_lock(&mi->rli.data_lock);

pem@mysql.telia.com's avatar
pem@mysql.telia.com committed
803
        if (thd->lex->mi.pos)
804
        {
805
          mi->rli.until_condition= Relay_log_info::UNTIL_MASTER_POS;
pem@mysql.telia.com's avatar
pem@mysql.telia.com committed
806
          mi->rli.until_log_pos= thd->lex->mi.pos;
807 808
          /*
             We don't check thd->lex->mi.log_file_name for NULL here
809 810
             since it is checked in sql_yacc.yy
          */
pem@mysql.telia.com's avatar
pem@mysql.telia.com committed
811
          strmake(mi->rli.until_log_name, thd->lex->mi.log_file_name,
812
                  sizeof(mi->rli.until_log_name)-1);
813
        }
pem@mysql.telia.com's avatar
pem@mysql.telia.com committed
814
        else if (thd->lex->mi.relay_log_pos)
815
        {
816
          mi->rli.until_condition= Relay_log_info::UNTIL_RELAY_POS;
pem@mysql.telia.com's avatar
pem@mysql.telia.com committed
817 818
          mi->rli.until_log_pos= thd->lex->mi.relay_log_pos;
          strmake(mi->rli.until_log_name, thd->lex->mi.relay_log_name,
819
                  sizeof(mi->rli.until_log_name)-1);
820 821
        }
        else
822
          mi->rli.clear_until_condition();
823

824
        if (mi->rli.until_condition != Relay_log_info::UNTIL_NONE)
825 826 827 828 829 830 831 832 833 834 835 836
        {
          /* Preparing members for effective until condition checking */
          const char *p= fn_ext(mi->rli.until_log_name);
          char *p_end;
          if (*p)
          {
            //p points to '.'
            mi->rli.until_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.
837
            */
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
838
            if (p_end==p || *p_end)
839 840 841 842
              slave_errno=ER_BAD_SLAVE_UNTIL_COND;
          }
          else
            slave_errno=ER_BAD_SLAVE_UNTIL_COND;
843

844
          /* mark the cached result of the UNTIL comparison as "undefined" */
845
          mi->rli.until_log_names_cmp_result=
846
            Relay_log_info::UNTIL_LOG_NAMES_CMP_UNKNOWN;
847 848 849

          /* Issuing warning then started without --skip-slave-start */
          if (!opt_skip_slave_start)
850
            push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
grog@mysql.com[grog]'s avatar
foo1  
grog@mysql.com[grog] committed
851
                         ER_MISSING_SKIP_SLAVE,
852 853
                         ER(ER_MISSING_SKIP_SLAVE));
        }
854

855 856
        pthread_mutex_unlock(&mi->rli.data_lock);
      }
pem@mysql.telia.com's avatar
pem@mysql.telia.com committed
857
      else if (thd->lex->mi.pos || thd->lex->mi.relay_log_pos)
858
        push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE, ER_UNTIL_COND_IGNORED,
859
                     ER(ER_UNTIL_COND_IGNORED));
860

monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
861
      if (!slave_errno)
862
        slave_errno = start_slave_threads(0 /*no mutex */,
863 864 865 866
					1 /* wait for start */,
					mi,
					master_info_file,relay_log_info_file,
					thread_mask);
867
    }
868 869 870
    else
      slave_errno = ER_BAD_SLAVE;
  }
871
  else
872 873
  {
    /* no error if all threads are already started, only a warning */
874 875
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE, ER_SLAVE_WAS_RUNNING,
                 ER(ER_SLAVE_WAS_RUNNING));
876
  }
grog@mysql.com[grog]'s avatar
foo1  
grog@mysql.com[grog] committed
877

878
  unlock_slave_threads(mi);
879

880 881
  if (slave_errno)
  {
882
    if (net_report)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
883
      my_message(slave_errno, ER(slave_errno), MYF(0));
884
    DBUG_RETURN(1);
885 886
  }
  else if (net_report)
887
    send_ok(thd);
888

889
  DBUG_RETURN(0);
890 891
}

892

893
int stop_slave(THD* thd, Master_info* mi, bool net_report )
894
{
895 896
  DBUG_ENTER("stop_slave");
  
897
  int slave_errno;
898 899
  if (!thd)
    thd = current_thd;
900

901
  if (check_access(thd, SUPER_ACL, any_db,0,0,0,0))
902
    DBUG_RETURN(1);
903 904 905
  thd->proc_info = "Killing slave";
  int thread_mask;
  lock_slave_threads(mi);
906
  // Get a mask of _running_ threads
907
  init_thread_mask(&thread_mask,mi,0 /* not inverse*/);
908 909 910 911 912 913
  /*
    Below we will stop all running threads.
    But if the user wants to stop only one thread, do as if the other thread
    was stopped (as we don't wan't to touch the other thread), so set the
    bit to 0 for the other thread
  */
914 915
  if (thd->lex->slave_thd_opt)
    thread_mask &= thd->lex->slave_thd_opt;
916 917 918 919 920 921 922 923 924 925 926 927 928

  if (thread_mask)
  {
    slave_errno= terminate_slave_threads(mi,thread_mask,
                                         1 /*skip lock */);
  }
  else
  {
    //no error if both threads are already stopped, only a warning
    slave_errno= 0;
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE, ER_SLAVE_WAS_NOT_RUNNING,
                 ER(ER_SLAVE_WAS_NOT_RUNNING));
  }
929
  unlock_slave_threads(mi);
930 931
  thd->proc_info = 0;

932 933 934
  if (slave_errno)
  {
    if (net_report)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
935
      my_message(slave_errno, ER(slave_errno), MYF(0));
936
    DBUG_RETURN(1);
937 938
  }
  else if (net_report)
939
    send_ok(thd);
940

941
  DBUG_RETURN(0);
942 943
}

944 945 946 947 948 949 950 951 952 953 954 955 956 957 958

/*
  Remove all relay logs and start replication from the start

  SYNOPSIS
    reset_slave()
    thd			Thread handler
    mi			Master info for the slave

  RETURN
    0	ok
    1	error
*/


959
int reset_slave(THD *thd, Master_info* mi)
960 961 962
{
  MY_STAT stat_area;
  char fname[FN_REFLEN];
963 964
  int thread_mask= 0, error= 0;
  uint sql_errno=0;
965
  const char* errmsg=0;
966 967
  DBUG_ENTER("reset_slave");

968
  lock_slave_threads(mi);
969 970 971 972 973 974 975
  init_thread_mask(&thread_mask,mi,0 /* not inverse */);
  if (thread_mask) // We refuse if any slave thread is running
  {
    sql_errno= ER_SLAVE_MUST_STOP;
    error=1;
    goto err;
  }
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
976 977 978

  ha_reset_slave(thd);

979
  // delete relay logs, clear relay log coordinates
980 981 982
  if ((error= purge_relay_logs(&mi->rli, thd,
			       1 /* just reset */,
			       &errmsg)))
983
    goto err;
984

guilhem@mysql.com's avatar
guilhem@mysql.com committed
985 986 987 988 989 990 991 992
  /*
    Clear master's log coordinates and reset host/user/etc to the values
    specified in mysqld's options (only for good display of SHOW SLAVE STATUS;
    next init_master_info() (in start_slave() for example) would have set them
    the same way; but here this is for the case where the user does SHOW SLAVE
    STATUS; before doing START SLAVE;
  */
  init_master_info_with_options(mi);
993
  /*
994
     Reset errors (the idea is that we forget about the
guilhem@gbichot2's avatar
guilhem@gbichot2 committed
995 996
     old master).
  */
997
  mi->rli.clear_error();
998
  mi->rli.clear_until_condition();
999

1000
  // close master_info_file, relay_log_info_file, set mi->inited=rli->inited=0
1001
  end_master_info(mi);
1002
  // and delete these two files
1003 1004
  fn_format(fname, master_info_file, mysql_data_home, "", 4+32);
  if (my_stat(fname, &stat_area, MYF(0)) && my_delete(fname, MYF(MY_WME)))
1005
  {
1006 1007
    error=1;
    goto err;
1008
  }
1009
  // delete relay_log_info_file
1010
  fn_format(fname, relay_log_info_file, mysql_data_home, "", 4+32);
1011
  if (my_stat(fname, &stat_area, MYF(0)) && my_delete(fname, MYF(MY_WME)))
1012 1013 1014 1015
  {
    error=1;
    goto err;
  }
1016

1017 1018
err:
  unlock_slave_threads(mi);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1019
  if (error)
1020
    my_error(sql_errno, MYF(0), errmsg);
1021
  DBUG_RETURN(error);
1022 1023
}

1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
/*

  Kill all Binlog_dump threads which previously talked to the same slave
  ("same" means with the same server id). Indeed, if the slave stops, if the
  Binlog_dump thread is waiting (pthread_cond_wait) for binlog update, then it
  will keep existing until a query is written to the binlog. If the master is
  idle, then this could last long, and if the slave reconnects, we could have 2
  Binlog_dump threads in SHOW PROCESSLIST, until a query is written to the
  binlog. To avoid this, when the slave reconnects and sends COM_BINLOG_DUMP,
  the master kills any existing thread with the slave's server id (if this id is
  not zero; it will be true for real slaves, but false for mysqlbinlog when it
  sends COM_BINLOG_DUMP to get a remote binlog dump).

  SYNOPSIS
    kill_zombie_dump_threads()
    slave_server_id     the slave's server id

*/
grog@mysql.com[grog]'s avatar
foo1  
grog@mysql.com[grog] committed
1042

1043

1044 1045 1046
void kill_zombie_dump_threads(uint32 slave_server_id)
{
  pthread_mutex_lock(&LOCK_thread_count);
1047 1048 1049
  I_List_iterator<THD> it(threads);
  THD *tmp;

1050 1051 1052 1053
  while ((tmp=it++))
  {
    if (tmp->command == COM_BINLOG_DUMP &&
       tmp->server_id == slave_server_id)
1054
    {
1055 1056
      pthread_mutex_lock(&tmp->LOCK_delete);	// Lock from delete
      break;
1057 1058
    }
  }
1059
  pthread_mutex_unlock(&LOCK_thread_count);
1060 1061 1062 1063 1064 1065 1066
  if (tmp)
  {
    /*
      Here we do not call kill_one_thread() as
      it will be slow because it will iterate through the list
      again. We just to do kill the thread ourselves.
    */
hf@genie.(none)'s avatar
SCRUM  
hf@genie.(none) committed
1067
    tmp->awake(THD::KILL_QUERY);
1068 1069
    pthread_mutex_unlock(&tmp->LOCK_delete);
  }
1070 1071
}

1072

1073
bool change_master(THD* thd, Master_info* mi)
1074
{
1075
  int thread_mask;
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1076 1077
  const char* errmsg= 0;
  bool need_relay_log_purge= 1;
1078 1079
  DBUG_ENTER("change_master");

1080
  lock_slave_threads(mi);
1081 1082
  init_thread_mask(&thread_mask,mi,0 /*not inverse*/);
  if (thread_mask) // We refuse if any slave thread is running
1083
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1084
    my_message(ER_SLAVE_MUST_STOP, ER(ER_SLAVE_MUST_STOP), MYF(0));
1085
    unlock_slave_threads(mi);
1086
    DBUG_RETURN(TRUE);
1087
  }
1088

1089
  thd->proc_info = "Changing master";
1090
  LEX_MASTER_INFO* lex_mi= &thd->lex->mi;
1091
  // TODO: see if needs re-write
1092 1093
  if (init_master_info(mi, master_info_file, relay_log_info_file, 0,
		       thread_mask))
1094
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1095
    my_message(ER_MASTER_INFO, ER(ER_MASTER_INFO), MYF(0));
1096
    unlock_slave_threads(mi);
1097
    DBUG_RETURN(TRUE);
1098 1099
  }

1100 1101 1102 1103
  /*
    Data lock not needed since we have already stopped the running threads,
    and we have the hold on the run locks which will keep all threads that
    could possibly modify the data structures from running
1104
  */
1105 1106

  /*
grog@mysql.com[grog]'s avatar
foo1  
grog@mysql.com[grog] committed
1107
    If the user specified host or port without binlog or position,
1108
    reset binlog's name to FIRST and position to 4.
grog@mysql.com[grog]'s avatar
foo1  
grog@mysql.com[grog] committed
1109
  */
1110

1111 1112
  if ((lex_mi->host || lex_mi->port) && !lex_mi->log_file_name && !lex_mi->pos)
  {
1113
    mi->master_log_name[0] = 0;
1114
    mi->master_log_pos= BIN_LOG_HEADER_SIZE;
1115
  }
1116

1117
  if (lex_mi->log_file_name)
1118
    strmake(mi->master_log_name, lex_mi->log_file_name,
1119
	    sizeof(mi->master_log_name)-1);
1120
  if (lex_mi->pos)
1121
  {
1122
    mi->master_log_pos= lex_mi->pos;
1123
  }
1124
  DBUG_PRINT("info", ("master_log_pos: %lu", (ulong) mi->master_log_pos));
1125 1126

  if (lex_mi->host)
1127
    strmake(mi->host, lex_mi->host, sizeof(mi->host)-1);
1128
  if (lex_mi->user)
1129
    strmake(mi->user, lex_mi->user, sizeof(mi->user)-1);
1130
  if (lex_mi->password)
1131
    strmake(mi->password, lex_mi->password, sizeof(mi->password)-1);
1132
  if (lex_mi->port)
1133
    mi->port = lex_mi->port;
1134
  if (lex_mi->connect_retry)
1135
    mi->connect_retry = lex_mi->connect_retry;
grog@mysql.com[grog]'s avatar
foo1  
grog@mysql.com[grog] committed
1136

1137 1138
  if (lex_mi->ssl != LEX_MASTER_INFO::SSL_UNCHANGED)
    mi->ssl= (lex_mi->ssl == LEX_MASTER_INFO::SSL_ENABLE);
1139 1140 1141 1142 1143

  if (lex_mi->ssl_verify_server_cert != LEX_MASTER_INFO::SSL_UNCHANGED)
    mi->ssl_verify_server_cert=
      (lex_mi->ssl_verify_server_cert == LEX_MASTER_INFO::SSL_ENABLE);

1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155
  if (lex_mi->ssl_ca)
    strmake(mi->ssl_ca, lex_mi->ssl_ca, sizeof(mi->ssl_ca)-1);
  if (lex_mi->ssl_capath)
    strmake(mi->ssl_capath, lex_mi->ssl_capath, sizeof(mi->ssl_capath)-1);
  if (lex_mi->ssl_cert)
    strmake(mi->ssl_cert, lex_mi->ssl_cert, sizeof(mi->ssl_cert)-1);
  if (lex_mi->ssl_cipher)
    strmake(mi->ssl_cipher, lex_mi->ssl_cipher, sizeof(mi->ssl_cipher)-1);
  if (lex_mi->ssl_key)
    strmake(mi->ssl_key, lex_mi->ssl_key, sizeof(mi->ssl_key)-1);
#ifndef HAVE_OPENSSL
  if (lex_mi->ssl || lex_mi->ssl_ca || lex_mi->ssl_capath ||
1156 1157
      lex_mi->ssl_cert || lex_mi->ssl_cipher || lex_mi->ssl_key ||
      lex_mi->ssl_verify_server_cert )
grog@mysql.com[grog]'s avatar
foo1  
grog@mysql.com[grog] committed
1158
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
1159 1160
                 ER_SLAVE_IGNORED_SSL_PARAMS, ER(ER_SLAVE_IGNORED_SSL_PARAMS));
#endif
1161

1162 1163
  if (lex_mi->relay_log_name)
  {
1164
    need_relay_log_purge= 0;
1165 1166 1167 1168
    strmake(mi->rli.group_relay_log_name,lex_mi->relay_log_name,
	    sizeof(mi->rli.group_relay_log_name)-1);
    strmake(mi->rli.event_relay_log_name,lex_mi->relay_log_name,
	    sizeof(mi->rli.event_relay_log_name)-1);
1169 1170 1171 1172
  }

  if (lex_mi->relay_log_pos)
  {
1173
    need_relay_log_purge= 0;
1174
    mi->rli.group_relay_log_pos= mi->rli.event_relay_log_pos= lex_mi->relay_log_pos;
1175 1176
  }

guilhem@mysql.com's avatar
guilhem@mysql.com committed
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201
  /*
    If user did specify neither host nor port nor any log name nor any log
    pos, i.e. he specified only user/password/master_connect_retry, he probably
    wants replication to resume from where it had left, i.e. from the
    coordinates of the **SQL** thread (imagine the case where the I/O is ahead
    of the SQL; restarting from the coordinates of the I/O would lose some
    events which is probably unwanted when you are just doing minor changes
    like changing master_connect_retry).
    A side-effect is that if only the I/O thread was started, this thread may
    restart from ''/4 after the CHANGE MASTER. That's a minor problem (it is a
    much more unlikely situation than the one we are fixing here).
    Note: coordinates of the SQL thread must be read here, before the
    'if (need_relay_log_purge)' block which resets them.
  */
  if (!lex_mi->host && !lex_mi->port &&
      !lex_mi->log_file_name && !lex_mi->pos &&
      need_relay_log_purge)
   {
     /*
       Sometimes mi->rli.master_log_pos == 0 (it happens when the SQL thread is
       not initialized), so we use a max().
       What happens to mi->rli.master_log_pos during the initialization stages
       of replication is not 100% clear, so we guard against problems using
       max().
      */
monty@mysql.com's avatar
monty@mysql.com committed
1202 1203 1204
     mi->master_log_pos = max(BIN_LOG_HEADER_SIZE,
			      mi->rli.group_master_log_pos);
     strmake(mi->master_log_name, mi->rli.group_master_log_name,
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1205 1206
             sizeof(mi->master_log_name)-1);
  }
guilhem@gbichot2's avatar
guilhem@gbichot2 committed
1207 1208 1209 1210
  /*
    Relay log's IO_CACHE may not be inited, if rli->inited==0 (server was never
    a slave before).
  */
1211 1212 1213 1214 1215 1216
  if (flush_master_info(mi, 0))
  {
    my_error(ER_RELAY_LOG_INIT, MYF(0), "Failed to flush master info file");
    unlock_slave_threads(mi);
    DBUG_RETURN(TRUE);
  }
1217
  if (need_relay_log_purge)
1218
  {
1219
    relay_log_purge= 1;
1220
    thd->proc_info="Purging old relay logs";
1221 1222
    if (purge_relay_logs(&mi->rli, thd,
			 0 /* not only reset, but also reinit */,
1223 1224
			 &errmsg))
    {
1225
      my_error(ER_RELAY_LOG_FAIL, MYF(0), errmsg);
1226
      unlock_slave_threads(mi);
1227
      DBUG_RETURN(TRUE);
1228 1229 1230 1231 1232
    }
  }
  else
  {
    const char* msg;
1233
    relay_log_purge= 0;
1234 1235
    /* Relay log is already initialized */
    if (init_relay_log_pos(&mi->rli,
1236 1237
			   mi->rli.group_relay_log_name,
			   mi->rli.group_relay_log_pos,
1238
			   0 /*no data lock*/,
1239
			   &msg, 0))
1240
    {
1241
      my_error(ER_RELAY_LOG_INIT, MYF(0), msg);
1242
      unlock_slave_threads(mi);
1243
      DBUG_RETURN(TRUE);
1244
    }
1245
  }
1246
  mi->rli.group_master_log_pos = mi->master_log_pos;
1247
  DBUG_PRINT("info", ("master_log_pos: %lu", (ulong) mi->master_log_pos));
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258

  /*
    Coordinates in rli were spoilt by the 'if (need_relay_log_purge)' block,
    so restore them to good values. If we left them to ''/0, that would work;
    but that would fail in the case of 2 successive CHANGE MASTER (without a
    START SLAVE in between): because first one would set the coords in mi to
    the good values of those in rli, the set those in rli to ''/0, then
    second CHANGE MASTER would set the coords in mi to those of rli, i.e. to
    ''/0: we have lost all copies of the original good coordinates.
    That's why we always save good coords in rli.
  */
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1259
  mi->rli.group_master_log_pos= mi->master_log_pos;
1260 1261
  strmake(mi->rli.group_master_log_name,mi->master_log_name,
	  sizeof(mi->rli.group_master_log_name)-1);
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1262

1263 1264
  if (!mi->rli.group_master_log_name[0]) // uninitialized case
    mi->rli.group_master_log_pos=0;
1265 1266

  pthread_mutex_lock(&mi->rli.data_lock);
1267
  mi->rli.abort_pos_wait++; /* for MASTER_POS_WAIT() to abort */
1268
  /* Clear the errors, for a clean start */
1269
  mi->rli.clear_error();
1270
  mi->rli.clear_until_condition();
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1271 1272 1273 1274 1275 1276
  /*
    If we don't write new coordinates to disk now, then old will remain in
    relay-log.info until START SLAVE is issued; but if mysqld is shutdown
    before START SLAVE, then old will remain in relay-log.info, and will be the
    in-memory value at restart (thus causing errors, as the old relay log does
    not exist anymore).
1277
  */
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1278
  flush_relay_log_info(&mi->rli);
1279
  pthread_cond_broadcast(&mi->data_cond);
1280
  pthread_mutex_unlock(&mi->rli.data_lock);
1281

1282
  unlock_slave_threads(mi);
1283
  thd->proc_info = 0;
1284
  send_ok(thd);
1285
  DBUG_RETURN(FALSE);
1286 1287
}

1288
int reset_master(THD* thd)
1289
{
1290
  if (!mysql_bin_log.is_open())
1291
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1292 1293
    my_message(ER_FLUSH_MASTER_BINLOG_CLOSED,
               ER(ER_FLUSH_MASTER_BINLOG_CLOSED), MYF(ME_BELL+ME_WAITTANG));
1294
    return 1;
1295
  }
1296
  return mysql_bin_log.reset_logs(thd);
1297 1298
}

1299 1300 1301 1302
int cmp_master_pos(const char* log_file_name1, ulonglong log_pos1,
		   const char* log_file_name2, ulonglong log_pos2)
{
  int res;
1303 1304
  uint log_file_name1_len=  strlen(log_file_name1);
  uint log_file_name2_len=  strlen(log_file_name2);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1305

1306 1307 1308 1309 1310 1311 1312 1313
  //  We assume that both log names match up to '.'
  if (log_file_name1_len == log_file_name2_len)
  {
    if ((res= strcmp(log_file_name1, log_file_name2)))
      return res;
    return (log_pos1 < log_pos2) ? -1 : (log_pos1 == log_pos2) ? 0 : 1;
  }
  return ((log_file_name1_len < log_file_name2_len) ? -1 : 1);
1314 1315
}

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1316

1317
bool mysql_show_binlog_events(THD* thd)
1318
{
1319
  Protocol *protocol= thd->protocol;
1320
  List<Item> field_list;
1321
  const char *errmsg = 0;
1322
  bool ret = TRUE;
1323 1324
  IO_CACHE log;
  File file = -1;
1325
  DBUG_ENTER("mysql_show_binlog_events");
1326 1327

  Log_event::init_show_field_list(&field_list);
1328 1329
  if (protocol->send_fields(&field_list,
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
1330
    DBUG_RETURN(TRUE);
1331

1332 1333 1334
  Format_description_log_event *description_event= new
    Format_description_log_event(3); /* MySQL 4.0 by default */

tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
1335 1336 1337 1338 1339 1340 1341
  /*
    Wait for handlers to insert any pending information
    into the binlog.  For e.g. ndb which updates the binlog asynchronously
    this is needed so that the uses sees all its own commands in the binlog
  */
  ha_binlog_wait(thd);

1342 1343
  if (mysql_bin_log.is_open())
  {
1344
    LEX_MASTER_INFO *lex_mi= &thd->lex->mi;
1345
    SELECT_LEX_UNIT *unit= &thd->lex->unit;
1346
    ha_rows event_count, limit_start, limit_end;
1347
    my_off_t pos = max(BIN_LOG_HEADER_SIZE, lex_mi->pos); // user-friendly
1348 1349
    char search_file_name[FN_REFLEN], *name;
    const char *log_file_name = lex_mi->log_file_name;
1350
    pthread_mutex_t *log_lock = mysql_bin_log.get_log_lock();
1351 1352
    LOG_INFO linfo;
    Log_event* ev;
1353

1354 1355 1356
    unit->set_limit(thd->lex->current_select);
    limit_start= unit->offset_limit_cnt;
    limit_end= unit->select_limit_cnt;
1357

1358
    name= search_file_name;
1359 1360 1361
    if (log_file_name)
      mysql_bin_log.make_log_name(search_file_name, log_file_name);
    else
1362
      name=0;					// Find first log
1363 1364

    linfo.index_file_offset = 0;
1365

1366
    if (mysql_bin_log.find_log_pos(&linfo, name, 1))
1367 1368 1369 1370 1371
    {
      errmsg = "Could not find target log";
      goto err;
    }

1372 1373 1374 1375
    pthread_mutex_lock(&LOCK_thread_count);
    thd->current_linfo = &linfo;
    pthread_mutex_unlock(&LOCK_thread_count);

1376 1377 1378
    if ((file=open_binlog(&log, linfo.log_file_name, &errmsg)) < 0)
      goto err;

1379
    pthread_mutex_lock(log_lock);
1380

1381
    /*
1382 1383 1384 1385 1386 1387
      open_binlog() sought to position 4.
      Read the first event in case it's a Format_description_log_event, to
      know the format. If there's no such event, we are 3.23 or 4.x. This
      code, like before, can't read 3.23 binlogs.
      This code will fail on a mixed relay log (one which has Format_desc then
      Rotate then Format_desc).
1388
    */
1389

1390 1391 1392 1393
    ev = Log_event::read_log_event(&log,(pthread_mutex_t*)0,description_event);
    if (ev)
    {
      if (ev->get_type_code() == FORMAT_DESCRIPTION_EVENT)
1394 1395
      {
        delete description_event;
1396
        description_event= (Format_description_log_event*) ev;
1397
      }
1398 1399 1400 1401
      else
        delete ev;
    }

1402 1403
    my_b_seek(&log, pos);

1404 1405 1406 1407 1408
    if (!description_event->is_valid())
    {
      errmsg="Invalid Format_description event; could be out of memory";
      goto err;
    }
1409

1410
    for (event_count = 0;
1411 1412
	 (ev = Log_event::read_log_event(&log,(pthread_mutex_t*) 0,
                                         description_event)); )
1413 1414
    {
      if (event_count >= limit_start &&
1415
	  ev->net_send(protocol, linfo.log_file_name, pos))
1416 1417 1418
      {
	errmsg = "Net error";
	delete ev;
1419
	pthread_mutex_unlock(log_lock);
1420 1421 1422 1423
	goto err;
      }

      pos = my_b_tell(&log);
1424 1425 1426 1427 1428 1429 1430 1431 1432
      delete ev;

      if (++event_count >= limit_end)
	break;
    }

    if (event_count < limit_end && log.error)
    {
      errmsg = "Wrong offset or I/O error";
1433
      pthread_mutex_unlock(log_lock);
1434 1435
      goto err;
    }
1436

1437
    pthread_mutex_unlock(log_lock);
1438 1439
  }

1440 1441
  ret= FALSE;

1442
err:
1443
  delete description_event;
1444 1445 1446 1447 1448
  if (file >= 0)
  {
    end_io_cache(&log);
    (void) my_close(file, MYF(MY_WME));
  }
1449

1450
  if (errmsg)
1451 1452
    my_error(ER_ERROR_WHEN_EXECUTING_COMMAND, MYF(0),
             "SHOW BINLOG EVENTS", errmsg);
1453 1454
  else
    send_eof(thd);
1455

1456 1457 1458
  pthread_mutex_lock(&LOCK_thread_count);
  thd->current_linfo = 0;
  pthread_mutex_unlock(&LOCK_thread_count);
1459
  DBUG_RETURN(ret);
1460 1461
}

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1462

1463
bool show_binlog_info(THD* thd)
1464
{
1465
  Protocol *protocol= thd->protocol;
1466 1467 1468
  DBUG_ENTER("show_binlog_info");
  List<Item> field_list;
  field_list.push_back(new Item_empty_string("File", FN_REFLEN));
1469 1470
  field_list.push_back(new Item_return_int("Position",20,
					   MYSQL_TYPE_LONGLONG));
1471 1472
  field_list.push_back(new Item_empty_string("Binlog_Do_DB",255));
  field_list.push_back(new Item_empty_string("Binlog_Ignore_DB",255));
1473

1474 1475
  if (protocol->send_fields(&field_list,
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
1476
    DBUG_RETURN(TRUE);
1477 1478
  protocol->prepare_for_resend();

1479 1480 1481 1482 1483
  if (mysql_bin_log.is_open())
  {
    LOG_INFO li;
    mysql_bin_log.get_current_log(&li);
    int dir_len = dirname_length(li.log_file_name);
1484
    protocol->store(li.log_file_name + dir_len, &my_charset_bin);
1485
    protocol->store((ulonglong) li.pos);
1486 1487
    protocol->store(binlog_filter->get_do_db());
    protocol->store(binlog_filter->get_ignore_db());
1488
    if (protocol->write())
1489
      DBUG_RETURN(TRUE);
1490
  }
1491
  send_eof(thd);
1492
  DBUG_RETURN(FALSE);
1493
}
1494

1495

1496
/*
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1497
  Send a list of all binary logs to client
1498 1499 1500 1501 1502 1503

  SYNOPSIS
    show_binlogs()
    thd		Thread specific variable

  RETURN VALUES
1504 1505
    FALSE OK
    TRUE  error
1506 1507
*/

1508
bool show_binlogs(THD* thd)
1509
{
1510
  IO_CACHE *index_file;
1511 1512
  LOG_INFO cur;
  File file;
1513 1514
  char fname[FN_REFLEN];
  List<Item> field_list;
1515
  uint length;
monty@mysql.com's avatar
monty@mysql.com committed
1516
  int cur_dir_len;
1517 1518
  Protocol *protocol= thd->protocol;
  DBUG_ENTER("show_binlogs");
1519 1520

  if (!mysql_bin_log.is_open())
1521
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1522
    my_message(ER_NO_BINARY_LOGGING, ER(ER_NO_BINARY_LOGGING), MYF(0));
1523
    return 1;
1524
  }
1525

1526
  field_list.push_back(new Item_empty_string("Log_name", 255));
grog@mysql.com[grog]'s avatar
foo1  
grog@mysql.com[grog] committed
1527
  field_list.push_back(new Item_return_int("File_size", 20,
1528
                                           MYSQL_TYPE_LONGLONG));
1529 1530
  if (protocol->send_fields(&field_list,
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
1531
    DBUG_RETURN(TRUE);
1532 1533
  
  pthread_mutex_lock(mysql_bin_log.get_log_lock());
1534
  mysql_bin_log.lock_index();
1535
  index_file=mysql_bin_log.get_index_file();
1536 1537 1538 1539
  
  mysql_bin_log.raw_get_current_log(&cur); // dont take mutex
  pthread_mutex_unlock(mysql_bin_log.get_log_lock()); // lockdep, OK
  
monty@mysql.com's avatar
monty@mysql.com committed
1540
  cur_dir_len= dirname_length(cur.log_file_name);
1541

1542 1543 1544 1545
  reinit_io_cache(index_file, READ_CACHE, (my_off_t) 0, 0, 0);

  /* The file ends with EOF or empty line */
  while ((length=my_b_gets(index_file, fname, sizeof(fname))) > 1)
1546
  {
monty@mysql.com's avatar
monty@mysql.com committed
1547 1548 1549
    int dir_len;
    ulonglong file_length= 0;                   // Length if open fails
    fname[--length] = '\0';                     // remove the newline
1550

1551
    protocol->prepare_for_resend();
monty@mysql.com's avatar
monty@mysql.com committed
1552 1553 1554 1555 1556 1557 1558
    dir_len= dirname_length(fname);
    length-= dir_len;
    protocol->store(fname + dir_len, length, &my_charset_bin);

    if (!(strncmp(fname+dir_len, cur.log_file_name+cur_dir_len, length)))
      file_length= cur.pos;  /* The active log, use the active position */
    else
1559 1560
    {
      /* this is an old log, open it and find the size */
1561
      if ((file= my_open(fname, O_RDONLY | O_SHARE | O_BINARY,
monty@mysql.com's avatar
monty@mysql.com committed
1562
                         MYF(0))) >= 0)
1563
      {
monty@mysql.com's avatar
monty@mysql.com committed
1564
        file_length= (ulonglong) my_seek(file, 0L, MY_SEEK_END, MYF(0));
1565 1566 1567
        my_close(file, MYF(0));
      }
    }
monty@mysql.com's avatar
monty@mysql.com committed
1568
    protocol->store(file_length);
1569
    if (protocol->write())
1570
      goto err;
1571
  }
1572
  mysql_bin_log.unlock_index();
1573
  send_eof(thd);
1574
  DBUG_RETURN(FALSE);
1575

1576 1577
err:
  mysql_bin_log.unlock_index();
1578
  DBUG_RETURN(TRUE);
1579 1580
}

1581

1582 1583
int log_loaded_block(IO_CACHE* file)
{
1584
  LOAD_FILE_INFO *lf_info;
1585
  uint block_len ;
monty@bitch.mysql.fi's avatar
monty@bitch.mysql.fi committed
1586 1587 1588

  /* file->request_pos contains position where we started last read */
  char* buffer = (char*) file->request_pos;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1589
  if (!(block_len = (char*) file->read_end - (char*) buffer))
1590
    return 0;
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1591
  lf_info = (LOAD_FILE_INFO*) file->arg;
1592 1593
  if (lf_info->thd->current_stmt_binlog_row_based)
    return 0;
1594 1595 1596 1597 1598 1599
  if (lf_info->last_pos_in_file != HA_POS_ERROR &&
      lf_info->last_pos_in_file >= file->pos_in_file)
    return 0;
  lf_info->last_pos_in_file = file->pos_in_file;
  if (lf_info->wrote_create_file)
  {
1600 1601
    Append_block_log_event a(lf_info->thd, lf_info->thd->db, buffer,
                             block_len, lf_info->log_delayed);
1602 1603 1604 1605
    mysql_bin_log.write(&a);
  }
  else
  {
1606 1607 1608 1609
    Begin_load_query_log_event b(lf_info->thd, lf_info->thd->db,
                                 buffer, block_len,
                                 lf_info->log_delayed);
    mysql_bin_log.write(&b);
1610
    lf_info->wrote_create_file = 1;
1611
    DBUG_SYNC_POINT("debug_lock.created_file_event",10);
1612 1613 1614
  }
  return 0;
}
1615

antony@ppcg5.local's avatar
antony@ppcg5.local committed
1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659
/*
  Replication System Variables
*/

class sys_var_slave_skip_counter :public sys_var
{
public:
  sys_var_slave_skip_counter(sys_var_chain *chain, const char *name_arg)
    :sys_var(name_arg)
  { chain_sys_var(chain); }
  bool check(THD *thd, set_var *var);
  bool update(THD *thd, set_var *var);
  bool check_type(enum_var_type type) { return type != OPT_GLOBAL; }
  /*
    We can't retrieve the value of this, so we don't have to define
    type() or value_ptr()
  */
};

class sys_var_sync_binlog_period :public sys_var_long_ptr
{
public:
  sys_var_sync_binlog_period(sys_var_chain *chain, const char *name_arg, 
                             ulong *value_ptr)
    :sys_var_long_ptr(chain, name_arg,value_ptr) {}
  bool update(THD *thd, set_var *var);
};

static sys_var_chain vars = { NULL, NULL };

static sys_var_bool_ptr	sys_relay_log_purge(&vars, "relay_log_purge",
					    &relay_log_purge);
static sys_var_long_ptr	sys_slave_net_timeout(&vars, "slave_net_timeout",
					      &slave_net_timeout);
static sys_var_long_ptr	sys_slave_trans_retries(&vars, "slave_transaction_retries",
						&slave_trans_retries);
static sys_var_sync_binlog_period sys_sync_binlog_period(&vars, "sync_binlog", &sync_binlog_period);
static sys_var_slave_skip_counter sys_slave_skip_counter(&vars, "sql_slave_skip_counter");

static int show_slave_skip_errors(THD *thd, SHOW_VAR *var, char *buff);


static SHOW_VAR fixed_vars[]= {
  {"log_slave_updates",       (char*) &opt_log_slave_updates,       SHOW_MY_BOOL},
1660 1661 1662
  {"relay_log" , (char*) &opt_relay_logname, SHOW_CHAR_PTR},
  {"relay_log_index", (char*) &opt_relaylog_index_name, SHOW_CHAR_PTR},
  {"relay_log_info_file", (char*) &relay_log_info_file, SHOW_CHAR_PTR},
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 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 1755 1756 1757 1758 1759 1760 1761
  {"relay_log_space_limit",   (char*) &relay_log_space_limit,       SHOW_LONGLONG},
  {"slave_load_tmpdir",       (char*) &slave_load_tmpdir,           SHOW_CHAR_PTR},
  {"slave_skip_errors",       (char*) &show_slave_skip_errors,      SHOW_FUNC},
};

static int show_slave_skip_errors(THD *thd, SHOW_VAR *var, char *buff)
{
  var->type=SHOW_CHAR;
  var->value= buff;
  if (!use_slave_mask || bitmap_is_clear_all(&slave_error_mask))
  {
    var->value= const_cast<char *>("OFF");
  }
  else if (bitmap_is_set_all(&slave_error_mask))
  {
    var->value= const_cast<char *>("ALL");
  }
  else
  {
    /* 10 is enough assuming errors are max 4 digits */
    int i;
    var->value= buff;
    for (i= 1;
         i < MAX_SLAVE_ERROR &&
         (buff - var->value) < SHOW_VAR_FUNC_BUFF_SIZE;
         i++)
    {
      if (bitmap_is_set(&slave_error_mask, i))
      {
        buff= int10_to_str(i, buff, 10);
        *buff++= ',';
      }
    }
    if (var->value != buff)
      buff--;				// Remove last ','
    if (i < MAX_SLAVE_ERROR)
      buff= strmov(buff, "...");  // Couldn't show all errors
    *buff=0;
  }
  return 0;
}

bool sys_var_slave_skip_counter::check(THD *thd, set_var *var)
{
  int result= 0;
  pthread_mutex_lock(&LOCK_active_mi);
  pthread_mutex_lock(&active_mi->rli.run_lock);
  if (active_mi->rli.slave_running)
  {
    my_message(ER_SLAVE_MUST_STOP, ER(ER_SLAVE_MUST_STOP), MYF(0));
    result=1;
  }
  pthread_mutex_unlock(&active_mi->rli.run_lock);
  pthread_mutex_unlock(&LOCK_active_mi);
  var->save_result.ulong_value= (ulong) var->value->val_int();
  return result;
}


bool sys_var_slave_skip_counter::update(THD *thd, set_var *var)
{
  pthread_mutex_lock(&LOCK_active_mi);
  pthread_mutex_lock(&active_mi->rli.run_lock);
  /*
    The following test should normally never be true as we test this
    in the check function;  To be safe against multiple
    SQL_SLAVE_SKIP_COUNTER request, we do the check anyway
  */
  if (!active_mi->rli.slave_running)
  {
    pthread_mutex_lock(&active_mi->rli.data_lock);
    active_mi->rli.slave_skip_counter= var->save_result.ulong_value;
    pthread_mutex_unlock(&active_mi->rli.data_lock);
  }
  pthread_mutex_unlock(&active_mi->rli.run_lock);
  pthread_mutex_unlock(&LOCK_active_mi);
  return 0;
}


bool sys_var_sync_binlog_period::update(THD *thd, set_var *var)
{
  sync_binlog_period= (ulong) var->save_result.ulonglong_value;
  return 0;
}

int init_replication_sys_vars()
{
  mysql_append_static_vars(fixed_vars, sizeof(fixed_vars) / sizeof(SHOW_VAR));

  if (mysql_add_sys_var_chain(vars.first, my_long_options))
  {
    /* should not happen */
    fprintf(stderr, "failed to initialize replication system variables");
    unireg_abort(1);
  }
  return 0;
}

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1762
#endif /* HAVE_REPLICATION */
1763 1764