log.cc 51.6 KB
Newer Older
unknown's avatar
unknown committed
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 18
   
   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 */


/* logging of commands */
19
/* TODO: Abort logging when we get an error in reading or writing log files */
unknown's avatar
unknown committed
20

21 22 23 24
#ifdef __EMX__
#include <io.h>
#endif

unknown's avatar
unknown committed
25 26
#include "mysql_priv.h"
#include "sql_acl.h"
unknown's avatar
unknown committed
27
#include "sql_repl.h"
unknown's avatar
unknown committed
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

#include <my_dir.h>
#include <stdarg.h>
#include <m_ctype.h>				// For test_if_number

MYSQL_LOG mysql_log,mysql_update_log,mysql_slow_log,mysql_bin_log;

static bool test_if_number(const char *str,
			   long *res, bool allow_wildcards);

/****************************************************************************
** Find a uniq filename for 'filename.#'.
** Set # to a number as low as possible
** returns != 0 if not possible to get uniq filename
****************************************************************************/

static int find_uniq_filename(char *name)
{
46 47 48 49
  long                  number;
  uint                  i;
  char                  buff[FN_REFLEN];
  struct st_my_dir     *dir_info;
unknown's avatar
unknown committed
50
  reg1 struct fileinfo *file_info;
51 52
  ulong                 max_found=0;

unknown's avatar
unknown committed
53 54
  DBUG_ENTER("find_uniq_filename");

55 56 57 58
  uint  length = dirname_part(buff,name);
  char *start  = name + length;
  char *end    = strend(start);

unknown's avatar
unknown committed
59
  *end='.';
unknown's avatar
unknown committed
60
  length= (uint) (end-start+1);
unknown's avatar
unknown committed
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78

  if (!(dir_info = my_dir(buff,MYF(MY_DONT_SORT))))
  {						// This shouldn't happen
    strmov(end,".1");				// use name+1
    DBUG_RETURN(0);
  }
  file_info= dir_info->dir_entry;
  for (i=dir_info->number_off_files ; i-- ; file_info++)
  {
    if (bcmp(file_info->name,start,length) == 0 &&
	test_if_number(file_info->name+length, &number,0))
    {
      set_if_bigger(max_found,(ulong) number);
    }
  }
  my_dirend(dir_info);

  *end++='.';
79
  sprintf(end,"%06ld",max_found+1);
unknown's avatar
unknown committed
80 81 82
  DBUG_RETURN(0);
}

83

unknown's avatar
unknown committed
84
MYSQL_LOG::MYSQL_LOG()
85
  :bytes_written(0), last_time(0), query_start(0), name(0),
unknown's avatar
unknown committed
86
   file_id(1), open_count(1), log_type(LOG_CLOSED), write_error(0), inited(0),
87
   need_start_event(1)
unknown's avatar
unknown committed
88 89
{
  /*
unknown's avatar
unknown committed
90 91
    We don't want to initialize LOCK_Log here as such initialization depends on
    safe_mutex (when using safe_mutex) which depends on MY_INIT(), which is
unknown's avatar
unknown committed
92 93
    called only in main(). Doing initialization here would make it happen
    before main(). 
unknown's avatar
unknown committed
94
  */
95 96
  index_file_name[0] = 0;
  bzero((char*) &log_file,sizeof(log_file));
97
  bzero((char*) &index_file, sizeof(index_file));
unknown's avatar
unknown committed
98 99
}

100

unknown's avatar
unknown committed
101
MYSQL_LOG::~MYSQL_LOG()
unknown's avatar
unknown committed
102 103 104 105
{
  cleanup();
}

unknown's avatar
unknown committed
106
/* this is called only once */
unknown's avatar
unknown committed
107

unknown's avatar
unknown committed
108
void MYSQL_LOG::cleanup()
unknown's avatar
unknown committed
109
{
110
  DBUG_ENTER("cleanup");
unknown's avatar
unknown committed
111
  if (inited)
112
  {
unknown's avatar
unknown committed
113
    inited= 0;
114
    close(LOG_CLOSE_INDEX);
115 116
    (void) pthread_mutex_destroy(&LOCK_log);
    (void) pthread_mutex_destroy(&LOCK_index);
unknown's avatar
unknown committed
117
    (void) pthread_cond_destroy(&update_cond);
118
  }
119
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
120 121
}

122

unknown's avatar
unknown committed
123 124
int MYSQL_LOG::generate_new_name(char *new_name, const char *log_name)
{      
125 126
  fn_format(new_name,log_name,mysql_data_home,"",4);
  if (log_type != LOG_NORMAL)
unknown's avatar
unknown committed
127 128 129 130 131 132 133 134 135 136 137 138 139
  {
    if (!fn_ext(log_name)[0])
    {
      if (find_uniq_filename(new_name))
      {
	sql_print_error(ER(ER_NO_UNIQUE_LOGFILE), log_name);
	return 1;
      }
    }
  }
  return 0;
}

140

141
void MYSQL_LOG::init(enum_log_type log_type_arg,
142
		     enum cache_type io_cache_type_arg,
143 144
		     bool no_auto_events_arg,
                     ulong max_size_arg)
145
{
146
  DBUG_ENTER("MYSQL_LOG::init");
147
  log_type = log_type_arg;
148
  io_cache_type = io_cache_type_arg;
149
  no_auto_events = no_auto_events_arg;
150
  max_size=max_size_arg;
unknown's avatar
unknown committed
151
  DBUG_PRINT("info",("log_type: %d max_size: %lu", log_type, max_size));
152
  DBUG_VOID_RETURN;
153 154
}

unknown's avatar
unknown committed
155

unknown's avatar
unknown committed
156 157
void MYSQL_LOG::init_pthread_objects()
{
unknown's avatar
unknown committed
158 159
  DBUG_ASSERT(inited == 0);
  inited= 1;
unknown's avatar
unknown committed
160 161 162
  (void) pthread_mutex_init(&LOCK_log,MY_MUTEX_INIT_SLOW);
  (void) pthread_mutex_init(&LOCK_index, MY_MUTEX_INIT_SLOW);
  (void) pthread_cond_init(&update_cond, 0);
163 164
}

unknown's avatar
unknown committed
165

166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
/*
  Open a (new) log file.

  DESCRIPTION
  - If binary logs, also open the index file and register the new
    file name in it
  - When calling this when the file is in use, you must have a locks
    on LOCK_log and LOCK_index.

  RETURN VALUES
    0	ok
    1	error
*/

bool MYSQL_LOG::open(const char *log_name, enum_log_type log_type_arg,
		     const char *new_name, const char *index_file_name_arg,
		     enum cache_type io_cache_type_arg,
183
		     bool no_auto_events_arg,
184
                     ulong max_size_arg)
unknown's avatar
unknown committed
185
{
186
  char buff[512];
187
  File file= -1, index_file_nr= -1;
188
  int open_flags = O_CREAT | O_APPEND | O_BINARY;
unknown's avatar
unknown committed
189
  DBUG_ENTER("MYSQL_LOG::open");
190 191 192 193
  DBUG_PRINT("enter",("log_type: %d",(int) log_type));

  last_time=query_start=0;
  write_error=0;
unknown's avatar
unknown committed
194

195
  init(log_type_arg,io_cache_type_arg,no_auto_events_arg,max_size_arg);
196 197 198
  
  if (!(name=my_strdup(log_name,MYF(MY_WME))))
    goto err;
unknown's avatar
unknown committed
199 200 201
  if (new_name)
    strmov(log_file_name,new_name);
  else if (generate_new_name(log_file_name, name))
202
    goto err;
203 204 205 206 207
  
  if (io_cache_type == SEQ_READ_APPEND)
    open_flags |= O_RDWR;
  else
    open_flags |= O_WRONLY;
208

unknown's avatar
unknown committed
209
  db[0]=0;
unknown's avatar
unknown committed
210
  open_count++;
211
  if ((file=my_open(log_file_name,open_flags,
212
		    MYF(MY_WME | ME_WAITTANG))) < 0 ||
213
      init_io_cache(&log_file, file, IO_SIZE, io_cache_type,
214 215
		    my_tell(file,MYF(MY_WME)), 0, MYF(MY_WME | MY_NABP)))
    goto err;
unknown's avatar
unknown committed
216

217 218
  switch (log_type) {
  case LOG_NORMAL:
unknown's avatar
unknown committed
219
  {
220
    char *end;
221
    int len=my_snprintf(buff, sizeof(buff), "%s, Version: %s. "
unknown's avatar
SCRUM  
unknown committed
222
#ifdef EMBEDDED_LIBRARY
223
		        "embedded library\n", my_progname, server_version
unknown's avatar
SCRUM  
unknown committed
224
#elif __NT__
225 226
			"started with:\nTCP Port: %d, Named Pipe: %s\n",
			my_progname, server_version, mysqld_port, mysqld_unix_port
unknown's avatar
unknown committed
227
#else
228 229
			"started with:\nTcp port: %d  Unix socket: %s\n",
			my_progname,server_version,mysqld_port,mysqld_unix_port
unknown's avatar
unknown committed
230
#endif
231
                        );
232 233
    end=strnmov(buff+len,"Time                 Id Command    Argument\n",
                sizeof(buff)-len);
unknown's avatar
unknown committed
234
    if (my_b_write(&log_file, (byte*) buff,(uint) (end-buff)) ||
235 236
	flush_io_cache(&log_file))
      goto err;
237
    break;
unknown's avatar
unknown committed
238
  }
239
  case LOG_NEW:
unknown's avatar
unknown committed
240
  {
241
    uint len;
unknown's avatar
unknown committed
242 243
    time_t skr=time(NULL);
    struct tm tm_tmp;
244

unknown's avatar
unknown committed
245
    localtime_r(&skr,&tm_tmp);
246 247 248 249 250 251 252 253 254 255
    len= my_snprintf(buff,sizeof(buff),
		     "# %s, Version: %s at %02d%02d%02d %2d:%02d:%02d\n",
		     my_progname,server_version,
		     tm_tmp.tm_year % 100,
		     tm_tmp.tm_mon+1,
		     tm_tmp.tm_mday,
		     tm_tmp.tm_hour,
		     tm_tmp.tm_min,
		     tm_tmp.tm_sec);
    if (my_b_write(&log_file, (byte*) buff, len) ||
256 257
	flush_io_cache(&log_file))
      goto err;
258
    break;
unknown's avatar
unknown committed
259
  }
260
  case LOG_BIN:
unknown's avatar
unknown committed
261
  {
262 263 264 265
    bool write_file_name_to_index_file=0;

    myf opt= MY_UNPACK_FILENAME;
    if (!index_file_name_arg)
unknown's avatar
unknown committed
266
    {
267 268 269
      index_file_name_arg= name;	// Use same basename for index file
      opt= MY_UNPACK_FILENAME | MY_REPLACE_EXT;
    }
270

271 272 273 274 275 276 277 278
    if (!my_b_filelength(&log_file))
    {
      /*
	The binary log file was empty (probably newly created)
	This is the normal case and happens when the user doesn't specify
	an extension for the binary log files.
	In this case we write a standard header to it.
      */
unknown's avatar
unknown committed
279 280
      if (my_b_safe_write(&log_file, (byte*) BINLOG_MAGIC,
			  BIN_LOG_HEADER_SIZE))
unknown's avatar
unknown committed
281
        goto err;
unknown's avatar
unknown committed
282
      bytes_written += BIN_LOG_HEADER_SIZE;
283
      write_file_name_to_index_file=1;
unknown's avatar
unknown committed
284
    }
unknown's avatar
unknown committed
285

286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
    if (!my_b_inited(&index_file))
    {
      /*
	First open of this class instance
	Create an index file that will hold all file names uses for logging.
	Add new entries to the end of it.
      */
      fn_format(index_file_name, index_file_name_arg, mysql_data_home,
		".index", opt);
      if ((index_file_nr= my_open(index_file_name,
				  O_RDWR | O_CREAT | O_BINARY ,
				  MYF(MY_WME))) < 0 ||
	  init_io_cache(&index_file, index_file_nr,
			IO_SIZE, WRITE_CACHE,
			my_seek(index_file_nr,0L,MY_SEEK_END,MYF(0)),
			0, MYF(MY_WME)))
	goto err;
    }
    else
    {
      safe_mutex_assert_owner(&LOCK_index);
      reinit_io_cache(&index_file, WRITE_CACHE, my_b_filelength(&index_file),
		      0, 0);
    }
310
    if (need_start_event && !no_auto_events)
311
    {
312
      need_start_event=0;
313
      Start_log_event s;
314
      s.set_log_pos(this);
315 316
      s.write(&log_file);
    }
317
    if (flush_io_cache(&log_file))
unknown's avatar
unknown committed
318
      goto err;
319 320 321 322 323 324 325 326 327

    if (write_file_name_to_index_file)
    {
      /* As this is a new log file, we write the file name to the index file */
      if (my_b_write(&index_file, (byte*) log_file_name,
		     strlen(log_file_name)) ||
	  my_b_write(&index_file, (byte*) "\n", 1) ||
	  flush_io_cache(&index_file))
	goto err;
unknown's avatar
unknown committed
328
    }
329
    break;
unknown's avatar
unknown committed
330
  }
331
  case LOG_CLOSED:				// Impossible
332
  case LOG_TO_BE_OPENED:
333 334 335 336
    DBUG_ASSERT(1);
    break;
  }
  DBUG_RETURN(0);
337 338

err:
339 340 341 342
  sql_print_error("Could not use %s for logging (error %d). \
Turning logging off for the whole duration of the MySQL server process. \
To turn it on again: fix the cause, \
shutdown the MySQL server and restart it.", log_name, errno);
343 344
  if (file >= 0)
    my_close(file,MYF(0));
345 346
  if (index_file_nr >= 0)
    my_close(index_file_nr,MYF(0));
347
  end_io_cache(&log_file);
348 349
  end_io_cache(&index_file);
  safeFree(name);
350
  log_type= LOG_CLOSED;
351
  DBUG_RETURN(1);
unknown's avatar
unknown committed
352 353
}

354

unknown's avatar
unknown committed
355 356 357
int MYSQL_LOG::get_current_log(LOG_INFO* linfo)
{
  pthread_mutex_lock(&LOCK_log);
358 359
  strmake(linfo->log_file_name, log_file_name, sizeof(linfo->log_file_name)-1);
  linfo->pos = my_b_tell(&log_file);
unknown's avatar
unknown committed
360 361 362 363
  pthread_mutex_unlock(&LOCK_log);
  return 0;
}

unknown's avatar
unknown committed
364

365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427
/*
  Move all data up in a file in an filename index file

  SYNOPSIS
    copy_up_file_and_fill()
    index_file			File to move
    offset			Move everything from here to beginning

  NOTE
    File will be truncated to be 'offset' shorter or filled up with
    newlines

  IMPLEMENTATION
    We do the copy outside of the IO_CACHE as the cache buffers would just
    make things slower and more complicated.
    In most cases the copy loop should only do one read.

  RETURN VALUES
    0	ok
*/

static bool copy_up_file_and_fill(IO_CACHE *index_file, my_off_t offset)
{
  int bytes_read;
  my_off_t init_offset= offset;
  File file= index_file->file;
  byte io_buf[IO_SIZE*2];
  DBUG_ENTER("copy_up_file_and_fill");

  for (;; offset+= bytes_read)
  {
    (void) my_seek(file, offset, MY_SEEK_SET, MYF(0));
    if ((bytes_read= (int) my_read(file, io_buf, sizeof(io_buf), MYF(MY_WME)))
	< 0)
      goto err;
    if (!bytes_read)
      break;					// end of file
    (void) my_seek(file, offset-init_offset, MY_SEEK_SET, MYF(0));
    if (my_write(file, (byte*) io_buf, bytes_read, MYF(MY_WME | MY_NABP)))
      goto err;
  }
  /* The following will either truncate the file or fill the end with \n' */
  if (my_chsize(file, offset - init_offset, '\n', MYF(MY_WME)))
    goto err;

  /* Reset data in old index cache */
  reinit_io_cache(index_file, READ_CACHE, (my_off_t) 0, 0, 1);
  DBUG_RETURN(0);

err:
  DBUG_RETURN(1);
}


/*
  Find the position in the log-index-file for the given log name

  SYNOPSIS
    find_log_pos()
    linfo		Store here the found log file name and position to
			the NEXT log file name in the index file.
    log_name		Filename to find in the index file.
			Is a null pointer if we want to read the first entry
unknown's avatar
unknown committed
428
    need_lock		Set this to 1 if the parent doesn't already have a
429 430 431
			lock on LOCK_index

  NOTE
unknown's avatar
unknown committed
432 433
    On systems without the truncate function the file will end with one or
    more empty lines.  These will be ignored when reading the file.
434 435 436 437 438 439 440 441 442

  RETURN VALUES
    0			ok
    LOG_INFO_EOF	End of log-index-file found
    LOG_INFO_IO		Got IO error while reading file
*/

int MYSQL_LOG::find_log_pos(LOG_INFO *linfo, const char *log_name,
			    bool need_lock)
unknown's avatar
unknown committed
443
{
444 445 446 447 448
  int error= 0;
  char *fname= linfo->log_file_name;
  uint log_name_len= log_name ? (uint) strlen(log_name) : 0;
  DBUG_ENTER("find_log_pos");
  DBUG_PRINT("enter",("log_name: %s", log_name ? log_name : "NULL"));
unknown's avatar
unknown committed
449

unknown's avatar
unknown committed
450 451 452 453
  /*
    Mutex needed because we need to make sure the file pointer does not move
    from under our feet
  */
454
  if (need_lock)
455
    pthread_mutex_lock(&LOCK_index);
456 457 458 459 460
  safe_mutex_assert_owner(&LOCK_index);

  /* As the file is flushed, we can't get an error here */
  (void) reinit_io_cache(&index_file, READ_CACHE, (my_off_t) 0, 0, 0);

unknown's avatar
unknown committed
461
  for (;;)
462
  {
463
    uint length;
464 465 466 467
    my_off_t offset= my_b_tell(&index_file);
    /* If we get 0 or 1 characters, this is the end of the file */

    if ((length= my_b_gets(&index_file, fname, FN_REFLEN)) <= 1)
unknown's avatar
unknown committed
468
    {
469 470 471
      /* Did not find the given entry; Return not found or error */
      error= !index_file.error ? LOG_INFO_EOF : LOG_INFO_IO;
      break;
unknown's avatar
unknown committed
472 473
    }

474 475
    // if the log entry matches, null string matching anything
    if (!log_name ||
unknown's avatar
unknown committed
476
	(log_name_len == length-1 && fname[log_name_len] == '\n' &&
477
	 !memcmp(fname, log_name, log_name_len)))
unknown's avatar
unknown committed
478
    {
479
      DBUG_PRINT("info",("Found log file entry"));
480
      fname[length-1]=0;			// remove last \n
481 482
      linfo->index_file_start_offset= offset;
      linfo->index_file_offset = my_b_tell(&index_file);
483
      break;
unknown's avatar
unknown committed
484
    }
485
  }
486

487
  if (need_lock)
488
    pthread_mutex_unlock(&LOCK_index);
489
  DBUG_RETURN(error);
unknown's avatar
unknown committed
490
}
unknown's avatar
unknown committed
491

492

493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
/*
  Find the position in the log-index-file for the given log name

  SYNOPSIS
    find_next_log()
    linfo		Store here the next log file name and position to
			the file name after that.
    need_lock		Set this to 1 if the parent doesn't already have a
			lock on LOCK_index

  NOTE
    - Before calling this function, one has to call find_log_pos()
      to set up 'linfo'
    - Mutex needed because we need to make sure the file pointer does not move
      from under our feet

  RETURN VALUES
    0			ok
    LOG_INFO_EOF	End of log-index-file found
    LOG_INFO_IO		Got IO error while reading file
*/

515
int MYSQL_LOG::find_next_log(LOG_INFO* linfo, bool need_lock)
unknown's avatar
unknown committed
516
{
517
  int error= 0;
518
  uint length;
519 520
  char *fname= linfo->log_file_name;

521 522
  if (need_lock)
    pthread_mutex_lock(&LOCK_index);
523 524 525 526 527 528 529 530
  safe_mutex_assert_owner(&LOCK_index);

  /* As the file is flushed, we can't get an error here */
  (void) reinit_io_cache(&index_file, READ_CACHE, linfo->index_file_offset, 0,
			 0);

  linfo->index_file_start_offset= linfo->index_file_offset;
  if ((length=my_b_gets(&index_file, fname, FN_REFLEN)) <= 1)
531
  {
532
    error = !index_file.error ? LOG_INFO_EOF : LOG_INFO_IO;
533 534 535
    goto err;
  }
  fname[length-1]=0;				// kill /n
536
  linfo->index_file_offset = my_b_tell(&index_file);
537

unknown's avatar
unknown committed
538
err:
539 540
  if (need_lock)
    pthread_mutex_unlock(&LOCK_index);
unknown's avatar
unknown committed
541 542 543
  return error;
}

unknown's avatar
unknown committed
544

545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
/*
  Delete all logs refered to in the index file
  Start writing to a new log file.  The new index file will only contain
  this file.

  SYNOPSIS
     reset_logs()
     thd		Thread

  NOTE
    If not called from slave thread, write start event to new log


  RETURN VALUES
    0	ok
    1   error
*/

bool MYSQL_LOG::reset_logs(THD* thd)
564 565
{
  LOG_INFO linfo;
566
  bool error=0;
567 568
  const char* save_name;
  enum_log_type save_log_type;
569
  DBUG_ENTER("reset_logs");
570

571 572 573 574
  /*
    We need to get both locks to be sure that no one is trying to
    write to the index log file.
  */
575
  pthread_mutex_lock(&LOCK_log);
576 577 578 579 580 581
  pthread_mutex_lock(&LOCK_index);

  /* Save variables so that we can reopen the log */
  save_name=name;
  name=0;					// Protect against free
  save_log_type=log_type;
582
  close(LOG_CLOSE_TO_BE_OPENED);
583 584 585 586

  /* First delete all old log files */

  if (find_log_pos(&linfo, NullS, 0))
587 588 589 590 591
  {
    error=1;
    goto err;
  }
  
unknown's avatar
unknown committed
592
  for (;;)
593 594
  {
    my_delete(linfo.log_file_name, MYF(MY_WME));
595
    if (find_next_log(&linfo, 0))
596 597
      break;
  }
598 599

  /* Start logging with a new file */
unknown's avatar
unknown committed
600
  close(LOG_CLOSE_INDEX);
601 602
  my_delete(index_file_name, MYF(MY_WME));	// Reset (open will update)
  if (!thd->slave_thread)
603
    need_start_event=1;
604
  open(save_name, save_log_type, 0, index_file_name,
605
       io_cache_type, no_auto_events, max_size);
606
  my_free((gptr) save_name, MYF(0));
607

608
err:  
609
  pthread_mutex_unlock(&LOCK_index);
610
  pthread_mutex_unlock(&LOCK_log);
611
  DBUG_RETURN(error);
612 613
}

unknown's avatar
unknown committed
614

615
/*
616 617 618
  Delete relay log files prior to rli->group_relay_log_name
  (i.e. all logs which are not involved in a non-finished group
  (transaction)), remove them from the index file and start on next relay log.
619 620 621

  SYNOPSIS
    purge_first_log()
622 623 624 625 626 627
    rli		 Relay log information
    included     If false, all relay logs that are strictly before
                 rli->group_relay_log_name are deleted ; if true, the latter is
                 deleted too (i.e. all relay logs
                 read by the SQL slave thread are deleted).
    
628 629
  NOTE
    - This is only called from the slave-execute thread when it has read
630 631 632 633 634
      all commands from a relay log and want to switch to a new relay log.
    - When this happens, we can be in an active transaction as
      a transaction can span over two relay logs
      (although it is always written as a single block to the master's binary 
      log, hence cannot span over two master's binary logs).
635 636 637

  IMPLEMENTATION
    - Protects index file with LOCK_index
638 639
    - Delete relevant relay log files
    - Copy all file names after these ones to the front of the index file
640
    - If the OS has truncate, truncate the file, else fill it with \n'
641
    - Read the next file name from the index file and store in rli->linfo
642 643

  RETURN VALUES
644 645 646 647
    0			ok
    LOG_INFO_EOF	End of log-index-file found
    LOG_INFO_SEEK	Could not allocate IO cache
    LOG_INFO_IO		Got IO error while reading file
648 649
*/

unknown's avatar
SCRUM  
unknown committed
650
#ifdef HAVE_REPLICATION
651

652
int MYSQL_LOG::purge_first_log(struct st_relay_log_info* rli, bool included) 
653
{
654
  int error;
655 656
  DBUG_ENTER("purge_first_log");

657 658
  DBUG_ASSERT(is_open());
  DBUG_ASSERT(rli->slave_running == 1);
659
  DBUG_ASSERT(!strcmp(rli->linfo.log_file_name,rli->event_relay_log_name));
660

661
  pthread_mutex_lock(&LOCK_index);
662 663 664 665 666 667
  pthread_mutex_lock(&rli->log_space_lock);
  rli->relay_log.purge_logs(rli->group_relay_log_name, included,
                            0, 0, &rli->log_space_total);
  // Tell the I/O thread to take the relay_log_space_limit into account
  rli->ignore_log_space_limit= 0;
  pthread_mutex_unlock(&rli->log_space_lock);
unknown's avatar
unknown committed
668 669

  /*
670 671 672
    Ok to broadcast after the critical region as there is no risk of
    the mutex being destroyed by this thread later - this helps save
    context switches
unknown's avatar
unknown committed
673
  */
674 675 676 677 678
  pthread_cond_broadcast(&rli->log_space_cond);
  
  /*
    Read the next log file name from the index file and pass it back to
    the caller
679 680
    If included is true, we want the first relay log;
    otherwise we want the one after event_relay_log_name.
681
  */
682 683 684 685
  if ((included && (error=find_log_pos(&rli->linfo, NullS, 0))) ||
      (!included &&
       ((error=find_log_pos(&rli->linfo, rli->event_relay_log_name, 0)) ||
        (error=find_next_log(&rli->linfo, 0)))))
686 687
  {
    char buff[22];
688 689 690 691 692
    sql_print_error("next log error: %d  offset: %s  log: %s included: %d",
                    error,
                    llstr(rli->linfo.index_file_offset,buff),
                    rli->group_relay_log_name,
                    included);
693 694
    goto err;
  }
695

696
  /*
697
    Reset rli's coordinates to the current log.
698
  */
699 700 701 702 703 704 705 706 707 708 709 710 711 712
  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);

  /*
    If we removed the rli->group_relay_log_name file,
    we must update the rli->group* coordinates, otherwise do not touch it as the
    group's execution is not finished (e.g. COMMIT not executed)
  */
  if (included)
  {
    rli->group_relay_log_pos = BIN_LOG_HEADER_SIZE;
    strmake(rli->group_relay_log_name,rli->linfo.log_file_name,
            sizeof(rli->group_relay_log_name)-1);
713
    rli->notify_group_relay_log_name_update();
714
  }
715 716 717

  /* Store where we are in the new file for the execution thread */
  flush_relay_log_info(rli);
unknown's avatar
unknown committed
718

719
err:
720
  pthread_mutex_unlock(&LOCK_index);
721
  DBUG_RETURN(error);
722 723
}

unknown's avatar
unknown committed
724 725 726 727
/*
  Update log index_file
*/

728
int MYSQL_LOG::update_log_index(LOG_INFO* log_info, bool need_update_threads)
unknown's avatar
unknown committed
729 730 731 732 733
{
  if (copy_up_file_and_fill(&index_file, log_info->index_file_start_offset))
    return LOG_INFO_IO;

  // now update offsets in index file for running threads
734 735
  if (need_update_threads)
    adjust_linfo_offsets(log_info->index_file_start_offset);
unknown's avatar
unknown committed
736 737
  return 0;
}
unknown's avatar
unknown committed
738

739 740 741 742 743
/*
  Remove all logs before the given log from disk and from the index file.

  SYNOPSIS
    purge_logs()
744 745 746 747 748 749 750
    to_log	        Delete all log file name before this file. 
    included            If true, to_log is deleted too.
    need_mutex
    need_update_threads If we want to update the log coordinates of
                        all threads. False for relay logs, true otherwise.
    freed_log_space     If not null, decrement this variable of
                        the amount of log space freed
751 752 753 754 755 756 757 758 759 760

  NOTES
    If any of the logs before the deleted one is in use,
    only purge logs up to this one.

  RETURN VALUES
    0				ok
    LOG_INFO_EOF		to_log not found
*/

761 762 763 764 765
int MYSQL_LOG::purge_logs(const char *to_log, 
                          bool included,
                          bool need_mutex, 
                          bool need_update_threads, 
                          ulonglong *decrease_log_space)
unknown's avatar
unknown committed
766 767
{
  int error;
768
  bool exit_loop= 0;
769 770
  LOG_INFO log_info;
  DBUG_ENTER("purge_logs");
771
  DBUG_PRINT("info",("to_log= %s",to_log));
772

773 774
  if (need_mutex)
    pthread_mutex_lock(&LOCK_index);
775
  if ((error=find_log_pos(&log_info, to_log, 0 /*no mutex*/)))
776 777
    goto err;

778
  /*
779
    File name exists in index file; delete until we find this file
780 781 782
    or a file that is used.
  */
  if ((error=find_log_pos(&log_info, NullS, 0 /*no mutex*/)))
783
    goto err;
784 785
  while ((strcmp(to_log,log_info.log_file_name) || (exit_loop=included)) &&
         !log_in_use(log_info.log_file_name))
786
  {
787
    ulong tmp;
unknown's avatar
unknown committed
788
    LINT_INIT(tmp);
789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
    if (decrease_log_space) //stat the file we want to delete
    {
      MY_STAT s;
      if (my_stat(log_info.log_file_name,&s,MYF(0)))
        tmp= s.st_size;
      else
      {
        /* 
           If we could not stat, we can't know the amount
           of space that deletion will free. In most cases,
           deletion won't work either, so it's not a problem.
        */
        tmp= 0; 
      }
    }
    /*
      It's not fatal if we can't delete a log file ;
      if we could delete it, take its size into account
    */
    DBUG_PRINT("info",("purging %s",log_info.log_file_name));
    if (!my_delete(log_info.log_file_name, MYF(0)) && decrease_log_space)
      *decrease_log_space-= tmp;
    if (find_next_log(&log_info, 0) || exit_loop)
812
      break;
813
  }
814

unknown's avatar
unknown committed
815 816 817 818
  /*
    If we get killed -9 here, the sysadmin would have to edit
    the log index file after restart - otherwise, this should be safe
  */
819
  error= update_log_index(&log_info, need_update_threads);
820

unknown's avatar
unknown committed
821
err:
822 823
  if (need_mutex)
    pthread_mutex_unlock(&LOCK_index);
824
  DBUG_RETURN(error);
unknown's avatar
unknown committed
825 826
}

827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844
/*
  Remove all logs before the given file date from disk and from the
  index file.

  SYNOPSIS
    purge_logs_before_date()
    thd		Thread pointer
    before_date	Delete all log files before given date.

  NOTES
    If any of the logs before the deleted one is in use,
    only purge logs up to this one.

  RETURN VALUES
    0				ok
    LOG_INFO_PURGE_NO_ROTATE	Binary file that can't be rotated
*/

845
int MYSQL_LOG::purge_logs_before_date(time_t purge_time)
846 847 848 849 850 851 852 853 854 855 856 857 858 859 860
{
  int error;
  LOG_INFO log_info;
  MY_STAT stat_area;

  DBUG_ENTER("purge_logs_before_date");

  pthread_mutex_lock(&LOCK_index);

  /*
    Delete until we find curren file
    or a file that is used or a file
    that is older than purge_time.
  */
  if ((error=find_log_pos(&log_info, NullS, 0 /*no mutex*/)))
unknown's avatar
unknown committed
861
    goto err;
862 863 864 865 866

  while (strcmp(log_file_name, log_info.log_file_name) &&
	 !log_in_use(log_info.log_file_name))
  {
    /* It's not fatal even if we can't delete a log file */
unknown's avatar
unknown committed
867 868
    if (!my_stat(log_info.log_file_name, &stat_area, MYF(0)) ||
	stat_area.st_mtime >= purge_time)
869
      break;
unknown's avatar
unknown committed
870
    my_delete(log_info.log_file_name, MYF(0));
871 872
    if (find_next_log(&log_info, 0))
      break;
unknown's avatar
unknown committed
873
  }
874

875 876 877 878
  /*
    If we get killed -9 here, the sysadmin would have to edit
    the log index file after restart - otherwise, this should be safe
  */
879
  error= update_log_index(&log_info, 1);
880

unknown's avatar
unknown committed
881 882
err:
  pthread_mutex_unlock(&LOCK_index);
883
  DBUG_RETURN(error);
unknown's avatar
unknown committed
884 885
}

886

unknown's avatar
SCRUM  
unknown committed
887
#endif /* HAVE_REPLICATION */
888

889 890 891 892 893 894 895 896 897 898 899 900

/*
  Create a new log file name

  SYNOPSIS
    make_log_name()
    buf			buf of at least FN_REFLEN where new name is stored

  NOTE
    If file name will be longer then FN_REFLEN it will be truncated
*/

unknown's avatar
unknown committed
901 902
void MYSQL_LOG::make_log_name(char* buf, const char* log_ident)
{
unknown's avatar
unknown committed
903 904 905 906 907
  uint dir_len = dirname_length(log_file_name); 
  if (dir_len > FN_REFLEN)
    dir_len=FN_REFLEN-1;
  strnmov(buf, log_file_name, dir_len);
  strmake(buf+dir_len, log_ident, FN_REFLEN - dir_len);
unknown's avatar
unknown committed
908 909
}

910 911 912 913 914 915

/*
  Check if we are writing/reading to the given log file
*/

bool MYSQL_LOG::is_active(const char *log_file_name_arg)
unknown's avatar
unknown committed
916
{
unknown's avatar
unknown committed
917
  return !strcmp(log_file_name, log_file_name_arg);
unknown's avatar
unknown committed
918 919
}

920 921 922 923 924 925 926 927 928 929 930 931 932 933

/*
  Start writing to a new log file or reopen the old file

  SYNOPSIS
    new_file()
    need_lock		Set to 1 (default) if caller has not locked
			LOCK_log and LOCK_index

  NOTE
    The new file name is stored last in the index file
*/

void MYSQL_LOG::new_file(bool need_lock)
unknown's avatar
unknown committed
934
{
935 936 937
  char new_name[FN_REFLEN], *new_name_ptr, *old_name;
  enum_log_type save_log_type;

938
  DBUG_ENTER("MYSQL_LOG::new_file");
939
  if (!is_open())
940 941 942 943
  {
    DBUG_PRINT("info",("log is closed"));
    DBUG_VOID_RETURN;
  }
944 945

  if (need_lock)
unknown's avatar
unknown committed
946
  {
947 948 949 950 951 952
    pthread_mutex_lock(&LOCK_log);
    pthread_mutex_lock(&LOCK_index);
  }    
  safe_mutex_assert_owner(&LOCK_log);
  safe_mutex_assert_owner(&LOCK_index);

unknown's avatar
unknown committed
953
  /* Reuse old name if not binlog and not update log */
954
  new_name_ptr= name;
unknown's avatar
unknown committed
955

956
  /*
957 958 959
    If user hasn't specified an extension, generate a new log name
    We have to do this here and not in open as we want to store the
    new file name in the current binary log file.
960
  */
961 962 963 964 965
  if (generate_new_name(new_name, name))
    goto end;
  new_name_ptr=new_name;
  
  if (log_type == LOG_BIN)
966
  {
967
    if (!no_auto_events)
unknown's avatar
unknown committed
968
    {
969
      /*
970 971
        We log the whole file name for log file as the user may decide
        to change base names at some point.
972
      */
unknown's avatar
unknown committed
973
      THD *thd = current_thd; /* may be 0 if we are reacting to SIGHUP */
974 975 976 977
      Rotate_log_event r(thd,new_name+dirname_length(new_name));
      r.set_log_pos(this);
      r.write(&log_file);
      bytes_written += r.get_event_len();
unknown's avatar
unknown committed
978
    }
979 980 981 982 983 984
    /*
      Update needs to be signalled even if there is no rotate event
      log rotation should give the waiting thread a signal to
      discover EOF and move on to the next log.
    */
    signal_update(); 
985 986 987 988
  }
  old_name=name;
  save_log_type=log_type;
  name=0;				// Don't free name
989
  close(LOG_CLOSE_TO_BE_OPENED);
unknown's avatar
unknown committed
990

unknown's avatar
unknown committed
991
  /* 
unknown's avatar
unknown committed
992
     Note that at this point, log_type != LOG_CLOSED (important for is_open()).
unknown's avatar
unknown committed
993
  */
unknown's avatar
unknown committed
994

995
  open(old_name, save_log_type, new_name_ptr, index_file_name, io_cache_type,
996
       no_auto_events, max_size);
997 998
  my_free(old_name,MYF(0));

999
end:
1000 1001 1002 1003
  if (need_lock)
  {
    pthread_mutex_unlock(&LOCK_index);
    pthread_mutex_unlock(&LOCK_log);
unknown's avatar
unknown committed
1004
  }
1005
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1006 1007
}

1008

1009 1010 1011 1012
bool MYSQL_LOG::append(Log_event* ev)
{
  bool error = 0;
  pthread_mutex_lock(&LOCK_log);
1013 1014
  DBUG_ENTER("MYSQL_LOG::append");

1015
  DBUG_ASSERT(log_file.type == SEQ_READ_APPEND);
1016 1017 1018 1019
  /*
    Log_event::write() is smart enough to use my_b_write() or
    my_b_append() depending on the kind of cache we have.
  */
1020 1021 1022 1023 1024
  if (ev->write(&log_file))
  {
    error=1;
    goto err;
  }
unknown's avatar
unknown committed
1025
  bytes_written += ev->get_event_len();
unknown's avatar
unknown committed
1026
  DBUG_PRINT("info",("max_size: %lu",max_size));
1027
  if ((uint) my_b_append_tell(&log_file) > max_size)
1028
  {
1029 1030 1031
    pthread_mutex_lock(&LOCK_index);
    new_file(0);
    pthread_mutex_unlock(&LOCK_index);
1032
  }
1033

1034 1035
err:  
  pthread_mutex_unlock(&LOCK_log);
1036
  signal_update();				// Safe as we don't call close
1037
  DBUG_RETURN(error);
1038 1039
}

1040

1041 1042
bool MYSQL_LOG::appendv(const char* buf, uint len,...)
{
1043
  bool error= 0;
1044
  DBUG_ENTER("MYSQL_LOG::appendv");
1045 1046 1047
  va_list(args);
  va_start(args,len);
  
1048 1049
  DBUG_ASSERT(log_file.type == SEQ_READ_APPEND);
  
1050 1051 1052
  pthread_mutex_lock(&LOCK_log);
  do
  {
unknown's avatar
unknown committed
1053
    if (my_b_append(&log_file,(byte*) buf,len))
1054
    {
1055 1056
      error= 1;
      goto err;
1057
    }
unknown's avatar
unknown committed
1058
    bytes_written += len;
1059
  } while ((buf=va_arg(args,const char*)) && (len=va_arg(args,uint)));
unknown's avatar
unknown committed
1060
  DBUG_PRINT("info",("max_size: %lu",max_size));
1061
  if ((uint) my_b_append_tell(&log_file) > max_size)
1062
  {
1063 1064 1065
    pthread_mutex_lock(&LOCK_index);
    new_file(0);
    pthread_mutex_unlock(&LOCK_index);
1066
  }
1067 1068 1069

err:
  pthread_mutex_unlock(&LOCK_log);
1070 1071
  if (!error)
    signal_update();
1072
  DBUG_RETURN(error);
1073
}
unknown's avatar
unknown committed
1074

unknown's avatar
unknown committed
1075

1076 1077 1078 1079 1080
/*
  Write to normal (not rotable) log
  This is the format for the 'normal', 'slow' and 'update' logs.
*/

1081
bool MYSQL_LOG::write(THD *thd,enum enum_server_command command,
unknown's avatar
unknown committed
1082 1083
		      const char *format,...)
{
1084
  if (is_open() && (what_to_log & (1L << (uint) command)))
unknown's avatar
unknown committed
1085
  {
1086 1087
    uint length;
    int error= 0;
unknown's avatar
unknown committed
1088
    VOID(pthread_mutex_lock(&LOCK_log));
1089

unknown's avatar
unknown committed
1090 1091
    /* Test if someone closed between the is_open test and lock */
    if (is_open())
unknown's avatar
unknown committed
1092 1093 1094
    {
      time_t skr;
      ulong id;
1095 1096 1097 1098
      va_list args;
      va_start(args,format);
      char buff[32];

unknown's avatar
unknown committed
1099 1100
      if (thd)
      {						// Normal thread
unknown's avatar
unknown committed
1101 1102 1103 1104 1105
	if ((thd->options & OPTION_LOG_OFF)
#ifndef NO_EMBEDDED_ACCESS_CHECKS
	    && (thd->master_access & SUPER_ACL)
#endif
)
unknown's avatar
unknown committed
1106 1107
	{
	  VOID(pthread_mutex_unlock(&LOCK_log));
1108
	  return 0;				// No logging
unknown's avatar
unknown committed
1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
	}
	id=thd->thread_id;
	if (thd->user_time || !(skr=thd->query_start()))
	  skr=time(NULL);			// Connected
      }
      else
      {						// Log from connect handler
	skr=time(NULL);
	id=0;
      }
      if (skr != last_time)
      {
	last_time=skr;
	struct tm tm_tmp;
	struct tm *start;
	localtime_r(&skr,&tm_tmp);
	start=&tm_tmp;
1126 1127 1128 1129 1130 1131 1132 1133
	/* Note that my_b_write() assumes it knows the length for this */
	sprintf(buff,"%02d%02d%02d %2d:%02d:%02d\t",
		start->tm_year % 100,
		start->tm_mon+1,
		start->tm_mday,
		start->tm_hour,
		start->tm_min,
		start->tm_sec);
unknown's avatar
unknown committed
1134
	if (my_b_write(&log_file, (byte*) buff,16))
unknown's avatar
unknown committed
1135 1136
	  error=errno;
      }
unknown's avatar
unknown committed
1137
      else if (my_b_write(&log_file, (byte*) "\t\t",2) < 0)
unknown's avatar
unknown committed
1138
	error=errno;
1139 1140 1141 1142
      length=my_sprintf(buff,
			(buff, "%7ld %-11.11s", id,
			 command_name[(uint) command]));
      if (my_b_write(&log_file, (byte*) buff,length))
unknown's avatar
unknown committed
1143 1144 1145
	error=errno;
      if (format)
      {
unknown's avatar
unknown committed
1146
	if (my_b_write(&log_file, (byte*) " ",1) ||
1147
	    my_b_vprintf(&log_file,format,args) == (uint) -1)
unknown's avatar
unknown committed
1148 1149
	  error=errno;
      }
unknown's avatar
unknown committed
1150
      if (my_b_write(&log_file, (byte*) "\n",1) ||
1151
	  flush_io_cache(&log_file))
unknown's avatar
unknown committed
1152 1153 1154 1155 1156 1157
	error=errno;
      if (error && ! write_error)
      {
	write_error=1;
	sql_print_error(ER(ER_ERROR_ON_WRITE),name,error);
      }
1158
      va_end(args);
unknown's avatar
unknown committed
1159 1160
    }
    VOID(pthread_mutex_unlock(&LOCK_log));
1161
    return error != 0;
unknown's avatar
unknown committed
1162
  }
1163
  return 0;
unknown's avatar
unknown committed
1164 1165 1166
}


1167 1168 1169 1170
/*
  Write an event to the binary log
*/

1171
bool MYSQL_LOG::write(Log_event* event_info)
unknown's avatar
unknown committed
1172
{
unknown's avatar
unknown committed
1173 1174
  THD *thd=event_info->thd;
  bool called_handler_commit=0;
unknown's avatar
unknown committed
1175
  bool error=0;
1176
  bool should_rotate = 0;
1177
  DBUG_ENTER("MYSQL_LOG::write(event)");
1178
  
1179 1180
  pthread_mutex_lock(&LOCK_log);

unknown's avatar
unknown committed
1181 1182 1183 1184 1185
  /* 
     In most cases this is only called if 'is_open()' is true; in fact this is
     mostly called if is_open() *was* true a few instructions before, but it
     could have changed since.
  */
1186
  if (is_open())
unknown's avatar
unknown committed
1187
  {
unknown's avatar
unknown committed
1188 1189
    const char *local_db= event_info->get_db();
    IO_CACHE *file= &log_file;
unknown's avatar
unknown committed
1190
#ifdef USING_TRANSACTIONS    
unknown's avatar
unknown committed
1191 1192 1193 1194 1195 1196 1197 1198 1199
    /*
      Should we write to the binlog cache or to the binlog on disk?
      Write to the binlog cache if:
      - it is already not empty (meaning we're in a transaction; note that the
     present event could be about a non-transactional table, but still we need
     to write to the binlog cache in that case to handle updates to mixed
     trans/non-trans table types the best possible in binlogging)
      - or if the event asks for it (cache_stmt == true).
    */
unknown's avatar
unknown committed
1200 1201 1202 1203 1204
    if (opt_using_transactions &&
	(event_info->get_cache_stmt() ||
	 (thd && my_b_tell(&thd->transaction.trans_log))))
      file= &thd->transaction.trans_log;
#endif
unknown's avatar
unknown committed
1205
    DBUG_PRINT("info",("event type=%d",event_info->get_type_code()));
unknown's avatar
SCRUM  
unknown committed
1206
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
1207 1208 1209 1210 1211
    /* 
       In the future we need to add to the following if tests like
       "do the involved tables match (to be implemented)
        binlog_[wild_]{do|ignore}_table?" (WL#1049)"
    */
1212
    if ((thd && !(thd->options & OPTION_BIN_LOG)) ||
1213
	(local_db && !db_ok(local_db, binlog_do_db, binlog_ignore_db)))
unknown's avatar
unknown committed
1214
    {
1215
      VOID(pthread_mutex_unlock(&LOCK_log));
1216 1217
      DBUG_PRINT("error",("!db_ok"));
      DBUG_RETURN(0);
1218
    }
unknown's avatar
SCRUM  
unknown committed
1219
#endif /* HAVE_REPLICATION */
1220

unknown's avatar
unknown committed
1221
    error=1;
unknown's avatar
unknown committed
1222 1223 1224 1225
    /*
      No check for auto events flag here - this write method should
      never be called if auto-events are enabled
    */
unknown's avatar
unknown committed
1226 1227 1228 1229 1230 1231

    /*
    1. Write first log events which describe the 'run environment'
    of the SQL command
    */

1232
    if (thd)
1233
    {
1234 1235 1236
      if (thd->last_insert_id_used)
      {
	Intvar_log_event e(thd,(uchar) LAST_INSERT_ID_EVENT,
1237
			   thd->current_insert_id);
1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255
	e.set_log_pos(this);
	if (e.write(file))
	  goto err;
      }
      if (thd->insert_id_used)
      {
	Intvar_log_event e(thd,(uchar) INSERT_ID_EVENT,thd->last_insert_id);
	e.set_log_pos(this);
	if (e.write(file))
	  goto err;
      }
      if (thd->rand_used)
      {
	Rand_log_event e(thd,thd->rand_saved_seed1,thd->rand_saved_seed2);
	e.set_log_pos(this);
	if (e.write(file))
	  goto err;
      }
unknown's avatar
unknown committed
1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272
      if (thd->user_var_events.elements)
      {
	for (uint i= 0; i < thd->user_var_events.elements; i++)
	{
	  BINLOG_USER_VAR_EVENT *user_var_event;
	  get_dynamic(&thd->user_var_events,(gptr) &user_var_event, i);
          User_var_log_event e(thd, user_var_event->user_var_event->name.str,
                               user_var_event->user_var_event->name.length,
                               user_var_event->value,
                               user_var_event->length,
                               user_var_event->type,
			       user_var_event->charset_number);
          e.set_log_pos(this);
	  if (e.write(file))
	    goto err;
	}
      }
unknown's avatar
unknown committed
1273
#ifdef TO_BE_REMOVED
1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
      if (thd->variables.convert_set)
      {
	char buf[256], *p;
	p= strmov(strmov(buf, "SET CHARACTER SET "),
		  thd->variables.convert_set->name);
	Query_log_event e(thd, buf, (ulong) (p - buf), 0);
	e.set_log_pos(this);
	if (e.write(file))
	  goto err;
      }
unknown's avatar
unknown committed
1284
#endif
unknown's avatar
unknown committed
1285

unknown's avatar
unknown committed
1286 1287 1288 1289 1290 1291 1292
      /*
	If the user has set FOREIGN_KEY_CHECKS=0 we wrap every SQL
	command in the binlog inside:
	SET FOREIGN_KEY_CHECKS=0;
	<command>;
	SET FOREIGN_KEY_CHECKS=1;
      */
unknown's avatar
unknown committed
1293 1294 1295

      if (thd->options & OPTION_NO_FOREIGN_KEY_CHECKS)
      {
unknown's avatar
unknown committed
1296
	Query_log_event e(thd, "SET FOREIGN_KEY_CHECKS=0", 24, 0);
unknown's avatar
unknown committed
1297 1298 1299 1300
	e.set_log_pos(this);
	if (e.write(file))
	  goto err;
      }
1301
    }
unknown's avatar
unknown committed
1302

unknown's avatar
unknown committed
1303
    /* Write the SQL command */
unknown's avatar
unknown committed
1304

1305
    event_info->set_log_pos(this);
unknown's avatar
unknown committed
1306
    if (event_info->write(file))
1307
      goto err;
unknown's avatar
unknown committed
1308

unknown's avatar
unknown committed
1309
    /* Write log events to reset the 'run environment' of the SQL command */
unknown's avatar
unknown committed
1310 1311 1312

    if (thd && thd->options & OPTION_NO_FOREIGN_KEY_CHECKS)
    {
unknown's avatar
unknown committed
1313
      Query_log_event e(thd, "SET FOREIGN_KEY_CHECKS=1", 24, 0);
unknown's avatar
unknown committed
1314
      e.set_log_pos(this);
unknown's avatar
unknown committed
1315
      if (e.write(file))
unknown's avatar
unknown committed
1316 1317
	goto err;
    }
1318

unknown's avatar
unknown committed
1319 1320 1321 1322 1323 1324 1325 1326
    /*
      Tell for transactional table handlers up to which position in the
      binlog file we wrote. The table handler can store this info, and
      after crash recovery print for the user the offset of the last
      transactions which were recovered. Actually, we must also call
      the table handler commit here, protected by the LOCK_log mutex,
      because otherwise the transactions may end up in a different order
      in the table handler log!
unknown's avatar
unknown committed
1327 1328 1329 1330 1331 1332 1333

      Note that we will NOT call ha_report_binlog_offset_and_commit() if
      there are binlog events cached in the transaction cache. That is
      because then the log event which we write to the binlog here is
      not a transactional event. In versions < 4.0.13 before this fix this
      caused an InnoDB transaction to be committed if in the middle there
      was a MyISAM event!
unknown's avatar
unknown committed
1334
    */
1335

1336
    if (file == &log_file) // we are writing to the real log (disk)
unknown's avatar
unknown committed
1337
    {
unknown's avatar
unknown committed
1338 1339 1340
      if (flush_io_cache(file))
	goto err;
 
1341
      if (opt_using_transactions && !my_b_tell(&thd->transaction.trans_log))
unknown's avatar
unknown committed
1342
      {
1343 1344 1345 1346 1347 1348 1349
        /*
          LOAD DATA INFILE in AUTOCOMMIT=1 mode writes to the binlog
          chunks also before it is successfully completed. We only report
          the binlog write and do the commit inside the transactional table
          handler if the log event type is appropriate.
        */
        
unknown's avatar
unknown committed
1350 1351
        if (event_info->get_type_code() == QUERY_EVENT ||
            event_info->get_type_code() == EXEC_LOAD_EVENT)
1352 1353 1354 1355 1356
        {
          error = ha_report_binlog_offset_and_commit(thd, log_file_name,
                                                     file->pos_in_file);
          called_handler_commit=1;
        }
unknown's avatar
unknown committed
1357
      }
1358
      /* We wrote to the real log, check automatic rotation; */
unknown's avatar
unknown committed
1359
      DBUG_PRINT("info",("max_size: %lu",max_size));      
1360
      should_rotate= (my_b_tell(file) >= (my_off_t) max_size); 
1361
    }
unknown's avatar
unknown committed
1362
    error=0;
1363

1364 1365 1366 1367 1368 1369 1370 1371 1372 1373
err:
    if (error)
    {
      if (my_errno == EFBIG)
	my_error(ER_TRANS_CACHE_FULL, MYF(0));
      else
	my_error(ER_ERROR_ON_WRITE, MYF(0), name, errno);
      write_error=1;
    }
    if (file == &log_file)
1374
      signal_update();
1375
    if (should_rotate)
1376 1377 1378 1379 1380
    {
      pthread_mutex_lock(&LOCK_index);      
      new_file(0); // inside mutex
      pthread_mutex_unlock(&LOCK_index);
    }
1381
  }
1382 1383

  pthread_mutex_unlock(&LOCK_log);
unknown's avatar
unknown committed
1384

unknown's avatar
unknown committed
1385 1386 1387 1388
  /*
    Flush the transactional handler log file now that we have released
    LOCK_log; the flush is placed here to eliminate the bottleneck on the
    group commit
unknown's avatar
unknown committed
1389
  */
unknown's avatar
unknown committed
1390

unknown's avatar
unknown committed
1391
  if (called_handler_commit)
unknown's avatar
unknown committed
1392 1393
    ha_commit_complete(thd);

unknown's avatar
unknown committed
1394
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
1395
  if (should_rotate && expire_logs_days)
1396 1397 1398
  {
    long purge_time= time(0) - expire_logs_days*24*60*60;
    if (purge_time >= 0)
1399
      error= purge_logs_before_date(purge_time);
1400
  }
unknown's avatar
unknown committed
1401
#endif
1402
  DBUG_RETURN(error);
1403 1404
}

1405

unknown's avatar
unknown committed
1406 1407 1408 1409 1410 1411 1412 1413 1414
uint MYSQL_LOG::next_file_id()
{
  uint res;
  pthread_mutex_lock(&LOCK_log);
  res = file_id++;
  pthread_mutex_unlock(&LOCK_log);
  return res;
}

1415

1416 1417
/*
  Write a cached log entry to the binary log
1418

unknown's avatar
unknown committed
1419 1420 1421 1422 1423 1424 1425
  SYNOPSIS
    write()
    thd 		
    cache		The cache to copy to the binlog
    commit_or_rollback  If true, will write "COMMIT" in the end, if false will
                        write "ROLLBACK".

1426 1427
  NOTE
    - We only come here if there is something in the cache.
unknown's avatar
unknown committed
1428
    - The thing in the cache is always a complete transaction
1429 1430 1431 1432
    - 'cache' needs to be reinitialized after this functions returns.

  IMPLEMENTATION
    - To support transaction over replication, we wrap the transaction
unknown's avatar
unknown committed
1433 1434 1435 1436
      with BEGIN/COMMIT or BEGIN/ROLLBACK in the binary log.
      We want to write a BEGIN/ROLLBACK block when a non-transactional table was
      updated in a transaction which was rolled back. This is to ensure that the
      same updates are run on the slave.
1437 1438
*/

unknown's avatar
unknown committed
1439
bool MYSQL_LOG::write(THD *thd, IO_CACHE *cache, bool commit_or_rollback)
1440 1441
{
  VOID(pthread_mutex_lock(&LOCK_log));
1442
  DBUG_ENTER("MYSQL_LOG::write(cache");
1443
  
1444
  if (is_open())				// Should always be true
1445
  {
1446 1447
    uint length;

unknown's avatar
unknown committed
1448
    /*
1449 1450 1451 1452 1453 1454 1455 1456
      Add the "BEGIN" and "COMMIT" in the binlog around transactions
      which may contain more than 1 SQL statement. If we run with
      AUTOCOMMIT=1, then MySQL immediately writes each SQL statement to
      the binlog when the statement has been completed. No need to add
      "BEGIN" ... "COMMIT" around such statements. Otherwise, MySQL uses
      thd->transaction.trans_log to cache the SQL statements until the
      explicit commit, and at the commit writes the contents in .trans_log
      to the binlog.
unknown's avatar
unknown committed
1457

1458 1459 1460 1461 1462 1463
      We write the "BEGIN" mark first in the buffer (.trans_log) where we
      store the SQL statements for a transaction. At the transaction commit
      we will add the "COMMIT mark and write the buffer to the binlog.
    */
    {
      Query_log_event qinfo(thd, "BEGIN", 5, TRUE);
1464 1465 1466
      /*
        Now this Query_log_event has artificial log_pos 0. It must be adjusted
        to reflect the real position in the log. Not doing it would confuse the
1467 1468 1469
	slave: it would prevent this one from knowing where he is in the
	master's binlog, which would result in wrong positions being shown to
	the user, MASTER_POS_WAIT undue waiting etc.
1470 1471
      */
      qinfo.set_log_pos(this);
1472 1473 1474
      if (qinfo.write(&log_file))
	goto err;
    }
unknown's avatar
unknown committed
1475
    /* Read from the file used to cache the queries .*/
unknown's avatar
unknown committed
1476
    if (reinit_io_cache(cache, READ_CACHE, 0, 0, 0))
1477
      goto err;
1478 1479
    length=my_b_bytes_in_cache(cache);
    do
1480
    {
unknown's avatar
unknown committed
1481
      /* Write data to the binary log file */
unknown's avatar
unknown committed
1482
      if (my_b_write(&log_file, cache->read_pos, length))
1483
	goto err;
unknown's avatar
unknown committed
1484
      cache->read_pos=cache->read_end;		// Mark buffer used up
1485
    } while ((length=my_b_fill(cache)));
1486 1487 1488 1489 1490 1491

    /*
      We write the command "COMMIT" as the last SQL command in the
      binlog segment cached for this transaction
    */

1492
    {
unknown's avatar
unknown committed
1493 1494 1495 1496
      Query_log_event qinfo(thd, 
                            commit_or_rollback ? "COMMIT" : "ROLLBACK",
                            commit_or_rollback ? 6        : 8, 
                            TRUE);
1497
      qinfo.set_log_pos(this);
1498 1499
      if (qinfo.write(&log_file) || flush_io_cache(&log_file))
	goto err;
1500 1501 1502
    }
    if (cache->error)				// Error on read
    {
unknown's avatar
unknown committed
1503
      sql_print_error(ER(ER_ERROR_ON_READ), cache->file_name, errno);
1504
      write_error=1;				// Don't give more errors
1505
      goto err;
unknown's avatar
unknown committed
1506
    }
1507 1508
    if ((ha_report_binlog_offset_and_commit(thd, log_file_name,
					    log_file.pos_in_file)))
1509
      goto err;
1510
    signal_update();
unknown's avatar
unknown committed
1511
    DBUG_PRINT("info",("max_size: %lu",max_size));
1512
    if (my_b_tell(&log_file) >= (my_off_t) max_size)
1513 1514 1515 1516 1517 1518
    {
      pthread_mutex_lock(&LOCK_index);
      new_file(0); // inside mutex
      pthread_mutex_unlock(&LOCK_index);
    }

unknown's avatar
unknown committed
1519
  }
1520
  VOID(pthread_mutex_unlock(&LOCK_log));
unknown's avatar
unknown committed
1521 1522 1523 1524 1525 1526 1527

  /* Flush the transactional handler log file now that we have released
  LOCK_log; the flush is placed here to eliminate the bottleneck on the
  group commit */  

  ha_commit_complete(thd);

1528
  DBUG_RETURN(0);
1529 1530

err:
1531 1532 1533 1534 1535
  if (!write_error)
  {
    write_error= 1;
    sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
  }
1536
  VOID(pthread_mutex_unlock(&LOCK_log));
1537
  DBUG_RETURN(1);
unknown's avatar
unknown committed
1538 1539
}

1540

1541 1542
/*
  Write update log in a format suitable for incremental backup
1543
  This is also used by the slow query log.
1544
*/
unknown's avatar
unknown committed
1545

1546
bool MYSQL_LOG::write(THD *thd,const char *query, uint query_length,
1547
		      time_t query_start_arg)
unknown's avatar
unknown committed
1548
{
1549
  bool error=0;
unknown's avatar
unknown committed
1550
  time_t current_time;
unknown's avatar
unknown committed
1551 1552
  if (!is_open())
    return 0;
unknown's avatar
unknown committed
1553
  VOID(pthread_mutex_lock(&LOCK_log));
1554
  if (is_open())
unknown's avatar
unknown committed
1555 1556 1557 1558
  {						// Safety agains reopen
    int tmp_errno=0;
    char buff[80],*end;
    end=buff;
1559
    if (!(thd->options & OPTION_UPDATE_LOG))
unknown's avatar
unknown committed
1560 1561 1562 1563
    {
      VOID(pthread_mutex_unlock(&LOCK_log));
      return 0;
    }
1564
    if (!(specialflag & SPECIAL_SHORT_LOG_FORMAT) || query_start_arg)
unknown's avatar
unknown committed
1565 1566 1567
    {
      current_time=time(NULL);
      if (current_time != last_time)
unknown's avatar
unknown committed
1568
      {
unknown's avatar
unknown committed
1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583
        last_time=current_time;
        struct tm tm_tmp;
        struct tm *start;
        localtime_r(&current_time,&tm_tmp);
        start=&tm_tmp;
        /* Note that my_b_write() assumes it knows the length for this */
        sprintf(buff,"# Time: %02d%02d%02d %2d:%02d:%02d\n",
                start->tm_year % 100,
                start->tm_mon+1,
                start->tm_mday,
                start->tm_hour,
                start->tm_min,
                start->tm_sec);
        if (my_b_write(&log_file, (byte*) buff,24))
          tmp_errno=errno;
unknown's avatar
unknown committed
1584
      }
unknown's avatar
unknown committed
1585
      if (my_b_printf(&log_file, "# User@Host: %s[%s] @ %s [%s]\n",
unknown's avatar
unknown committed
1586 1587
                      thd->priv_user ? thd->priv_user : "",
                      thd->user ? thd->user : "",
unknown's avatar
unknown committed
1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
                      thd->host ? thd->host : "",
                      thd->ip ? thd->ip : "") == (uint) -1)
        tmp_errno=errno;
    }
    if (query_start_arg)
    {
      /* For slow query log */
      if (my_b_printf(&log_file,
                      "# Query_time: %lu  Lock_time: %lu  Rows_sent: %lu  Rows_examined: %lu\n",
                      (ulong) (current_time - query_start_arg),
                      (ulong) (thd->time_after_lock - query_start_arg),
                      (ulong) thd->sent_row_count,
                      (ulong) thd->examined_row_count) == (uint) -1)
        tmp_errno=errno;
    }
    if (thd->db && strcmp(thd->db,db))
    {						// Database changed
      if (my_b_printf(&log_file,"use %s;\n",thd->db) == (uint) -1)
        tmp_errno=errno;
      strmov(db,thd->db);
    }
    if (thd->last_insert_id_used)
    {
      end=strmov(end,",last_insert_id=");
      end=longlong10_to_str((longlong) thd->current_insert_id,end,-10);
    }
    // Save value if we do an insert.
    if (thd->insert_id_used)
    {
1617
      if (!(specialflag & SPECIAL_SHORT_LOG_FORMAT))
unknown's avatar
unknown committed
1618
      {
unknown's avatar
unknown committed
1619 1620
        end=strmov(end,",insert_id=");
        end=longlong10_to_str((longlong) thd->last_insert_id,end,-10);
unknown's avatar
unknown committed
1621
      }
unknown's avatar
unknown committed
1622 1623 1624 1625
    }
    if (thd->query_start_used)
    {
      if (query_start_arg != thd->query_start())
unknown's avatar
unknown committed
1626
      {
unknown's avatar
unknown committed
1627 1628 1629
        query_start_arg=thd->query_start();
        end=strmov(end,",timestamp=");
        end=int10_to_str((long) query_start_arg,end,10);
unknown's avatar
unknown committed
1630
      }
unknown's avatar
unknown committed
1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654
    }
    if (end != buff)
    {
      *end++=';';
      *end='\n';
      if (my_b_write(&log_file, (byte*) "SET ",4) ||
          my_b_write(&log_file, (byte*) buff+1,(uint) (end-buff)))
        tmp_errno=errno;
    }
    if (!query)
    {
      end=strxmov(buff, "# administrator command: ",
                  command_name[thd->command], NullS);
      query_length=(ulong) (end-buff);
      query=buff;
    }
    if (my_b_write(&log_file, (byte*) query,query_length) ||
        my_b_write(&log_file, (byte*) ";\n",2) ||
        flush_io_cache(&log_file))
      tmp_errno=errno;
    if (tmp_errno)
    {
      error=1;
      if (! write_error)
unknown's avatar
unknown committed
1655
      {
unknown's avatar
unknown committed
1656 1657
        write_error=1;
        sql_print_error(ER(ER_ERROR_ON_WRITE),name,error);
unknown's avatar
unknown committed
1658 1659 1660
      }
    }
  }
unknown's avatar
unknown committed
1661
  VOID(pthread_mutex_unlock(&LOCK_log));
1662
  return error;
unknown's avatar
unknown committed
1663 1664
}

unknown's avatar
unknown committed
1665

1666 1667 1668 1669 1670 1671
/*
  Wait until we get a signal that the binary log has been updated

  SYNOPSIS
    wait_for_update()
    thd			Thread variable
1672 1673 1674
    master_or_slave     If 0, the caller is the Binlog_dump thread from master;
                        if 1, the caller is the SQL thread from the slave. This
                        influences only thd->proc_info.
1675 1676 1677

  NOTES
    One must have a lock on LOCK_log before calling this function.
1678 1679 1680 1681 1682 1683
    This lock will be freed before return!

    The reason for the above is that for enter_cond() / exit_cond() to
    work the mutex must be got before enter_cond() but releases before
    exit_cond().
    If you don't do it this way, you will get a deadlock in THD::awake()
1684 1685
*/

1686
void MYSQL_LOG:: wait_for_update(THD* thd, bool master_or_slave)
1687
{
1688
  safe_mutex_assert_owner(&LOCK_log);
1689
  const char* old_msg = thd->enter_cond(&update_cond, &LOCK_log,
1690 1691
                                        master_or_slave ?
                                        "Has read all relay log; waiting for \
1692
the slave I/O thread to update it" : 
1693 1694
                                        "Has sent all binlog to slave; \
waiting for binlog to be updated"); 
1695
  pthread_cond_wait(&update_cond, &LOCK_log);
1696
  pthread_mutex_unlock(&LOCK_log);		// See NOTES
1697
  thd->exit_cond(old_msg);
1698
}
unknown's avatar
unknown committed
1699

unknown's avatar
unknown committed
1700

1701 1702 1703 1704 1705
/*
  Close the log file

  SYNOPSIS
    close()
1706 1707 1708 1709 1710
    exiting	Bitmask for one or more of the following bits:
    		LOG_CLOSE_INDEX if we should close the index file
		LOG_CLOSE_TO_BE_OPENED if we intend to call open
		at once after close.
		LOG_CLOSE_STOP_EVENT write a 'stop' event to the log
unknown's avatar
unknown committed
1711 1712 1713 1714

  NOTES
    One can do an open on the object at once after doing a close.
    The internal structures are not freed until cleanup() is called
1715 1716
*/

1717
void MYSQL_LOG::close(uint exiting)
unknown's avatar
unknown committed
1718
{					// One can't set log_type here!
1719 1720
  DBUG_ENTER("MYSQL_LOG::close");
  DBUG_PRINT("enter",("exiting: %d", (int) exiting));
unknown's avatar
unknown committed
1721
  if (log_type != LOG_CLOSED && log_type != LOG_TO_BE_OPENED)
unknown's avatar
unknown committed
1722
  {
unknown's avatar
SCRUM  
unknown committed
1723
#ifdef HAVE_REPLICATION
1724 1725
    if (log_type == LOG_BIN && !no_auto_events &&
	(exiting & LOG_CLOSE_STOP_EVENT))
unknown's avatar
unknown committed
1726 1727
    {
      Stop_log_event s;
1728
      s.set_log_pos(this);
1729
      s.write(&log_file);
1730
      signal_update();
unknown's avatar
unknown committed
1731
    }
unknown's avatar
SCRUM  
unknown committed
1732
#endif /* HAVE_REPLICATION */
1733
    end_io_cache(&log_file);
1734
    if (my_close(log_file.file,MYF(0)) < 0 && ! write_error)
unknown's avatar
unknown committed
1735 1736
    {
      write_error=1;
1737
      sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
unknown's avatar
unknown committed
1738 1739
    }
  }
1740 1741 1742 1743 1744 1745

  /*
    The following test is needed even if is_open() is not set, as we may have
    called a not complete close earlier and the index file is still open.
  */

1746
  if ((exiting & LOG_CLOSE_INDEX) && my_b_inited(&index_file))
1747
  {
1748 1749
    end_io_cache(&index_file);
    if (my_close(index_file.file, MYF(0)) < 0 && ! write_error)
unknown's avatar
unknown committed
1750
    {
1751 1752
      write_error= 1;
      sql_print_error(ER(ER_ERROR_ON_WRITE), index_file_name, errno);
unknown's avatar
unknown committed
1753
    }
1754
  }
1755
  log_type= (exiting & LOG_CLOSE_TO_BE_OPENED) ? LOG_TO_BE_OPENED : LOG_CLOSED;
1756
  safeFree(name);
1757
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1758 1759 1760
}


1761 1762 1763 1764 1765 1766 1767 1768 1769
void MYSQL_LOG::set_max_size(ulong max_size_arg)
{
  /*
    We need to take locks, otherwise this may happen:
    new_file() is called, calls open(old_max_size), then before open() starts,
    set_max_size() sets max_size to max_size_arg, then open() starts and
    uses the old_max_size argument, so max_size_arg has been overwritten and
    it's like if the SET command was never run.
  */
unknown's avatar
unknown committed
1770 1771
  DBUG_ENTER("MYSQL_LOG::set_max_size");
  pthread_mutex_lock(&LOCK_log);
1772 1773
  if (is_open())
    max_size= max_size_arg;
unknown's avatar
unknown committed
1774 1775
  pthread_mutex_unlock(&LOCK_log);
  DBUG_VOID_RETURN;
1776
}
unknown's avatar
unknown committed
1777

unknown's avatar
unknown committed
1778

1779 1780
/*
  Check if a string is a valid number
1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794

  SYNOPSIS
    test_if_number()
    str			String to test
    res			Store value here
    allow_wildcards	Set to 1 if we should ignore '%' and '_'

  NOTE
    For the moment the allow_wildcards argument is not used
    Should be move to some other file.

  RETURN VALUES
    1	String is a number
    0	Error
1795
*/
unknown's avatar
unknown committed
1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807

static bool test_if_number(register const char *str,
			   long *res, bool allow_wildcards)
{
  reg2 int flag;
  const char *start;
  DBUG_ENTER("test_if_number");

  flag=0; start=str;
  while (*str++ == ' ') ;
  if (*--str == '-' || *str == '+')
    str++;
1808 1809
  while (my_isdigit(files_charset_info,*str) ||
	 (allow_wildcards && (*str == wild_many || *str == wild_one)))
unknown's avatar
unknown committed
1810 1811 1812 1813 1814 1815 1816
  {
    flag=1;
    str++;
  }
  if (*str == '.')
  {
    for (str++ ;
1817
	 my_isdigit(files_charset_info,*str) ||
unknown's avatar
unknown committed
1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841
	   (allow_wildcards && (*str == wild_many || *str == wild_one)) ;
	 str++, flag=1) ;
  }
  if (*str != 0 || flag == 0)
    DBUG_RETURN(0);
  if (res)
    *res=atol(start);
  DBUG_RETURN(1);			/* Number ok */
} /* test_if_number */


void sql_print_error(const char *format,...)
{
  va_list args;
  time_t skr;
  struct tm tm_tmp;
  struct tm *start;
  va_start(args,format);
  DBUG_ENTER("sql_print_error");

  VOID(pthread_mutex_lock(&LOCK_error_log));
#ifndef DBUG_OFF
  {
    char buff[1024];
1842
    my_vsnprintf(buff,sizeof(buff)-1,format,args);
unknown's avatar
unknown committed
1843
    DBUG_PRINT("error",("%s",buff));
1844
    va_end(args);
unknown's avatar
unknown committed
1845
    va_start(args,format);
unknown's avatar
unknown committed
1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875
  }
#endif
  skr=time(NULL);
  localtime_r(&skr,&tm_tmp);
  start=&tm_tmp;
  fprintf(stderr,"%02d%02d%02d %2d:%02d:%02d  ",
	  start->tm_year % 100,
	  start->tm_mon+1,
	  start->tm_mday,
	  start->tm_hour,
	  start->tm_min,
	  start->tm_sec);
  (void) vfprintf(stderr,format,args);
  (void) fputc('\n',stderr);
  fflush(stderr);
  va_end(args);

  VOID(pthread_mutex_unlock(&LOCK_error_log));
  DBUG_VOID_RETURN;
}


void sql_perror(const char *message)
{
#ifdef HAVE_STRERROR
  sql_print_error("%s: %s",message, strerror(errno));
#else
  perror(message);
#endif
}
1876

unknown's avatar
unknown committed
1877 1878 1879
bool flush_error_log()
{
  bool result=0;
1880
  if (opt_error_log)
unknown's avatar
unknown committed
1881 1882 1883 1884 1885 1886 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
  {
    char err_renamed[FN_REFLEN], *end;
    end= strmake(err_renamed,log_error_file,FN_REFLEN-4);
    strmov(end, "-old");
#ifdef __WIN__
    char err_temp[FN_REFLEN+4];
    /*
     On Windows is necessary a temporary file for to rename
     the current error file.
    */
    strmov(strmov(err_temp, err_renamed),"-tmp");
    (void) my_delete(err_temp, MYF(0)); 
    if (freopen(err_temp,"a+",stdout))
    {
      freopen(err_temp,"a+",stderr);
      (void) my_delete(err_renamed, MYF(0));
      my_rename(log_error_file,err_renamed,MYF(0));
      if (freopen(log_error_file,"a+",stdout))
        freopen(log_error_file,"a+",stderr);
      int fd, bytes;
      char buf[IO_SIZE];
      if ((fd = my_open(err_temp, O_RDONLY, MYF(0))) >= 0)
      {
        while ((bytes = (int) my_read(fd, (byte*) buf, IO_SIZE, MYF(0))) > 0)
             my_fwrite(stderr, (byte*) buf, (uint) strlen(buf),MYF(0));
        my_close(fd, MYF(0));
      }
      (void) my_delete(err_temp, MYF(0)); 
    }
    else
     result= 1;
#else
   my_rename(log_error_file,err_renamed,MYF(0));
   if (freopen(log_error_file,"a+",stdout))
     freopen(log_error_file,"a+",stderr);
   else
     result= 1;
#endif
  }
   return result;
}
unknown's avatar
unknown committed
1922

1923 1924