log.cc 64.7 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000-2003 MySQL AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4 5 6
   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.
unknown's avatar
unknown committed
7

unknown's avatar
unknown committed
8 9 10 11
   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.
unknown's avatar
unknown committed
12

unknown's avatar
unknown committed
13 14 15 16 17 18
   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
#include "mysql_priv.h"
unknown's avatar
unknown committed
26
#include "sql_repl.h"
unknown's avatar
unknown committed
27
#include "ha_innodb.h" // necessary to cut the binlog when crash recovery
unknown's avatar
unknown committed
28 29 30 31 32

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

unknown's avatar
unknown committed
33 34 35 36
#ifdef __NT__
#include "message.h"
#endif

unknown's avatar
unknown committed
37
MYSQL_LOG mysql_log,mysql_update_log,mysql_slow_log,mysql_bin_log;
38
ulong sync_binlog_counter= 0;
unknown's avatar
unknown committed
39 40 41 42

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

unknown's avatar
unknown committed
43 44
#ifdef __NT__
static int eventSource = 0;
unknown's avatar
unknown committed
45

unknown's avatar
unknown committed
46 47 48 49 50 51
void setup_windows_event_source() 
{
  HKEY    hRegKey= NULL; 
  DWORD   dwError= 0;
  TCHAR   szPath[MAX_PATH];
  DWORD dwTypes;
unknown's avatar
unknown committed
52
    
unknown's avatar
unknown committed
53 54 55
  if (eventSource)               // Ensure that we are only called once
    return;
  eventSource= 1;
unknown's avatar
unknown committed
56

unknown's avatar
unknown committed
57 58 59 60
  // Create the event source registry key
  dwError= RegCreateKey(HKEY_LOCAL_MACHINE, 
                          "SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\MySQL", 
                          &hRegKey);
unknown's avatar
unknown committed
61

unknown's avatar
unknown committed
62 63
  /* Name of the PE module that contains the message resource */
  GetModuleFileName(NULL, szPath, MAX_PATH);
unknown's avatar
unknown committed
64

unknown's avatar
unknown committed
65
  /* Register EventMessageFile */
unknown's avatar
unknown committed
66 67
  dwError = RegSetValueEx(hRegKey, "EventMessageFile", 0, REG_EXPAND_SZ, 
                          (PBYTE) szPath, strlen(szPath)+1);
unknown's avatar
unknown committed
68 69
    

unknown's avatar
unknown committed
70 71 72 73 74
  /* Register supported event types */
  dwTypes= (EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE |
            EVENTLOG_INFORMATION_TYPE);
  dwError= RegSetValueEx(hRegKey, "TypesSupported", 0, REG_DWORD,
                         (LPBYTE) &dwTypes, sizeof dwTypes);
unknown's avatar
unknown committed
75

unknown's avatar
unknown committed
76
  RegCloseKey(hRegKey);
unknown's avatar
unknown committed
77 78
}

unknown's avatar
unknown committed
79
#endif /* __NT__ */
unknown's avatar
unknown committed
80 81


unknown's avatar
unknown committed
82 83 84 85 86 87 88 89
/****************************************************************************
** 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)
{
90 91 92 93
  long                  number;
  uint                  i;
  char                  buff[FN_REFLEN];
  struct st_my_dir     *dir_info;
unknown's avatar
unknown committed
94
  reg1 struct fileinfo *file_info;
95 96
  ulong                 max_found=0;

unknown's avatar
unknown committed
97 98
  DBUG_ENTER("find_uniq_filename");

99 100 101 102
  uint  length = dirname_part(buff,name);
  char *start  = name + length;
  char *end    = strend(start);

unknown's avatar
unknown committed
103
  *end='.';
unknown's avatar
unknown committed
104
  length= (uint) (end-start+1);
unknown's avatar
unknown committed
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122

  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++='.';
123
  sprintf(end,"%06ld",max_found+1);
unknown's avatar
unknown committed
124 125 126
  DBUG_RETURN(0);
}

127

unknown's avatar
unknown committed
128
MYSQL_LOG::MYSQL_LOG()
129
  :bytes_written(0), last_time(0), query_start(0), name(0),
unknown's avatar
unknown committed
130
   file_id(1), open_count(1), log_type(LOG_CLOSED), write_error(0), inited(0),
131
   need_start_event(1)
unknown's avatar
unknown committed
132 133
{
  /*
unknown's avatar
unknown committed
134 135
    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
136 137
    called only in main(). Doing initialization here would make it happen
    before main(). 
unknown's avatar
unknown committed
138
  */
139 140
  index_file_name[0] = 0;
  bzero((char*) &log_file,sizeof(log_file));
141
  bzero((char*) &index_file, sizeof(index_file));
unknown's avatar
unknown committed
142 143
}

144

unknown's avatar
unknown committed
145
MYSQL_LOG::~MYSQL_LOG()
unknown's avatar
unknown committed
146 147 148 149
{
  cleanup();
}

unknown's avatar
unknown committed
150
/* this is called only once */
unknown's avatar
unknown committed
151

unknown's avatar
unknown committed
152
void MYSQL_LOG::cleanup()
unknown's avatar
unknown committed
153
{
154
  DBUG_ENTER("cleanup");
unknown's avatar
unknown committed
155
  if (inited)
156
  {
unknown's avatar
unknown committed
157
    inited= 0;
158
    close(LOG_CLOSE_INDEX);
159 160
    (void) pthread_mutex_destroy(&LOCK_log);
    (void) pthread_mutex_destroy(&LOCK_index);
unknown's avatar
unknown committed
161
    (void) pthread_cond_destroy(&update_cond);
162
  }
163
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
164 165
}

166

unknown's avatar
unknown committed
167 168
int MYSQL_LOG::generate_new_name(char *new_name, const char *log_name)
{      
169 170
  fn_format(new_name,log_name,mysql_data_home,"",4);
  if (log_type != LOG_NORMAL)
unknown's avatar
unknown committed
171 172 173 174 175 176 177 178 179 180 181 182 183
  {
    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;
}

184

185
void MYSQL_LOG::init(enum_log_type log_type_arg,
186
		     enum cache_type io_cache_type_arg,
187 188
		     bool no_auto_events_arg,
                     ulong max_size_arg)
189
{
190
  DBUG_ENTER("MYSQL_LOG::init");
191
  log_type = log_type_arg;
192
  io_cache_type = io_cache_type_arg;
193
  no_auto_events = no_auto_events_arg;
194
  max_size=max_size_arg;
unknown's avatar
unknown committed
195
  DBUG_PRINT("info",("log_type: %d max_size: %lu", log_type, max_size));
196
  DBUG_VOID_RETURN;
197 198
}

unknown's avatar
unknown committed
199

unknown's avatar
unknown committed
200 201
void MYSQL_LOG::init_pthread_objects()
{
unknown's avatar
unknown committed
202 203
  DBUG_ASSERT(inited == 0);
  inited= 1;
unknown's avatar
unknown committed
204 205 206
  (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);
207 208
}

unknown's avatar
unknown committed
209

210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
/*
  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,
227
		     bool no_auto_events_arg,
228
                     ulong max_size_arg)
unknown's avatar
unknown committed
229
{
230
  char buff[512];
231
  File file= -1, index_file_nr= -1;
232
  int open_flags = O_CREAT | O_APPEND | O_BINARY;
unknown's avatar
unknown committed
233
  DBUG_ENTER("MYSQL_LOG::open");
234 235 236 237
  DBUG_PRINT("enter",("log_type: %d",(int) log_type));

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

239
  init(log_type_arg,io_cache_type_arg,no_auto_events_arg,max_size_arg);
240 241 242
  
  if (!(name=my_strdup(log_name,MYF(MY_WME))))
    goto err;
unknown's avatar
unknown committed
243 244 245
  if (new_name)
    strmov(log_file_name,new_name);
  else if (generate_new_name(log_file_name, name))
246
    goto err;
247 248 249 250 251
  
  if (io_cache_type == SEQ_READ_APPEND)
    open_flags |= O_RDWR;
  else
    open_flags |= O_WRONLY;
252

unknown's avatar
unknown committed
253
  db[0]=0;
unknown's avatar
unknown committed
254
  open_count++;
255
  if ((file=my_open(log_file_name,open_flags,
256
		    MYF(MY_WME | ME_WAITTANG))) < 0 ||
257
      init_io_cache(&log_file, file, IO_SIZE, io_cache_type,
258 259
		    my_tell(file,MYF(MY_WME)), 0, MYF(MY_WME | MY_NABP)))
    goto err;
unknown's avatar
unknown committed
260

261 262
  switch (log_type) {
  case LOG_NORMAL:
unknown's avatar
unknown committed
263
  {
264
    char *end;
265
    int len=my_snprintf(buff, sizeof(buff), "%s, Version: %s. "
unknown's avatar
SCRUM  
unknown committed
266
#ifdef EMBEDDED_LIBRARY
267
		        "embedded library\n", my_progname, server_version
unknown's avatar
SCRUM  
unknown committed
268
#elif __NT__
269 270
			"started with:\nTCP Port: %d, Named Pipe: %s\n",
			my_progname, server_version, mysqld_port, mysqld_unix_port
unknown's avatar
unknown committed
271
#else
272 273
			"started with:\nTcp port: %d  Unix socket: %s\n",
			my_progname,server_version,mysqld_port,mysqld_unix_port
unknown's avatar
unknown committed
274
#endif
unknown's avatar
unknown committed
275
                       );
276 277
    end=strnmov(buff+len,"Time                 Id Command    Argument\n",
                sizeof(buff)-len);
unknown's avatar
unknown committed
278
    if (my_b_write(&log_file, (byte*) buff,(uint) (end-buff)) ||
279 280
	flush_io_cache(&log_file))
      goto err;
281
    break;
unknown's avatar
unknown committed
282
  }
283
  case LOG_NEW:
unknown's avatar
unknown committed
284
  {
285
    uint len;
unknown's avatar
unknown committed
286 287
    time_t skr=time(NULL);
    struct tm tm_tmp;
288

unknown's avatar
unknown committed
289
    localtime_r(&skr,&tm_tmp);
290 291 292 293 294 295 296 297 298 299
    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) ||
300 301
	flush_io_cache(&log_file))
      goto err;
302
    break;
unknown's avatar
unknown committed
303
  }
304
  case LOG_BIN:
unknown's avatar
unknown committed
305
  {
306 307 308 309
    bool write_file_name_to_index_file=0;

    myf opt= MY_UNPACK_FILENAME;
    if (!index_file_name_arg)
unknown's avatar
unknown committed
310
    {
311 312 313
      index_file_name_arg= name;	// Use same basename for index file
      opt= MY_UNPACK_FILENAME | MY_REPLACE_EXT;
    }
314

315 316 317 318 319 320 321 322
    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
323 324
      if (my_b_safe_write(&log_file, (byte*) BINLOG_MAGIC,
			  BIN_LOG_HEADER_SIZE))
unknown's avatar
unknown committed
325
        goto err;
unknown's avatar
unknown committed
326
      bytes_written += BIN_LOG_HEADER_SIZE;
327
      write_file_name_to_index_file=1;
unknown's avatar
unknown committed
328
    }
unknown's avatar
unknown committed
329

330 331 332 333 334 335 336 337 338 339 340 341
    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 ||
unknown's avatar
unknown committed
342
          my_sync(index_file_nr, MYF(MY_WME)) ||
343 344 345 346 347 348 349 350 351 352 353 354
	  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);
    }
355
    if (need_start_event && !no_auto_events)
356
    {
357
      need_start_event=0;
358
      Start_log_event s;
359
      s.set_log_pos(this);
360 361
      s.write(&log_file);
    }
unknown's avatar
unknown committed
362 363
    if (flush_io_cache(&log_file) ||
        my_sync(log_file.file, MYF(MY_WME)))
unknown's avatar
unknown committed
364
      goto err;
365 366 367

    if (write_file_name_to_index_file)
    {
unknown's avatar
unknown committed
368 369 370 371
      /*
        As this is a new log file, we write the file name to the index
        file. As every time we write to the index file, we sync it.
      */
372 373 374
      if (my_b_write(&index_file, (byte*) log_file_name,
		     strlen(log_file_name)) ||
	  my_b_write(&index_file, (byte*) "\n", 1) ||
unknown's avatar
unknown committed
375 376
	  flush_io_cache(&index_file) ||
          my_sync(index_file.file, MYF(MY_WME)))
377
	goto err;
unknown's avatar
unknown committed
378
    }
379
    break;
unknown's avatar
unknown committed
380
  }
381
  case LOG_CLOSED:				// Impossible
382
  case LOG_TO_BE_OPENED:
383 384 385 386
    DBUG_ASSERT(1);
    break;
  }
  DBUG_RETURN(0);
387 388

err:
389 390 391 392
  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);
393 394
  if (file >= 0)
    my_close(file,MYF(0));
395 396
  if (index_file_nr >= 0)
    my_close(index_file_nr,MYF(0));
397
  end_io_cache(&log_file);
398 399
  end_io_cache(&index_file);
  safeFree(name);
400
  log_type= LOG_CLOSED;
401
  DBUG_RETURN(1);
unknown's avatar
unknown committed
402 403
}

404

unknown's avatar
unknown committed
405 406 407
int MYSQL_LOG::get_current_log(LOG_INFO* linfo)
{
  pthread_mutex_lock(&LOCK_log);
408 409
  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
410 411 412 413
  pthread_mutex_unlock(&LOCK_log);
  return 0;
}

unknown's avatar
unknown committed
414

415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
/*
  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' */
unknown's avatar
unknown committed
457 458
  if (my_chsize(file, offset - init_offset, '\n', MYF(MY_WME)) ||
      my_sync(file, MYF(MY_WME)))
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
    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
479
    need_lock		Set this to 1 if the parent doesn't already have a
480 481 482
			lock on LOCK_index

  NOTE
unknown's avatar
unknown committed
483 484
    On systems without the truncate function the file will end with one or
    more empty lines.  These will be ignored when reading the file.
485 486 487 488 489 490 491 492 493

  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
494
{
495 496 497 498 499
  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
500

unknown's avatar
unknown committed
501 502 503 504
  /*
    Mutex needed because we need to make sure the file pointer does not move
    from under our feet
  */
505
  if (need_lock)
506
    pthread_mutex_lock(&LOCK_index);
507 508 509 510 511
  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
512
  for (;;)
513
  {
514
    uint length;
515 516 517 518
    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
519
    {
520 521 522
      /* 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
523 524
    }

525 526
    // if the log entry matches, null string matching anything
    if (!log_name ||
unknown's avatar
unknown committed
527
	(log_name_len == length-1 && fname[log_name_len] == '\n' &&
528
	 !memcmp(fname, log_name, log_name_len)))
unknown's avatar
unknown committed
529
    {
530
      DBUG_PRINT("info",("Found log file entry"));
531
      fname[length-1]=0;			// remove last \n
532 533
      linfo->index_file_start_offset= offset;
      linfo->index_file_offset = my_b_tell(&index_file);
534
      break;
unknown's avatar
unknown committed
535
    }
536
  }
537

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

543

544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
/*
  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
*/

566
int MYSQL_LOG::find_next_log(LOG_INFO* linfo, bool need_lock)
unknown's avatar
unknown committed
567
{
568
  int error= 0;
569
  uint length;
570 571
  char *fname= linfo->log_file_name;

572 573
  if (need_lock)
    pthread_mutex_lock(&LOCK_index);
574 575 576 577 578 579 580 581
  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)
582
  {
583
    error = !index_file.error ? LOG_INFO_EOF : LOG_INFO_IO;
584 585 586
    goto err;
  }
  fname[length-1]=0;				// kill /n
587
  linfo->index_file_offset = my_b_tell(&index_file);
588

unknown's avatar
unknown committed
589
err:
590 591
  if (need_lock)
    pthread_mutex_unlock(&LOCK_index);
unknown's avatar
unknown committed
592 593 594
  return error;
}

unknown's avatar
unknown committed
595

596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614
/*
  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)
615 616
{
  LOG_INFO linfo;
617
  bool error=0;
618 619
  const char* save_name;
  enum_log_type save_log_type;
620
  DBUG_ENTER("reset_logs");
621

622 623 624 625
  /*
    We need to get both locks to be sure that no one is trying to
    write to the index log file.
  */
626
  pthread_mutex_lock(&LOCK_log);
627 628 629 630 631 632
  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;
633
  close(LOG_CLOSE_TO_BE_OPENED);
634 635 636 637

  /* First delete all old log files */

  if (find_log_pos(&linfo, NullS, 0))
638 639 640 641 642
  {
    error=1;
    goto err;
  }
  
unknown's avatar
unknown committed
643
  for (;;)
644 645
  {
    my_delete(linfo.log_file_name, MYF(MY_WME));
646
    if (find_next_log(&linfo, 0))
647 648
      break;
  }
649 650

  /* Start logging with a new file */
unknown's avatar
unknown committed
651
  close(LOG_CLOSE_INDEX);
652 653
  my_delete(index_file_name, MYF(MY_WME));	// Reset (open will update)
  if (!thd->slave_thread)
654
    need_start_event=1;
655
  open(save_name, save_log_type, 0, index_file_name,
656
       io_cache_type, no_auto_events, max_size);
657
  my_free((gptr) save_name, MYF(0));
658

659
err:  
660
  pthread_mutex_unlock(&LOCK_index);
661
  pthread_mutex_unlock(&LOCK_log);
662
  DBUG_RETURN(error);
663 664
}

unknown's avatar
unknown committed
665

666
/*
667 668 669
  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.
670 671 672

  SYNOPSIS
    purge_first_log()
673 674 675 676 677 678
    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).
    
679 680
  NOTE
    - This is only called from the slave-execute thread when it has read
681 682 683 684 685
      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).
686 687 688

  IMPLEMENTATION
    - Protects index file with LOCK_index
689 690
    - Delete relevant relay log files
    - Copy all file names after these ones to the front of the index file
691
    - If the OS has truncate, truncate the file, else fill it with \n'
692
    - Read the next file name from the index file and store in rli->linfo
693 694

  RETURN VALUES
695 696 697 698
    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
699 700
*/

unknown's avatar
SCRUM  
unknown committed
701
#ifdef HAVE_REPLICATION
702

703
int MYSQL_LOG::purge_first_log(struct st_relay_log_info* rli, bool included) 
704
{
705
  int error;
706 707
  DBUG_ENTER("purge_first_log");

708 709
  DBUG_ASSERT(is_open());
  DBUG_ASSERT(rli->slave_running == 1);
710
  DBUG_ASSERT(!strcmp(rli->linfo.log_file_name,rli->event_relay_log_name));
711

712
  pthread_mutex_lock(&LOCK_index);
713 714 715 716 717 718
  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
719 720

  /*
721 722 723
    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
724
  */
725 726 727 728 729
  pthread_cond_broadcast(&rli->log_space_cond);
  
  /*
    Read the next log file name from the index file and pass it back to
    the caller
730 731
    If included is true, we want the first relay log;
    otherwise we want the one after event_relay_log_name.
732
  */
733 734 735 736
  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)))))
737 738
  {
    char buff[22];
739 740 741 742 743
    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);
744 745
    goto err;
  }
746

747
  /*
748
    Reset rli's coordinates to the current log.
749
  */
750 751 752 753 754 755 756 757 758 759 760 761 762 763
  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);
764
    rli->notify_group_relay_log_name_update();
765
  }
766 767 768

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

770
err:
771
  pthread_mutex_unlock(&LOCK_index);
772
  DBUG_RETURN(error);
773 774
}

unknown's avatar
unknown committed
775 776 777 778
/*
  Update log index_file
*/

779
int MYSQL_LOG::update_log_index(LOG_INFO* log_info, bool need_update_threads)
unknown's avatar
unknown committed
780 781 782 783 784
{
  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
785 786
  if (need_update_threads)
    adjust_linfo_offsets(log_info->index_file_start_offset);
unknown's avatar
unknown committed
787 788
  return 0;
}
unknown's avatar
unknown committed
789

790 791 792 793 794
/*
  Remove all logs before the given log from disk and from the index file.

  SYNOPSIS
    purge_logs()
795 796 797 798 799 800 801
    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
802 803 804 805 806 807 808 809 810 811

  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
*/

812 813 814 815 816
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
817 818
{
  int error;
819
  bool exit_loop= 0;
820 821
  LOG_INFO log_info;
  DBUG_ENTER("purge_logs");
822
  DBUG_PRINT("info",("to_log= %s",to_log));
823

824 825
  if (need_mutex)
    pthread_mutex_lock(&LOCK_index);
826
  if ((error=find_log_pos(&log_info, to_log, 0 /*no mutex*/)))
827 828
    goto err;

829
  /*
830
    File name exists in index file; delete until we find this file
831 832 833
    or a file that is used.
  */
  if ((error=find_log_pos(&log_info, NullS, 0 /*no mutex*/)))
834
    goto err;
835 836
  while ((strcmp(to_log,log_info.log_file_name) || (exit_loop=included)) &&
         !log_in_use(log_info.log_file_name))
837
  {
838
    ulong tmp;
unknown's avatar
unknown committed
839
    LINT_INIT(tmp);
840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
    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)
863
      break;
864
  }
865

unknown's avatar
unknown committed
866 867 868 869
  /*
    If we get killed -9 here, the sysadmin would have to edit
    the log index file after restart - otherwise, this should be safe
  */
870
  error= update_log_index(&log_info, need_update_threads);
871

unknown's avatar
unknown committed
872
err:
873 874
  if (need_mutex)
    pthread_mutex_unlock(&LOCK_index);
875
  DBUG_RETURN(error);
unknown's avatar
unknown committed
876 877
}

878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895
/*
  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
*/

896
int MYSQL_LOG::purge_logs_before_date(time_t purge_time)
897 898 899 900 901 902 903 904 905 906 907 908 909 910 911
{
  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
912
    goto err;
913 914 915 916 917

  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
918 919
    if (!my_stat(log_info.log_file_name, &stat_area, MYF(0)) ||
	stat_area.st_mtime >= purge_time)
920
      break;
unknown's avatar
unknown committed
921
    my_delete(log_info.log_file_name, MYF(0));
922 923
    if (find_next_log(&log_info, 0))
      break;
unknown's avatar
unknown committed
924
  }
925

926 927 928 929
  /*
    If we get killed -9 here, the sysadmin would have to edit
    the log index file after restart - otherwise, this should be safe
  */
930
  error= update_log_index(&log_info, 1);
931

unknown's avatar
unknown committed
932 933
err:
  pthread_mutex_unlock(&LOCK_index);
934
  DBUG_RETURN(error);
unknown's avatar
unknown committed
935 936
}

937

unknown's avatar
SCRUM  
unknown committed
938
#endif /* HAVE_REPLICATION */
939

940 941 942 943 944 945 946 947 948 949 950 951

/*
  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
952 953
void MYSQL_LOG::make_log_name(char* buf, const char* log_ident)
{
unknown's avatar
unknown committed
954 955 956 957 958
  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
959 960
}

961 962 963 964 965 966

/*
  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
967
{
unknown's avatar
unknown committed
968
  return !strcmp(log_file_name, log_file_name_arg);
unknown's avatar
unknown committed
969 970
}

971 972 973 974 975 976 977 978 979 980 981 982 983 984

/*
  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
985
{
986 987 988
  char new_name[FN_REFLEN], *new_name_ptr, *old_name;
  enum_log_type save_log_type;

989
  DBUG_ENTER("MYSQL_LOG::new_file");
990
  if (!is_open())
991 992 993 994
  {
    DBUG_PRINT("info",("log is closed"));
    DBUG_VOID_RETURN;
  }
995 996

  if (need_lock)
unknown's avatar
unknown committed
997
  {
998 999 1000 1001 1002 1003
    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
1004
  /* Reuse old name if not binlog and not update log */
1005
  new_name_ptr= name;
unknown's avatar
unknown committed
1006

1007
  /*
1008 1009 1010
    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.
1011
  */
1012 1013 1014 1015 1016
  if (generate_new_name(new_name, name))
    goto end;
  new_name_ptr=new_name;
  
  if (log_type == LOG_BIN)
1017
  {
1018
    if (!no_auto_events)
unknown's avatar
unknown committed
1019
    {
1020
      /*
1021 1022
        We log the whole file name for log file as the user may decide
        to change base names at some point.
1023
      */
unknown's avatar
unknown committed
1024
      THD *thd = current_thd; /* may be 0 if we are reacting to SIGHUP */
1025 1026 1027 1028
      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
1029
    }
1030 1031 1032 1033 1034 1035
    /*
      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(); 
1036 1037 1038 1039
  }
  old_name=name;
  save_log_type=log_type;
  name=0;				// Don't free name
1040
  close(LOG_CLOSE_TO_BE_OPENED);
unknown's avatar
unknown committed
1041

unknown's avatar
unknown committed
1042
  /* 
unknown's avatar
unknown committed
1043
     Note that at this point, log_type != LOG_CLOSED (important for is_open()).
unknown's avatar
unknown committed
1044
  */
unknown's avatar
unknown committed
1045

1046
  open(old_name, save_log_type, new_name_ptr, index_file_name, io_cache_type,
1047
       no_auto_events, max_size);
unknown's avatar
unknown committed
1048 1049
  if (this == &mysql_bin_log)
    report_pos_in_innodb();
1050 1051
  my_free(old_name,MYF(0));

1052
end:
1053 1054 1055 1056
  if (need_lock)
  {
    pthread_mutex_unlock(&LOCK_index);
    pthread_mutex_unlock(&LOCK_log);
unknown's avatar
unknown committed
1057
  }
1058
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1059 1060
}

1061

1062 1063 1064 1065
bool MYSQL_LOG::append(Log_event* ev)
{
  bool error = 0;
  pthread_mutex_lock(&LOCK_log);
1066 1067
  DBUG_ENTER("MYSQL_LOG::append");

1068
  DBUG_ASSERT(log_file.type == SEQ_READ_APPEND);
1069 1070 1071 1072
  /*
    Log_event::write() is smart enough to use my_b_write() or
    my_b_append() depending on the kind of cache we have.
  */
1073 1074 1075 1076 1077
  if (ev->write(&log_file))
  {
    error=1;
    goto err;
  }
unknown's avatar
unknown committed
1078
  bytes_written += ev->get_event_len();
unknown's avatar
unknown committed
1079
  DBUG_PRINT("info",("max_size: %lu",max_size));
1080
  if ((uint) my_b_append_tell(&log_file) > max_size)
1081
  {
1082 1083 1084
    pthread_mutex_lock(&LOCK_index);
    new_file(0);
    pthread_mutex_unlock(&LOCK_index);
1085
  }
1086

1087 1088
err:  
  pthread_mutex_unlock(&LOCK_log);
1089
  signal_update();				// Safe as we don't call close
1090
  DBUG_RETURN(error);
1091 1092
}

1093

1094 1095
bool MYSQL_LOG::appendv(const char* buf, uint len,...)
{
1096
  bool error= 0;
1097
  DBUG_ENTER("MYSQL_LOG::appendv");
1098 1099 1100
  va_list(args);
  va_start(args,len);
  
1101 1102
  DBUG_ASSERT(log_file.type == SEQ_READ_APPEND);
  
1103 1104 1105
  pthread_mutex_lock(&LOCK_log);
  do
  {
unknown's avatar
unknown committed
1106
    if (my_b_append(&log_file,(byte*) buf,len))
1107
    {
1108 1109
      error= 1;
      goto err;
1110
    }
unknown's avatar
unknown committed
1111
    bytes_written += len;
1112
  } while ((buf=va_arg(args,const char*)) && (len=va_arg(args,uint)));
unknown's avatar
unknown committed
1113
  DBUG_PRINT("info",("max_size: %lu",max_size));
1114
  if ((uint) my_b_append_tell(&log_file) > max_size)
1115
  {
1116 1117 1118
    pthread_mutex_lock(&LOCK_index);
    new_file(0);
    pthread_mutex_unlock(&LOCK_index);
1119
  }
1120 1121 1122

err:
  pthread_mutex_unlock(&LOCK_log);
1123 1124
  if (!error)
    signal_update();
1125
  DBUG_RETURN(error);
1126
}
unknown's avatar
unknown committed
1127

unknown's avatar
unknown committed
1128

1129 1130 1131 1132 1133
/*
  Write to normal (not rotable) log
  This is the format for the 'normal', 'slow' and 'update' logs.
*/

1134
bool MYSQL_LOG::write(THD *thd,enum enum_server_command command,
unknown's avatar
unknown committed
1135 1136
		      const char *format,...)
{
1137
  if (is_open() && (what_to_log & (1L << (uint) command)))
unknown's avatar
unknown committed
1138
  {
1139 1140
    uint length;
    int error= 0;
unknown's avatar
unknown committed
1141
    VOID(pthread_mutex_lock(&LOCK_log));
1142

unknown's avatar
unknown committed
1143 1144
    /* Test if someone closed between the is_open test and lock */
    if (is_open())
unknown's avatar
unknown committed
1145 1146 1147
    {
      time_t skr;
      ulong id;
1148 1149 1150 1151
      va_list args;
      va_start(args,format);
      char buff[32];

unknown's avatar
unknown committed
1152 1153
      if (thd)
      {						// Normal thread
unknown's avatar
unknown committed
1154 1155 1156 1157 1158
	if ((thd->options & OPTION_LOG_OFF)
#ifndef NO_EMBEDDED_ACCESS_CHECKS
	    && (thd->master_access & SUPER_ACL)
#endif
)
unknown's avatar
unknown committed
1159 1160
	{
	  VOID(pthread_mutex_unlock(&LOCK_log));
1161
	  return 0;				// No logging
unknown's avatar
unknown committed
1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
	}
	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;
1179 1180 1181 1182 1183 1184 1185 1186
	/* 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
1187
	if (my_b_write(&log_file, (byte*) buff,16))
unknown's avatar
unknown committed
1188 1189
	  error=errno;
      }
unknown's avatar
unknown committed
1190
      else if (my_b_write(&log_file, (byte*) "\t\t",2) < 0)
unknown's avatar
unknown committed
1191
	error=errno;
1192 1193 1194 1195
      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
1196 1197 1198
	error=errno;
      if (format)
      {
unknown's avatar
unknown committed
1199
	if (my_b_write(&log_file, (byte*) " ",1) ||
1200
	    my_b_vprintf(&log_file,format,args) == (uint) -1)
unknown's avatar
unknown committed
1201 1202
	  error=errno;
      }
unknown's avatar
unknown committed
1203
      if (my_b_write(&log_file, (byte*) "\n",1) ||
1204
	  flush_io_cache(&log_file))
unknown's avatar
unknown committed
1205 1206 1207 1208 1209 1210
	error=errno;
      if (error && ! write_error)
      {
	write_error=1;
	sql_print_error(ER(ER_ERROR_ON_WRITE),name,error);
      }
1211
      va_end(args);
unknown's avatar
unknown committed
1212 1213
    }
    VOID(pthread_mutex_unlock(&LOCK_log));
1214
    return error != 0;
unknown's avatar
unknown committed
1215
  }
1216
  return 0;
unknown's avatar
unknown committed
1217 1218 1219
}


1220 1221 1222 1223 1224 1225 1226
inline bool sync_binlog(IO_CACHE *cache)
{
  return (sync_binlog_period &&
          (sync_binlog_period == ++sync_binlog_counter) &&
          (sync_binlog_counter= 0, my_sync(cache->file, MYF(MY_WME))));
}

1227 1228 1229 1230
/*
  Write an event to the binary log
*/

1231
bool MYSQL_LOG::write(Log_event* event_info)
unknown's avatar
unknown committed
1232
{
unknown's avatar
unknown committed
1233 1234
  THD *thd=event_info->thd;
  bool called_handler_commit=0;
unknown's avatar
unknown committed
1235
  bool error=0;
1236
  bool should_rotate = 0;
1237
  DBUG_ENTER("MYSQL_LOG::write(event)");
1238
  
1239 1240
  pthread_mutex_lock(&LOCK_log);

unknown's avatar
unknown committed
1241 1242 1243 1244 1245
  /* 
     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.
  */
1246
  if (is_open())
unknown's avatar
unknown committed
1247
  {
unknown's avatar
unknown committed
1248 1249
    const char *local_db= event_info->get_db();
    IO_CACHE *file= &log_file;
unknown's avatar
unknown committed
1250
#ifdef USING_TRANSACTIONS    
unknown's avatar
unknown committed
1251 1252 1253 1254 1255 1256 1257 1258 1259
    /*
      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
1260 1261 1262 1263 1264
    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
1265
    DBUG_PRINT("info",("event type=%d",event_info->get_type_code()));
unknown's avatar
SCRUM  
unknown committed
1266
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
1267 1268 1269 1270 1271
    /* 
       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)"
    */
1272
    if ((thd && !(thd->options & OPTION_BIN_LOG)) ||
1273
	(local_db && !db_ok(local_db, binlog_do_db, binlog_ignore_db)))
unknown's avatar
unknown committed
1274
    {
1275
      VOID(pthread_mutex_unlock(&LOCK_log));
1276
      DBUG_PRINT("error",("!db_ok('%s')", local_db));
1277
      DBUG_RETURN(0);
1278
    }
unknown's avatar
SCRUM  
unknown committed
1279
#endif /* HAVE_REPLICATION */
1280

unknown's avatar
unknown committed
1281
    error=1;
unknown's avatar
unknown committed
1282 1283 1284 1285
    /*
      No check for auto events flag here - this write method should
      never be called if auto-events are enabled
    */
unknown's avatar
unknown committed
1286 1287 1288 1289 1290 1291

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

1292
    if (thd)
1293
    {
1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
#if MYSQL_VERSION_ID < 50000
      /*
        To make replication of charsets working in 4.1 we are writing values
        of charset related variables before every statement in the binlog,
        if values of those variables differ from global server-wide defaults.
        We are using SET ONE_SHOT command so that the charset vars get reset
        to default after the first non-SET statement.
        In the next 5.0 this won't be needed as we will use the new binlog
        format to store charset info.
      */
      if ((thd->variables.character_set_client->number !=
           global_system_variables.collation_server->number) ||
          (thd->variables.character_set_client->number !=
           thd->variables.collation_connection->number) ||
          (thd->variables.collation_server->number !=
           thd->variables.collation_connection->number))
      {
	char buf[200];
        int written= my_snprintf(buf, sizeof(buf)-1,
unknown's avatar
unknown committed
1313 1314 1315 1316 1317 1318
                    "SET ONE_SHOT CHARACTER_SET_CLIENT=%u,\
COLLATION_CONNECTION=%u,COLLATION_DATABASE=%u,COLLATION_SERVER=%u",
                             (uint) thd->variables.character_set_client->number,
                             (uint) thd->variables.collation_connection->number,
                             (uint) thd->variables.collation_database->number,
                             (uint) thd->variables.collation_server->number);
1319
	Query_log_event e(thd, buf, written, 0, FALSE);
1320 1321 1322 1323
	e.set_log_pos(this);
	if (e.write(file))
	  goto err;
      }
1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334
      /*
        We use the same ONE_SHOT trick for making replication of time zones 
        working in 4.1. Again in 5.0 we have better means for doing this.
      */
      if (thd->time_zone_used &&
          thd->variables.time_zone != global_system_variables.time_zone)
      {
        char buf[MAX_TIME_ZONE_NAME_LENGTH + 26];
        char *buf_end= strxmov(buf, "SET ONE_SHOT TIME_ZONE='", 
                               thd->variables.time_zone->get_name()->ptr(),
                               "'", NullS);
1335
        Query_log_event e(thd, buf, buf_end - buf, 0, FALSE);
1336 1337 1338 1339
        e.set_log_pos(this);
        if (e.write(file))
          goto err;
      }
1340 1341
#endif

1342 1343 1344
      if (thd->last_insert_id_used)
      {
	Intvar_log_event e(thd,(uchar) LAST_INSERT_ID_EVENT,
1345
			   thd->current_insert_id);
1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363
	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
1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380
      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
1381
#ifdef TO_BE_REMOVED
1382 1383 1384 1385 1386 1387 1388 1389 1390 1391
      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
1392
#endif
unknown's avatar
unknown committed
1393

unknown's avatar
unknown committed
1394 1395 1396 1397 1398 1399 1400
      /*
	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
1401 1402 1403

      if (thd->options & OPTION_NO_FOREIGN_KEY_CHECKS)
      {
1404
	Query_log_event e(thd, "SET FOREIGN_KEY_CHECKS=0", 24, 0, FALSE);
unknown's avatar
unknown committed
1405 1406 1407 1408
	e.set_log_pos(this);
	if (e.write(file))
	  goto err;
      }
1409
    }
unknown's avatar
unknown committed
1410

unknown's avatar
unknown committed
1411
    /* Write the SQL command */
unknown's avatar
unknown committed
1412

1413
    event_info->set_log_pos(this);
unknown's avatar
unknown committed
1414
    if (event_info->write(file))
1415
      goto err;
unknown's avatar
unknown committed
1416

unknown's avatar
unknown committed
1417
    /* Write log events to reset the 'run environment' of the SQL command */
unknown's avatar
unknown committed
1418

1419
    if (thd)
unknown's avatar
unknown committed
1420
    {
1421 1422
      if (thd->options & OPTION_NO_FOREIGN_KEY_CHECKS)
      {
1423
        Query_log_event e(thd, "SET FOREIGN_KEY_CHECKS=1", 24, 0, FALSE);
1424 1425 1426 1427
        e.set_log_pos(this);
        if (e.write(file))
          goto err;
      }
unknown's avatar
unknown committed
1428
    }
1429

unknown's avatar
unknown committed
1430 1431 1432 1433 1434 1435 1436 1437
    /*
      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
1438 1439 1440 1441 1442 1443 1444

      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
1445
    */
1446

1447
    if (file == &log_file) // we are writing to the real log (disk)
unknown's avatar
unknown committed
1448
    {
1449
      if (flush_io_cache(file) || sync_binlog(file))
unknown's avatar
unknown committed
1450
	goto err;
1451

1452 1453
      if (opt_using_transactions &&
          !(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)))
unknown's avatar
unknown committed
1454
      {
1455 1456 1457 1458 1459 1460 1461
        /*
          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
1462 1463
        if (event_info->get_type_code() == QUERY_EVENT ||
            event_info->get_type_code() == EXEC_LOAD_EVENT)
1464
        {
unknown's avatar
unknown committed
1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488
#ifndef DBUG_OFF
          if (unlikely(opt_crash_binlog_innodb))
          {
            /*
              This option is for use in rpl_crash_binlog_innodb.test.
              1st we want to verify that Binlog_dump thread cannot send the
              event now (because of LOCK_log): we here tell the Binlog_dump
              thread to wake up, sleep for the slave to have time to possibly
              receive data from the master (it should not), and then crash.
              2nd we want to verify that at crash recovery the rolled back
              event is cut from the binlog.
            */
            if (!(--opt_crash_binlog_innodb))
            {
              signal_update();
              sleep(2);
              fprintf(stderr,"This is a normal crash because of"
                      " --crash-binlog-innodb\n");
              assert(0);
            }
            DBUG_PRINT("info",("opt_crash_binlog_innodb: %d",
                               opt_crash_binlog_innodb));
          }
#endif
1489 1490 1491 1492
          error = ha_report_binlog_offset_and_commit(thd, log_file_name,
                                                     file->pos_in_file);
          called_handler_commit=1;
        }
unknown's avatar
unknown committed
1493
      }
1494
      /* We wrote to the real log, check automatic rotation; */
unknown's avatar
unknown committed
1495
      DBUG_PRINT("info",("max_size: %lu",max_size));      
1496
      should_rotate= (my_b_tell(file) >= (my_off_t) max_size); 
1497
    }
unknown's avatar
unknown committed
1498
    error=0;
1499

1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
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)
1510
      signal_update();
1511
    if (should_rotate)
1512 1513 1514 1515 1516
    {
      pthread_mutex_lock(&LOCK_index);      
      new_file(0); // inside mutex
      pthread_mutex_unlock(&LOCK_index);
    }
1517
  }
1518 1519

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

unknown's avatar
unknown committed
1521 1522 1523 1524
  /*
    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
1525
  */
unknown's avatar
unknown committed
1526

unknown's avatar
unknown committed
1527
  if (called_handler_commit)
unknown's avatar
unknown committed
1528 1529
    ha_commit_complete(thd);

unknown's avatar
unknown committed
1530
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
1531
  if (should_rotate && expire_logs_days)
1532 1533 1534
  {
    long purge_time= time(0) - expire_logs_days*24*60*60;
    if (purge_time >= 0)
1535
      error= purge_logs_before_date(purge_time);
1536
  }
unknown's avatar
unknown committed
1537
#endif
1538
  DBUG_RETURN(error);
1539 1540
}

1541

unknown's avatar
unknown committed
1542 1543 1544 1545 1546 1547 1548 1549 1550
uint MYSQL_LOG::next_file_id()
{
  uint res;
  pthread_mutex_lock(&LOCK_log);
  res = file_id++;
  pthread_mutex_unlock(&LOCK_log);
  return res;
}

1551

1552 1553
/*
  Write a cached log entry to the binary log
1554

unknown's avatar
unknown committed
1555 1556 1557 1558 1559 1560 1561
  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".

1562 1563
  NOTE
    - We only come here if there is something in the cache.
unknown's avatar
unknown committed
1564
    - The thing in the cache is always a complete transaction
1565 1566 1567 1568
    - 'cache' needs to be reinitialized after this functions returns.

  IMPLEMENTATION
    - To support transaction over replication, we wrap the transaction
unknown's avatar
unknown committed
1569 1570 1571 1572
      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.
1573 1574
*/

unknown's avatar
unknown committed
1575
bool MYSQL_LOG::write(THD *thd, IO_CACHE *cache, bool commit_or_rollback)
1576 1577
{
  VOID(pthread_mutex_lock(&LOCK_log));
1578
  DBUG_ENTER("MYSQL_LOG::write(cache");
1579
  
1580
  if (is_open())				// Should always be true
1581
  {
1582 1583
    uint length;

unknown's avatar
unknown committed
1584
    /*
1585 1586 1587 1588 1589 1590 1591 1592
      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
1593

1594 1595 1596 1597 1598
      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.
    */
    {
1599
      Query_log_event qinfo(thd, "BEGIN", 5, TRUE, FALSE);
1600 1601 1602 1603 1604 1605 1606 1607
      /*
        Imagine this is rollback due to net timeout, after all statements of
        the transaction succeeded. Then we want a zero-error code in BEGIN.
        In other words, if there was a really serious error code it's already
        in the statement's events.
        This is safer than thd->clear_error() against kills at shutdown.
      */
      qinfo.error_code= 0;
1608 1609 1610
      /*
        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
1611 1612 1613
	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.
1614 1615
      */
      qinfo.set_log_pos(this);
1616 1617 1618
      if (qinfo.write(&log_file))
	goto err;
    }
unknown's avatar
unknown committed
1619
    /* Read from the file used to cache the queries .*/
unknown's avatar
unknown committed
1620
    if (reinit_io_cache(cache, READ_CACHE, 0, 0, 0))
1621
      goto err;
1622 1623
    length=my_b_bytes_in_cache(cache);
    do
1624
    {
unknown's avatar
unknown committed
1625
      /* Write data to the binary log file */
unknown's avatar
unknown committed
1626
      if (my_b_write(&log_file, cache->read_pos, length))
1627
	goto err;
unknown's avatar
unknown committed
1628
      cache->read_pos=cache->read_end;		// Mark buffer used up
1629
    } while ((length=my_b_fill(cache)));
1630 1631 1632 1633 1634 1635

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

1636
    {
unknown's avatar
unknown committed
1637 1638 1639
      Query_log_event qinfo(thd, 
                            commit_or_rollback ? "COMMIT" : "ROLLBACK",
                            commit_or_rollback ? 6        : 8, 
1640
                            TRUE, FALSE);
1641
      qinfo.error_code= 0;
1642
      qinfo.set_log_pos(this);
1643 1644
      if (qinfo.write(&log_file) || flush_io_cache(&log_file) ||
          sync_binlog(&log_file))
1645
	goto err;
1646 1647 1648
    }
    if (cache->error)				// Error on read
    {
unknown's avatar
unknown committed
1649
      sql_print_error(ER(ER_ERROR_ON_READ), cache->file_name, errno);
1650
      write_error=1;				// Don't give more errors
1651
      goto err;
unknown's avatar
unknown committed
1652
    }
unknown's avatar
unknown committed
1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668
#ifndef DBUG_OFF
    if (unlikely(opt_crash_binlog_innodb))
    {
      /* see the previous MYSQL_LOG::write() method for a comment */
      if (!(--opt_crash_binlog_innodb))
      {
        signal_update();
        sleep(2);
        fprintf(stderr, "This is a normal crash because of"
                " --crash-binlog-innodb\n");
        assert(0);
      }
      DBUG_PRINT("info",("opt_crash_binlog_innodb: %d",
                         opt_crash_binlog_innodb));
    }
#endif
1669 1670
    if ((ha_report_binlog_offset_and_commit(thd, log_file_name,
					    log_file.pos_in_file)))
1671
      goto err;
1672
    signal_update();
unknown's avatar
unknown committed
1673
    DBUG_PRINT("info",("max_size: %lu",max_size));
1674
    if (my_b_tell(&log_file) >= (my_off_t) max_size)
1675 1676 1677 1678 1679 1680
    {
      pthread_mutex_lock(&LOCK_index);
      new_file(0); // inside mutex
      pthread_mutex_unlock(&LOCK_index);
    }

unknown's avatar
unknown committed
1681
  }
1682
  VOID(pthread_mutex_unlock(&LOCK_log));
unknown's avatar
unknown committed
1683 1684 1685 1686 1687 1688 1689

  /* 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);

1690
  DBUG_RETURN(0);
1691 1692

err:
1693 1694 1695 1696 1697
  if (!write_error)
  {
    write_error= 1;
    sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
  }
1698
  VOID(pthread_mutex_unlock(&LOCK_log));
1699
  DBUG_RETURN(1);
unknown's avatar
unknown committed
1700 1701
}

1702

1703 1704
/*
  Write update log in a format suitable for incremental backup
1705
  This is also used by the slow query log.
1706
*/
unknown's avatar
unknown committed
1707

1708
bool MYSQL_LOG::write(THD *thd,const char *query, uint query_length,
1709
		      time_t query_start_arg)
unknown's avatar
unknown committed
1710
{
1711
  bool error=0;
unknown's avatar
unknown committed
1712
  time_t current_time;
unknown's avatar
unknown committed
1713 1714
  if (!is_open())
    return 0;
unknown's avatar
unknown committed
1715 1716
  DBUG_ENTER("MYSQL_LOG::write");

unknown's avatar
unknown committed
1717
  VOID(pthread_mutex_lock(&LOCK_log));
1718
  if (is_open())
unknown's avatar
unknown committed
1719 1720 1721 1722
  {						// Safety agains reopen
    int tmp_errno=0;
    char buff[80],*end;
    end=buff;
1723
    if (!(thd->options & OPTION_UPDATE_LOG))
unknown's avatar
unknown committed
1724 1725
    {
      VOID(pthread_mutex_unlock(&LOCK_log));
unknown's avatar
unknown committed
1726
      DBUG_RETURN(0);
unknown's avatar
unknown committed
1727
    }
1728
    if (!(specialflag & SPECIAL_SHORT_LOG_FORMAT) || query_start_arg)
unknown's avatar
unknown committed
1729 1730 1731
    {
      current_time=time(NULL);
      if (current_time != last_time)
unknown's avatar
unknown committed
1732
      {
unknown's avatar
unknown committed
1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747
        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
1748
      }
unknown's avatar
unknown committed
1749
      if (my_b_printf(&log_file, "# User@Host: %s[%s] @ %s [%s]\n",
unknown's avatar
unknown committed
1750 1751
                      thd->priv_user ? thd->priv_user : "",
                      thd->user ? thd->user : "",
unknown's avatar
unknown committed
1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780
                      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)
    {
1781
      if (!(specialflag & SPECIAL_SHORT_LOG_FORMAT))
unknown's avatar
unknown committed
1782
      {
unknown's avatar
unknown committed
1783 1784
        end=strmov(end,",insert_id=");
        end=longlong10_to_str((longlong) thd->last_insert_id,end,-10);
unknown's avatar
unknown committed
1785
      }
unknown's avatar
unknown committed
1786 1787 1788 1789
    }
    if (thd->query_start_used)
    {
      if (query_start_arg != thd->query_start())
unknown's avatar
unknown committed
1790
      {
unknown's avatar
unknown committed
1791 1792 1793
        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
1794
      }
unknown's avatar
unknown committed
1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818
    }
    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
1819
      {
unknown's avatar
unknown committed
1820 1821
        write_error=1;
        sql_print_error(ER(ER_ERROR_ON_WRITE),name,error);
unknown's avatar
unknown committed
1822 1823 1824
      }
    }
  }
unknown's avatar
unknown committed
1825
  VOID(pthread_mutex_unlock(&LOCK_log));
unknown's avatar
unknown committed
1826
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1827 1828
}

unknown's avatar
unknown committed
1829

1830 1831 1832 1833 1834 1835
/*
  Wait until we get a signal that the binary log has been updated

  SYNOPSIS
    wait_for_update()
    thd			Thread variable
1836 1837 1838
    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.
1839 1840 1841

  NOTES
    One must have a lock on LOCK_log before calling this function.
unknown's avatar
unknown committed
1842 1843
    This lock will be freed before return! That's required by
    THD::enter_cond() (see NOTES in sql_class.h).
1844 1845
*/

unknown's avatar
unknown committed
1846
void MYSQL_LOG::wait_for_update(THD* thd, bool master_or_slave)
1847
{
unknown's avatar
unknown committed
1848 1849 1850 1851 1852 1853 1854 1855
  const char *old_msg;
  DBUG_ENTER("wait_for_update");
  old_msg= thd->enter_cond(&update_cond, &LOCK_log,
                           master_or_slave ?
                           "Has read all relay log; waiting for the slave I/O "
                           "thread to update it" : 
                           "Has sent all binlog to slave; waiting for binlog "
                           "to be updated"); 
1856 1857
  pthread_cond_wait(&update_cond, &LOCK_log);
  thd->exit_cond(old_msg);
unknown's avatar
unknown committed
1858
  DBUG_VOID_RETURN;
1859
}
unknown's avatar
unknown committed
1860

unknown's avatar
unknown committed
1861

1862 1863 1864 1865 1866
/*
  Close the log file

  SYNOPSIS
    close()
1867 1868 1869 1870 1871
    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
1872 1873 1874 1875

  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
1876 1877
*/

1878
void MYSQL_LOG::close(uint exiting)
unknown's avatar
unknown committed
1879
{					// One can't set log_type here!
1880 1881
  DBUG_ENTER("MYSQL_LOG::close");
  DBUG_PRINT("enter",("exiting: %d", (int) exiting));
unknown's avatar
unknown committed
1882
  if (log_type != LOG_CLOSED && log_type != LOG_TO_BE_OPENED)
unknown's avatar
unknown committed
1883
  {
unknown's avatar
SCRUM  
unknown committed
1884
#ifdef HAVE_REPLICATION
1885 1886
    if (log_type == LOG_BIN && !no_auto_events &&
	(exiting & LOG_CLOSE_STOP_EVENT))
unknown's avatar
unknown committed
1887 1888
    {
      Stop_log_event s;
1889
      s.set_log_pos(this);
1890
      s.write(&log_file);
1891
      signal_update();
unknown's avatar
unknown committed
1892
    }
unknown's avatar
SCRUM  
unknown committed
1893
#endif /* HAVE_REPLICATION */
1894
    end_io_cache(&log_file);
1895
    if (my_close(log_file.file,MYF(0)) < 0 && ! write_error)
unknown's avatar
unknown committed
1896 1897
    {
      write_error=1;
1898
      sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);
unknown's avatar
unknown committed
1899 1900
    }
  }
1901 1902 1903 1904 1905 1906

  /*
    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.
  */

1907
  if ((exiting & LOG_CLOSE_INDEX) && my_b_inited(&index_file))
1908
  {
1909 1910
    end_io_cache(&index_file);
    if (my_close(index_file.file, MYF(0)) < 0 && ! write_error)
unknown's avatar
unknown committed
1911
    {
1912 1913
      write_error= 1;
      sql_print_error(ER(ER_ERROR_ON_WRITE), index_file_name, errno);
unknown's avatar
unknown committed
1914
    }
1915
  }
1916
  log_type= (exiting & LOG_CLOSE_TO_BE_OPENED) ? LOG_TO_BE_OPENED : LOG_CLOSED;
1917
  safeFree(name);
1918
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1919 1920 1921
}


1922 1923 1924 1925 1926 1927 1928 1929 1930
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
1931 1932
  DBUG_ENTER("MYSQL_LOG::set_max_size");
  pthread_mutex_lock(&LOCK_log);
1933 1934
  if (is_open())
    max_size= max_size_arg;
unknown's avatar
unknown committed
1935 1936
  pthread_mutex_unlock(&LOCK_log);
  DBUG_VOID_RETURN;
1937
}
unknown's avatar
unknown committed
1938

unknown's avatar
unknown committed
1939

1940 1941
/*
  Check if a string is a valid number
1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955

  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
1956
*/
unknown's avatar
unknown committed
1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968

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++;
1969 1970
  while (my_isdigit(files_charset_info,*str) ||
	 (allow_wildcards && (*str == wild_many || *str == wild_one)))
unknown's avatar
unknown committed
1971 1972 1973 1974 1975 1976 1977
  {
    flag=1;
    str++;
  }
  if (*str == '.')
  {
    for (str++ ;
1978
	 my_isdigit(files_charset_info,*str) ||
unknown's avatar
unknown committed
1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989
	   (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 */


unknown's avatar
unknown committed
1990
void print_buffer_to_file(enum loglevel level, const char *buffer)
unknown's avatar
unknown committed
1991 1992 1993 1994
{
  time_t skr;
  struct tm tm_tmp;
  struct tm *start;
unknown's avatar
unknown committed
1995 1996
  DBUG_ENTER("print_buffer_to_file");
  DBUG_PRINT("enter",("buffer: %s", buffer));
unknown's avatar
unknown committed
1997 1998

  VOID(pthread_mutex_lock(&LOCK_error_log));
unknown's avatar
unknown committed
1999

unknown's avatar
unknown committed
2000
  skr=time(NULL);
2001
  localtime_r(&skr, &tm_tmp);
unknown's avatar
unknown committed
2002
  start=&tm_tmp;
2003
  fprintf(stderr, "%02d%02d%02d %2d:%02d:%02d [%s] %s\n",
2004 2005 2006 2007 2008 2009
          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
2010
          (level == ERROR_LEVEL ? "ERROR" : level == WARNING_LEVEL ?
2011
           "Warning" : "Note"),
unknown's avatar
unknown committed
2012
          buffer);
unknown's avatar
unknown committed
2013

unknown's avatar
unknown committed
2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028
  fflush(stderr);

  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
}
2029

unknown's avatar
unknown committed
2030

unknown's avatar
unknown committed
2031 2032 2033
bool flush_error_log()
{
  bool result=0;
2034
  if (opt_error_log)
unknown's avatar
unknown committed
2035 2036 2037 2038
  {
    char err_renamed[FN_REFLEN], *end;
    end= strmake(err_renamed,log_error_file,FN_REFLEN-4);
    strmov(end, "-old");
2039
    VOID(pthread_mutex_lock(&LOCK_error_log));
unknown's avatar
unknown committed
2040 2041 2042 2043 2044 2045 2046
#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");
2047
    (void) my_delete(err_temp, MYF(0));
unknown's avatar
unknown committed
2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059
    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)
2060
             my_fwrite(stderr, (byte*) buf, bytes, MYF(0));
unknown's avatar
unknown committed
2061 2062
        my_close(fd, MYF(0));
      }
2063
      (void) my_delete(err_temp, MYF(0));
unknown's avatar
unknown committed
2064 2065 2066 2067
    }
    else
     result= 1;
#else
2068 2069 2070 2071 2072
    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;
unknown's avatar
unknown committed
2073
#endif
2074
    VOID(pthread_mutex_unlock(&LOCK_error_log));
unknown's avatar
unknown committed
2075 2076 2077
  }
   return result;
}
unknown's avatar
unknown committed
2078

2079

unknown's avatar
unknown committed
2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098
/*
  If the server has InnoDB on, and InnoDB has published the position of the
  last committed transaction (which happens only if a crash recovery occured at
  this startup) then truncate the previous binary log at the position given by
  InnoDB. If binlog is shorter than the position, print a message to the error
  log.

  SYNOPSIS
    cut_spurious_tail()

  RETURN VALUES
    1	Error
    0	Ok
*/

bool MYSQL_LOG::cut_spurious_tail()
{
  int error= 0;
  DBUG_ENTER("cut_spurious_tail");
2099

unknown's avatar
unknown committed
2100 2101 2102 2103 2104 2105 2106 2107 2108
#ifdef HAVE_INNOBASE_DB
  if (have_innodb != SHOW_OPTION_YES)
    DBUG_RETURN(0);
  /*
    This is the place where we use information from InnoDB to cut the
    binlog.
  */
  char *name= ha_innobase::get_mysql_bin_log_name();
  ulonglong pos= ha_innobase::get_mysql_bin_log_pos();
2109 2110 2111
  ulonglong actual_size;
  char llbuf1[22], llbuf2[22];

2112
  if (name[0] == 0 || pos == ULONGLONG_MAX)
unknown's avatar
unknown committed
2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125
  {
    DBUG_PRINT("info", ("InnoDB has not set binlog info"));
    DBUG_RETURN(0);
  }
  /* The binlog given by InnoDB normally is never an active binlog */
  if (is_open() && is_active(name))
  {
    sql_print_error("Warning: after InnoDB crash recovery, InnoDB says that "
                    "the binary log of the previous run has the same name "
                    "'%s' as the current one; this is likely to be abnormal.",
                    name);
    DBUG_RETURN(1);
  }
2126 2127 2128
  sql_print_error("After InnoDB crash recovery, checking if the binary log "
                  "'%s' contains rolled back transactions which must be "
                  "removed from it...", name);
unknown's avatar
unknown committed
2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140
  /* If we have a too long binlog, cut. If too short, print error */
  int fd= my_open(name, O_EXCL | O_APPEND | O_BINARY | O_WRONLY, MYF(MY_WME));
  if (fd < 0)
  {
    int save_errno= my_errno;
    sql_print_error("Could not open the binary log '%s' for truncation.",
                    name);
    if (save_errno != ENOENT)
      sql_print_error("The binary log '%s' should not be used for "
                      "replication.", name);    
    DBUG_RETURN(1);
  }
2141

unknown's avatar
unknown committed
2142 2143
  if (pos > (actual_size= my_seek(fd, 0L, MY_SEEK_END, MYF(MY_WME))))
  {
2144 2145 2146 2147
    /*
      Note that when we have MyISAM rollback this error message should be
      reconsidered.
    */
unknown's avatar
unknown committed
2148 2149 2150
    sql_print_error("The binary log '%s' is shorter than its expected size "
                    "(actual: %s, expected: %s) so it misses at least one "
                    "committed transaction; so it should not be used for "
2151 2152 2153 2154
                    "replication or point-in-time recovery. You would need "
                    "to restart slaves from a fresh master's data "
                    "snapshot ",
                    name, llstr(actual_size, llbuf1),
unknown's avatar
unknown committed
2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213
                    llstr(pos, llbuf2));
    error= 1;
    goto err;
  }
  if (pos < actual_size)
  {
    sql_print_error("The binary log '%s' is bigger than its expected size "
                    "(actual: %s, expected: %s) so it contains a rolled back "
                    "transaction; now truncating that.", name,
                    llstr(actual_size, llbuf1), llstr(pos, llbuf2));
    /*
      As on some OS, my_chsize() can only pad with 0s instead of really
      truncating. Then mysqlbinlog (and Binlog_dump thread) will error on
      these zeroes. This is annoying, but not more (you just need to manually
      switch replication to the next binlog). Fortunately, in my_chsize.c, it
      says that all modern machines support real ftruncate().
      
    */
    if ((error= my_chsize(fd, pos, 0, MYF(MY_WME))))
      goto err;
  }
err:
  if (my_close(fd, MYF(MY_WME)))
    error= 1;
#endif
  DBUG_RETURN(error);
}


/*
  If the server has InnoDB on, store the binlog name and position into
  InnoDB. This function is used every time we create a new binlog.

  SYNOPSIS
    report_pos_in_innodb()

  NOTES
    This cannot simply be done in MYSQL_LOG::open(), because when we create
    the first binlog at startup, we have not called ha_init() yet so we cannot
    write into InnoDB yet.

  RETURN VALUES
    1	Error
    0	Ok
*/

void MYSQL_LOG::report_pos_in_innodb()
{
  DBUG_ENTER("report_pos_in_innodb");
#ifdef HAVE_INNOBASE_DB
  if (is_open() && have_innodb == SHOW_OPTION_YES)
  {
    DBUG_PRINT("info", ("Reporting binlog info into InnoDB - "
                        "name: '%s' position: %d",
                        log_file_name, my_b_tell(&log_file)));
    innobase_store_binlog_offset_and_flush_log(log_file_name,
                                               my_b_tell(&log_file));
  }
#endif
unknown's avatar
unknown committed
2214 2215
  DBUG_VOID_RETURN;
}
unknown's avatar
unknown committed
2216

unknown's avatar
unknown committed
2217 2218 2219 2220 2221 2222 2223 2224 2225

void MYSQL_LOG::signal_update()
{
  DBUG_ENTER("MYSQL_LOG::signal_update");
  pthread_cond_broadcast(&update_cond);
  DBUG_VOID_RETURN;
}


2226
#ifdef __NT__
unknown's avatar
unknown committed
2227 2228
void print_buffer_to_nt_eventlog(enum loglevel level, char *buff,
                                 uint length, int buffLen)
2229 2230 2231 2232
{
  HANDLE event;
  char   *buffptr;
  LPCSTR *buffmsgptr;
unknown's avatar
unknown committed
2233
  DBUG_ENTER("print_buffer_to_nt_eventlog");
2234

unknown's avatar
unknown committed
2235 2236
  buffptr= buff;
  if (length > (uint)(buffLen-4))
2237
  {
unknown's avatar
unknown committed
2238
    char *newBuff= new char[length + 4];
unknown's avatar
unknown committed
2239
    strcpy(newBuff, buff);
unknown's avatar
unknown committed
2240
    buffptr= newBuff;
2241
  }
unknown's avatar
unknown committed
2242 2243
  strmov(buffptr+length, "\r\n\r\n");
  buffmsgptr= (LPCSTR*) &buffptr;               // Keep windows happy
2244

unknown's avatar
unknown committed
2245 2246
  setup_windows_event_source();
  if ((event= RegisterEventSource(NULL,"MySQL")))
2247
  {
unknown's avatar
unknown committed
2248
    switch (level) {
2249
      case ERROR_LEVEL:
unknown's avatar
unknown committed
2250 2251
        ReportEvent(event, EVENTLOG_ERROR_TYPE, 0, MSG_DEFAULT, NULL, 1, 0,
                    buffmsgptr, NULL);
2252 2253
        break;
      case WARNING_LEVEL:
unknown's avatar
unknown committed
2254 2255
        ReportEvent(event, EVENTLOG_WARNING_TYPE, 0, MSG_DEFAULT, NULL, 1, 0,
                    buffmsgptr, NULL);
2256 2257
        break;
      case INFORMATION_LEVEL:
unknown's avatar
unknown committed
2258 2259
        ReportEvent(event, EVENTLOG_INFORMATION_TYPE, 0, MSG_DEFAULT, NULL, 1,
                    0, buffmsgptr, NULL);
2260 2261 2262 2263 2264
        break;
    }
    DeregisterEventSource(event);
  }

unknown's avatar
unknown committed
2265
  /* if we created a string buffer, then delete it */
unknown's avatar
unknown committed
2266
  if (buffptr != buff)
2267 2268 2269 2270
    delete[] buffptr;

  DBUG_VOID_RETURN;
}
unknown's avatar
unknown committed
2271 2272
#endif /* __NT__ */

2273 2274

/*
unknown's avatar
unknown committed
2275 2276
  Prints a printf style message to the error log and, under NT, to the
  Windows event log.
2277 2278 2279

  SYNOPSIS
    vprint_msg_to_log()
unknown's avatar
unknown committed
2280 2281 2282
    event_type             Type of event to write (Error, Warning, or Info)
    format                 Printf style format of message
    args                   va_list list of arguments for the message    
2283 2284 2285 2286

  NOTE

  IMPLEMENTATION
unknown's avatar
unknown committed
2287 2288
    This function prints the message into a buffer and then sends that buffer
    to other functions to write that message to other logging sources.
2289 2290 2291

  RETURN VALUES
    void
unknown's avatar
unknown committed
2292
*/
unknown's avatar
unknown committed
2293

2294
void vprint_msg_to_log(enum loglevel level, const char *format, va_list args)
unknown's avatar
unknown committed
2295 2296
{
  char   buff[1024];
unknown's avatar
unknown committed
2297
  uint length;
2298
  DBUG_ENTER("vprint_msg_to_log");
unknown's avatar
unknown committed
2299

unknown's avatar
unknown committed
2300
  length= my_vsnprintf(buff, sizeof(buff)-5, format, args);
unknown's avatar
unknown committed
2301
  print_buffer_to_file(level, buff);
unknown's avatar
unknown committed
2302 2303

#ifdef __NT__
unknown's avatar
unknown committed
2304
  print_buffer_to_nt_eventlog(level, buff, length, sizeof(buff));
unknown's avatar
unknown committed
2305
#endif
2306

unknown's avatar
unknown committed
2307 2308 2309
  DBUG_VOID_RETURN;
}

2310

unknown's avatar
unknown committed
2311
void sql_print_error(const char *format, ...) 
unknown's avatar
unknown committed
2312 2313
{
  va_list args;
unknown's avatar
unknown committed
2314
  DBUG_ENTER("sql_print_error");
unknown's avatar
unknown committed
2315

unknown's avatar
unknown committed
2316 2317 2318
  va_start(args, format);
  vprint_msg_to_log(ERROR_LEVEL, format, args);
  va_end(args);
unknown's avatar
unknown committed
2319 2320 2321 2322 2323

  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
2324
void sql_print_warning(const char *format, ...) 
unknown's avatar
unknown committed
2325 2326
{
  va_list args;
unknown's avatar
unknown committed
2327
  DBUG_ENTER("sql_print_warning");
unknown's avatar
unknown committed
2328

unknown's avatar
unknown committed
2329 2330 2331
  va_start(args, format);
  vprint_msg_to_log(WARNING_LEVEL, format, args);
  va_end(args);
unknown's avatar
unknown committed
2332 2333 2334 2335 2336

  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
2337
void sql_print_information(const char *format, ...) 
unknown's avatar
unknown committed
2338 2339
{
  va_list args;
unknown's avatar
unknown committed
2340
  DBUG_ENTER("sql_print_information");
unknown's avatar
unknown committed
2341

unknown's avatar
unknown committed
2342 2343 2344
  va_start(args, format);
  vprint_msg_to_log(INFORMATION_LEVEL, format, args);
  va_end(args);
unknown's avatar
unknown committed
2345

unknown's avatar
unknown committed
2346 2347
  DBUG_VOID_RETURN;
}