~drizzle-trunk/drizzle/development

                                       THD * /* thd */)

{

  strmake(m_message, message_arg, sizeof(m_message)-1);

}

 

 

  {

    if (m_mutex)

      pthread_mutex_unlock(m_mutex);

    m_mutex= 0;

  }

 

private:

 

  ~binlog_trx_data()

  {

    close_cached_file(&trans_log);

  }

 

   */

  void truncate(my_off_t pos)

  {

    delete pending();

    set_pending(0);

    reinit_io_cache(&trans_log, WRITE_CACHE, pos, 0, 0);

    if (opt_log)

      mysql_log.open_query_log(sys_var_general_log_path.value);

 

  }

 

}

 

 

bool LOGGER::error_log_print(enum loglevel level, const char *format,

                             va_list args)

{

  Log_event_handler **current_handler;

 

  /* currently we don't need locking here as there is no error_log table */

 

void LOGGER::cleanup_base()

{

  rwlock_destroy(&LOCK_logger);

  if (file_log_handler)

    file_log_handler->cleanup();

 

void LOGGER::cleanup_end()

{

  if (file_log_handler)

    delete file_log_handler;

}

*/

void LOGGER::init_base()

{

  inited= 1;

 

  /*

                            ulonglong current_utime)

 

{

  Log_event_handler **current_handler;

  char user_host_buff[MAX_USER_HOST_SIZE];

  Security_context *sctx= thd->security_ctx;

  uint user_host_len= 0;

 

    if (!query)

    {

      query= command_name[thd->command].str;

      query_length= command_name[thd->command].length;

    }

bool LOGGER::general_log_write(THD *thd, enum enum_server_command command,

                               const char *query, uint query_length)

{

  Log_event_handler **current_handler= general_log_handler_list;

  char user_host_buff[MAX_USER_HOST_SIZE];

  Security_context *sctx= thd->security_ctx;

    break;

    /* these two are disabled for now */

  case LOG_TABLE:

    break;

  case LOG_TABLE|LOG_FILE:

    break;

  }

}

                                  uint log_type)

{

  MYSQL_QUERY_LOG *file_log;

  lock_exclusive();

  switch (log_type) {

  case QUERY_LOG_SLOW:

 

      file_log->open_slow_log(sys_var_slow_log_path.value);

      init_slow_log(log_output_options);

    }

    break;

  case QUERY_LOG_GENERAL:

 

      file_log->open_query_log(sys_var_general_log_path.value);

      init_general_log(log_output_options);

    }

    break;

  default:

  }

  unlock();

  return res;

 

  lock_exclusive();

  file_log->close(0);

  unlock();

}

 

                         uint general_log_printer)

{

  /* error log table is not supported yet */

 

  lock_exclusive();

 

static void

binlog_trans_log_savepos(THD *thd, my_off_t *pos)

{

  if (thd_get_ha_data(thd, binlog_hton) == NULL)

    thd->binlog_setup_trx_data();

  binlog_trx_data *const trx_data=

    (binlog_trx_data*) thd_get_ha_data(thd, binlog_hton);

  *pos= trx_data->position();

}

 

 

static void

binlog_trans_log_truncate(THD *thd, my_off_t pos)

{

  /* Only true if binlog_trans_log_savepos() wasn't called before */

 

  binlog_trx_data *const trx_data=

    (binlog_trx_data*) thd_get_ha_data(thd, binlog_hton);

  trx_data->truncate(pos);

}

 

 

{

  binlog_trx_data *const trx_data=

    (binlog_trx_data*) thd_get_ha_data(thd, binlog_hton);

  thd_set_ha_data(thd, binlog_hton, NULL);

  trx_data->~binlog_trx_data();

  my_free((uchar*)trx_data, MYF(0));

binlog_end_trans(THD *thd, binlog_trx_data *trx_data,

                 Log_event *end_ev, bool all)

{

  int error=0;

  IO_CACHE *trans_log= &trx_data->trans_log;

 

  /*

    NULL denotes ROLLBACK with nothing to replicate: i.e., rollback of

      were, we would have to ensure that we're not ending a statement

      inside a stored function.

     */

 

    error= mysql_bin_log.write(thd, &trx_data->trans_log, end_ev);

    trx_data->reset();

    {

      trx_data->reset();

 

      thd->clear_binlog_table_maps();

    }

    else                                        // ...statement

    mysql_bin_log.update_table_map_version();

  }

 

}

 

static int binlog_prepare(handlerton *hton __attribute__((__unused__)),

static int binlog_commit(handlerton *hton __attribute__((__unused__)),

                         THD *thd, bool all)

{

  binlog_trx_data *const trx_data=

    (binlog_trx_data*) thd_get_ha_data(thd, binlog_hton);

 

  {

    // we're here because trans_log was flushed in MYSQL_BIN_LOG::log_xid()

    trx_data->reset();

  }

 

  /*

  */

  ulonglong const in_transaction=

    thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN);

  if ((in_transaction && (all || (!trx_data->at_least_one_stmt && thd->transaction.stmt.modified_non_trans_table))) || (!in_transaction && !all))

  {

    qev.error_code= 0; // see comment in MYSQL_LOG::write(THD, IO_CACHE)

    int error= binlog_end_trans(thd, trx_data, &qev, all);

  }

}

 

/**

static int binlog_rollback(handlerton *hton __attribute__((__unused__)),

                           THD *thd, bool all)

{

  int error=0;

  binlog_trx_data *const trx_data=

    (binlog_trx_data*) thd_get_ha_data(thd, binlog_hton);

 

  if (trx_data->empty()) {

    trx_data->reset();

  }

 

  if ((all && thd->transaction.all.modified_non_trans_table) ||

      (!all && thd->transaction.stmt.modified_non_trans_table) ||

      (thd->options & OPTION_KEEP_LOG))

      transactional table in that statement as well, which needs to be

      rolled back on the slave.

    */

    qev.error_code= 0; // see comment in MYSQL_LOG::write(THD, IO_CACHE)

    error= binlog_end_trans(thd, trx_data, &qev, all);

  }

     */

    error= binlog_end_trans(thd, trx_data, 0, all);

  }

}

 

/**

static int binlog_savepoint_set(handlerton *hton __attribute__((__unused__)),

                                THD *thd, void *sv)

{

  binlog_trans_log_savepos(thd, (my_off_t*) sv);

  /* Write it to the binary log */

  

  int const error=

    thd->binlog_query(THD::STMT_QUERY_TYPE,

}

 

static int binlog_savepoint_rollback(handlerton *hton __attribute__((__unused__)),

                                     THD *thd, void *sv)

{

  /*

    Write ROLLBACK TO SAVEPOINT to the binlog cache if we have updated some

    non-transactional table. Otherwise, truncate the binlog cache starting

  {

    int error=

      thd->binlog_query(THD::STMT_QUERY_TYPE,

  }

  binlog_trans_log_truncate(thd, *(my_off_t*)sv);

}

 

 

int check_binlog_magic(IO_CACHE* log, const char** errmsg)

{

  char magic[4];

 

  if (my_b_read(log, (uchar*) magic, sizeof(magic)))

  {

File open_binlog(IO_CACHE *log, const char *log_file_name, const char **errmsg)

{

  File file;

 

  if ((file = my_open(log_file_name, O_RDONLY | O_BINARY | O_SHARE, 

                      MYF(MY_WME))) < 0)

  }

  if (check_binlog_magic(log,errmsg))

    goto err;

 

err:

  if (file >= 0)

    my_close(file,MYF(0));

    end_io_cache(log);

  }

}

 

 

  ulong                 max_found=0;

  size_t                buf_length, length;

  char                  *start, *end;

 

  length= dirname_part(buff, name, &buf_length);

  start=  name + length;

  if (!(dir_info = my_dir(buff,MYF(MY_DONT_SORT))))

  {                                             // This shouldn't happen

    strmov(end,".1");                           // use name+1

  }

  file_info= dir_info->dir_entry;

  for (i=dir_info->number_off_files ; i-- ; file_info++)

 

  *end++='.';

  sprintf(end,"%06ld",max_found+1);

}

 

 

void MYSQL_LOG::init(enum_log_type log_type_arg,

                     enum cache_type io_cache_type_arg)

{

  log_type= log_type_arg;

  io_cache_type= io_cache_type_arg;

}

 

 

  char buff[FN_REFLEN];

  File file= -1;

  int open_flags= O_CREAT | O_BINARY;

 

  write_error= 0;

 

  }

 

  log_state= LOG_OPENED;

 

err:

  sql_print_error("Could not use %s for logging (error %d). \

  end_io_cache(&log_file);

  safeFree(name);

  log_state= LOG_CLOSED;

}

 

MYSQL_LOG::MYSQL_LOG()

    log_state(LOG_CLOSED)

{

  /*

 

void MYSQL_LOG::init_pthread_objects()

{

  inited= 1;

  (void) pthread_mutex_init(&LOCK_log, MY_MUTEX_INIT_SLOW);

}

 

void MYSQL_LOG::close(uint exiting)

{                                       // One can't set log_type here!

  if (log_state == LOG_OPENED)

  {

    end_io_cache(&log_file);

 

  log_state= (exiting & LOG_CLOSE_TO_BE_OPENED) ? LOG_TO_BE_OPENED : LOG_CLOSED;

  safeFree(name);

}

 

/** This is called only once. */

 

void MYSQL_LOG::cleanup()

{

  if (inited)

  {

    inited= 0;

    (void) pthread_mutex_destroy(&LOCK_log);

    close(0);

  }

}

 

 

{

  char *save_name;

 

  if (!is_open())

  {

  }

 

  pthread_mutex_lock(&LOCK_log);

 

  pthread_mutex_unlock(&LOCK_log);

 

}

 

 

  }

 

  (void) pthread_mutex_unlock(&LOCK_log);

err:

 

  if (!write_error)

    sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);

  }

  (void) pthread_mutex_unlock(&LOCK_log);

}

 

 

                            const char *sql_text, uint sql_text_len)

{

  bool error= 0;

 

  (void) pthread_mutex_lock(&LOCK_log);

 

  if (!is_open())

  {

    (void) pthread_mutex_unlock(&LOCK_log);

  }

 

  if (is_open())

    }

  }

  (void) pthread_mutex_unlock(&LOCK_log);

}

 

 

 

MYSQL_BIN_LOG::MYSQL_BIN_LOG()

  :bytes_written(0), prepared_xids(0), file_id(1), open_count(1),

   description_event_for_exec(0), description_event_for_queue(0)

{

  /*

 

void MYSQL_BIN_LOG::cleanup()

{

  if (inited)

  {

    inited= 0;

    (void) pthread_mutex_destroy(&LOCK_index);

    (void) pthread_cond_destroy(&update_cond);

  }

}

 

 

/* Init binlog-specific vars */

void MYSQL_BIN_LOG::init(bool no_auto_events_arg, ulong max_size_arg)

{

  no_auto_events= no_auto_events_arg;

  max_size= max_size_arg;

}

 

 

void MYSQL_BIN_LOG::init_pthread_objects()

{

  inited= 1;

  (void) pthread_mutex_init(&LOCK_log, MY_MUTEX_INIT_SLOW);

  (void) pthread_mutex_init(&LOCK_index, MY_MUTEX_INIT_SLOW);

                                const char *log_name)

{

  File index_file_nr= -1;

 

  /*

    First open of this class instance

    */

    if (index_file_nr >= 0)

      my_close(index_file_nr,MYF(0));

  }

}

 

 

                         bool null_created_arg)

{

  File file= -1;

 

  write_error=0;

 

  /* open the main log file */

  if (MYSQL_LOG::open(log_name, log_type_arg, new_name, io_cache_type_arg))

 

  init(no_auto_events_arg, max_size_arg);

 

  open_count++;

 

 

  {

    bool write_file_name_to_index_file=0;

      write_file_name_to_index_file= 1;

    }

 

    reinit_io_cache(&index_file, WRITE_CACHE,

                    my_b_filelength(&index_file), 0, 0);

    if (need_start_event && !no_auto_events)

  }

  log_state= LOG_OPENED;

 

 

err:

  sql_print_error("Could not use %s for logging (error %d). \

  end_io_cache(&index_file);

  safeFree(name);

  log_state= LOG_CLOSED;

}

 

 

  my_off_t init_offset= offset;

  File file= index_file->file;

  uchar io_buf[IO_SIZE*2];

 

  for (;; offset+= bytes_read)

  {

 

  /* Reset data in old index cache */

  reinit_io_cache(index_file, READ_CACHE, (my_off_t) 0, 0, 1);

 

err:

}

 

#endif /* HAVE_REPLICATION */

  int error= 0;

  char *fname= linfo->log_file_name;

  uint log_name_len= log_name ? (uint) strlen(log_name) : 0;

 

  /*

    Mutex needed because we need to make sure the file pointer does not

        (log_name_len == length-1 && fname[log_name_len] == '\n' &&

         !memcmp(fname, log_name, log_name_len)))

    {

      fname[length-1]=0;                        // remove last \n

      linfo->index_file_start_offset= offset;

      linfo->index_file_offset = my_b_tell(&index_file);

 

  if (need_lock)

    pthread_mutex_unlock(&LOCK_index);

}

 

 

  LOG_INFO linfo;

  bool error=0;

  const char* save_name;

 

  ha_reset_logs(thd);

  /*

  VOID(pthread_mutex_unlock(&LOCK_thread_count));

  pthread_mutex_unlock(&LOCK_index);

  pthread_mutex_unlock(&LOCK_log);

}

 

 

int MYSQL_BIN_LOG::purge_first_log(Relay_log_info* rli, bool included)

{

  int error;

 

 

  pthread_mutex_lock(&LOCK_index);

  pthread_mutex_lock(&rli->log_space_lock);

 

err:

  pthread_mutex_unlock(&LOCK_index);

}

 

/**

  int ret = 0;

  bool exit_loop= 0;

  LOG_INFO log_info;

 

  if (need_mutex)

    pthread_mutex_lock(&LOCK_index);

    }

    else

    {

      if (!my_delete(log_info.log_file_name, MYF(0)))

      {

        if (decrease_log_space)

                              log_info.log_file_name);

          if (my_errno == EMFILE)

          {

            error= LOG_INFO_EMFILE;

          }

          error= LOG_INFO_FATAL;

err:

  if (need_mutex)

    pthread_mutex_unlock(&LOCK_index);

}

 

/**

  LOG_INFO log_info;

  struct stat stat_area;

 

  pthread_mutex_lock(&LOCK_index);

 

  /*

 

err:

  pthread_mutex_unlock(&LOCK_index);

}

#endif /* HAVE_REPLICATION */

 

{

  char new_name[FN_REFLEN], *new_name_ptr, *old_name;

 

  if (!is_open())

  {

  }

 

  if (need_lock)

    tc_log_page_waits++;

    pthread_mutex_lock(&LOCK_prep_xids);

    while (prepared_xids) {

      pthread_cond_wait(&COND_prep_xids, &LOCK_prep_xids);

    }

    pthread_mutex_unlock(&LOCK_prep_xids);

    pthread_mutex_unlock(&LOCK_log);

  pthread_mutex_unlock(&LOCK_index);

 

}

 

 

{

  bool error = 0;

  pthread_mutex_lock(&LOCK_log);

 

  /*

    Log_event::write() is smart enough to use my_b_write() or

    my_b_append() depending on the kind of cache we have.

    goto err;

  }

  bytes_written+= ev->data_written;

  if ((uint) my_b_append_tell(&log_file) > max_size)

    new_file_without_locking();

 

err:

  pthread_mutex_unlock(&LOCK_log);

  signal_update();                              // Safe as we don't call close

}

 

 

bool MYSQL_BIN_LOG::appendv(const char* buf, uint len,...)

{

  bool error= 0;

  va_list(args);

  va_start(args,len);

 

 

  safe_mutex_assert_owner(&LOCK_log);

  do

    }

    bytes_written += len;

  } while ((buf=va_arg(args,const char*)) && (len=va_arg(args,uint)));

  if ((uint) my_b_append_tell(&log_file) > max_size)

    new_file_without_locking();

 

err:

  if (!error)

    signal_update();

}

 

 

 

void MYSQL_BIN_LOG::start_union_events(THD *thd, query_id_t query_id_param)

{

  thd->binlog_evt_union.first_query_id= query_id_param;

}

 

void MYSQL_BIN_LOG::stop_union_events(THD *thd)

{

}

 

bool MYSQL_BIN_LOG::is_query_in_union(THD *thd, query_id_t query_id_param)

 

int THD::binlog_setup_trx_data()

{

  binlog_trx_data *trx_data=

    (binlog_trx_data*) thd_get_ha_data(this, binlog_hton);

 

  if (trx_data)

 

  trx_data= (binlog_trx_data*) my_malloc(sizeof(binlog_trx_data), MYF(MY_ZEROFILL));

  if (!trx_data ||

                       LOG_PREFIX, binlog_cache_size, MYF(MY_WME)))

  {

    my_free((uchar*)trx_data, MYF(MY_ALLOW_ZERO_PTR));

  }

  thd_set_ha_data(this, binlog_hton, trx_data);

 

  trx_data= new (thd_get_ha_data(this, binlog_hton)) binlog_trx_data;

 

}

 

/*

THD::binlog_start_trans_and_stmt()

{

  binlog_trx_data *trx_data= (binlog_trx_data*) thd_get_ha_data(this, binlog_hton);

 

  if (trx_data == NULL ||

      trx_data->before_stmt_pos == MY_OFF_T_UNDEF)

  {

    this->binlog_set_stmt_begin();

    if (options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))

    /*

      Mark statement transaction as read/write. We never start

      a binary log transaction and keep it read-only,

    */

    ha_data[binlog_hton->slot].ha_info[0].set_trx_read_write();

  }

}

 

void THD::binlog_set_stmt_begin() {

int THD::binlog_write_table_map(TABLE *table, bool is_trans)

{

  int error;

 

  /* Pre-conditions */

 

  Table_map_log_event::flag_set const

    flags= Table_map_log_event::TM_NO_FLAGS;

    binlog_start_trans_and_stmt();

 

  if ((error= mysql_bin_log.write(&the_event)))

 

  binlog_table_maps++;

  table->s->table_map_version= mysql_bin_log.table_map_version();

}

 

Rows_log_event*

  binlog_trx_data *const trx_data=

    (binlog_trx_data*) thd_get_ha_data(this, binlog_hton);

 

  trx_data->set_pending(ev);

}

 

MYSQL_BIN_LOG::flush_and_set_pending_rows_event(THD *thd,

                                                Rows_log_event* event)

{

 

  int error= 0;

 

  binlog_trx_data *const trx_data=

    (binlog_trx_data*) thd_get_ha_data(thd, binlog_hton);

 

 

  if (Rows_log_event* pending= trx_data->pending())

  {

    if (pending->write(file))

    {

      pthread_mutex_unlock(&LOCK_log);

    }

 

    /*

 

  thd->binlog_set_pending_rows_event(event);

 

}

 

/**

{

  THD *thd= event_info->thd;

  bool error= 1;

 

  if (thd->binlog_evt_union.do_union)

  {

      In Stored function; Remember that function call caused an update.

      We will log the function call to the binary log on function exit

    */

    thd->binlog_evt_union.unioned_events_trans |= event_info->cache_stmt;

  }

 

  /*

        (!binlog_filter->db_ok(local_db)))

    {

      VOID(pthread_mutex_unlock(&LOCK_log));

    }

 

    /*

      my_off_t trans_log_pos= my_b_tell(trans_log);

      if (event_info->get_cache_stmt() || trans_log_pos != 0)

      {

        if (trans_log_pos == 0)

          thd->binlog_start_trans_and_stmt();

        file= trans_log;

        LOCK_log.

      */

    }

 

    /*

      No check for auto events flag here - this write method should

        }

        if (thd->auto_inc_intervals_in_cur_stmt_for_binlog.nb_elements() > 0)

        {

          /*

            If the auto_increment was second in a table's index (possible with

            MyISAM or BDB) (table->next_number_keypart != 0), such event is

    ++m_table_map_version;

 

  pthread_mutex_unlock(&LOCK_log);

}

 

 

    if (thd->options & OPTION_LOG_OFF)

    {

      /* No logging */

    }

 

  }

 

}

 

 

 

  /* Print the message to the buffer if we want to log this king of commands */

  if (! logger.log_command(thd, command))

 

  va_start(args, format);

  error= logger.general_log_print(thd, command, format, args);

  if (logger.log_command(thd, command))

    return logger.general_log_write(thd, command, query, query_length);

 

}

 

void MYSQL_BIN_LOG::rotate_and_purge(uint flags)

    */

    if (unlikely(carry > 0))

    {

 

      /* assemble both halves */

      memcpy(&header[carry], (char *)cache->read_pos, LOG_EVENT_HEADER_LEN - carry);

    cache->read_pos=cache->read_end;            // Mark buffer used up

  } while ((length= my_b_fill(cache)));

 

 

  if (sync_log)

    flush_and_sync();

 

bool MYSQL_BIN_LOG::write(THD *thd, IO_CACHE *cache, Log_event *commit_event)

{

  VOID(pthread_mutex_lock(&LOCK_log));

 

  /* NULL would represent nothing to replicate after ROLLBACK */

 

  if (likely(is_open()))                       // Should always be true

  {

    /*

        transaction is either a BEGIN..COMMIT block or a single

        statement in autocommit mode.

      */

      /*

        Imagine this is rollback due to net timeout, after all

        statements of the transaction succeeded. Then we want a

      if (qinfo.write(&log_file))

        goto err;

 

      if ((write_error= write_cache(cache, false, false)))

        goto err;

 

        goto err;

      if (flush_and_sync())

        goto err;

      if (cache->error)                         // Error on read

      {

        sql_print_error(ER(ER_ERROR_ON_READ), cache->file_name, errno);

  }

  VOID(pthread_mutex_unlock(&LOCK_log));

 

 

err:

  if (!write_error)

    sql_print_error(ER(ER_ERROR_ON_WRITE), name, errno);

  }

  VOID(pthread_mutex_unlock(&LOCK_log));

}

 

 

void MYSQL_BIN_LOG::wait_for_update_relay_log(THD* thd)

{

  const char *old_msg;

  old_msg= thd->enter_cond(&update_cond, &LOCK_log,

                           "Slave has read all relay log; " 

                           "waiting for the slave I/O "

                           "thread to update it" );

  pthread_cond_wait(&update_cond, &LOCK_log);

  thd->exit_cond(old_msg);

}

 

 

{

  int ret= 0;

  const char* old_msg = thd->proc_info;

  old_msg= thd->enter_cond(&update_cond, &LOCK_log,

                           "Master has sent all binlog to slave; "

                           "waiting for binlog to be updated");

  else

    ret= pthread_cond_timedwait(&update_cond, &LOCK_log,

                                const_cast<struct timespec *>(timeout));

}

 

 

 

void MYSQL_BIN_LOG::close(uint exiting)

{                                       // One can't set log_type here!

  if (log_state == LOG_OPENED)

  {

#ifdef HAVE_REPLICATION

  }

  log_state= (exiting & LOG_CLOSE_TO_BE_OPENED) ? LOG_TO_BE_OPENED : LOG_CLOSED;

  safeFree(name);

}

 

 

    uses the old_max_size argument, so max_size_arg has been overwritten and

    it's like if the SET command was never run.

  */

  pthread_mutex_lock(&LOCK_log);

  if (is_open())

    max_size= max_size_arg;

  pthread_mutex_unlock(&LOCK_log);

}

 

 

{

  register int flag;

  const char *start;

 

  flag= 0; 

  start= str;

         str++, flag=1) ;

  }

  if (*str != 0 || flag == 0)

  if (res)

    *res=atol(start);

} /* test_if_number */

 

 

 

void MYSQL_BIN_LOG::signal_update()

{

  pthread_cond_broadcast(&update_cond);

}

 

/**

  time_t skr;

  struct tm tm_tmp;

  struct tm *start;

 

  VOID(pthread_mutex_lock(&LOCK_error_log));

 

  fflush(stderr);

 

  VOID(pthread_mutex_unlock(&LOCK_error_log));

}

 

 

  char   buff[1024];

  size_t length;

  int error_code= errno;

 

  length= vsnprintf(buff, sizeof(buff), format, args);

 

  print_buffer_to_file(level, error_code, buff, length);

 

}

 

 

void sql_print_error(const char *format, ...) 

{

  va_list args;

 

  va_start(args, format);

  error_log_print(ERROR_LEVEL, format, args);

  va_end(args);

 

}

 

 

void sql_print_warning(const char *format, ...) 

{

  va_list args;

 

  va_start(args, format);

  error_log_print(WARNING_LEVEL, format, args);

  va_end(args);

 

}

 

 

void sql_print_information(const char *format, ...) 

{

  va_list args;

 

  va_start(args, format);

  error_log_print(INFORMATION_LEVEL, format, args);

  va_end(args);

 

}

 

 

int TC_LOG_MMAP::open(const char *opt_name)

{

  uint i;

  PAGE *pg;

 

 

  tc_log_page_size= my_getpagesize();

 

  fn_format(logname,opt_name,mysql_data_home,"",MY_UNPACK_FILENAME);

  if ((fd= my_open(logname, O_RDWR, MYF(0))) < 0)

  else

  {

    inited= 1;

    sql_print_information("Recovering after a crash using %s", opt_name);

    if (tc_heuristic_recover)

    {

  inited=2;

 

  npages=(uint)file_length/tc_log_page_size;

  if (!(pages=(PAGE *)my_malloc(npages*sizeof(PAGE), MYF(MY_WME|MY_ZEROFILL))))

    goto err;

  inited=3;

  while (*p->ptr)

  {

    p->ptr++;

  }

 

  /* found! store xid there and mark the page dirty */

      goto done;                             // we're done

    }

  }                                          // page was not synced! do it now