home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / sql / sql_repl.cpp < prev    next >
C/C++ Source or Header  |  2000-11-22  |  20KB  |  792 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.  
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.  
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.  
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  16.  
  17. // Sasha Pachev <sasha@mysql.com> is currently in charge of this file
  18. // Do not mess with it without his permission!
  19.  
  20. #include "mysql_priv.h"
  21. #include "sql_repl.h"
  22. #include "sql_acl.h"
  23. #include "log_event.h"
  24. #include <thr_alarm.h>
  25. #include <my_dir.h>
  26.  
  27. extern const char* any_db;
  28. extern pthread_handler_decl(handle_slave,arg);
  29.  
  30. static int send_file(THD *thd)
  31. {
  32.   NET* net = &thd->net;
  33.   int fd = -1,bytes, error = 1;
  34.   char fname[FN_REFLEN+1];
  35.   char buf[IO_SIZE*15];
  36.   const char *errmsg = 0;
  37.   int old_timeout;
  38.   DBUG_ENTER("send_file");
  39.  
  40.   // the client might be slow loading the data, give him wait_timeout to do
  41.   // the job
  42.   old_timeout = thd->net.timeout;
  43.   thd->net.timeout = thd->inactive_timeout;
  44.  
  45.   // we need net_flush here because the client will not know it needs to send
  46.   // us the file name until it has processed the load event entry
  47.   if (net_flush(net) || my_net_read(net) == packet_error)
  48.   {
  49.     errmsg = "Failed reading file name";
  50.     goto err;
  51.   }
  52.  
  53.   fn_format(fname, (char*)net->read_pos + 1, "", "", 4);
  54.   // this is needed to make replicate-ignore-db
  55.   if (!strcmp(fname,"/dev/null"))
  56.     goto end;
  57.   // TODO: work on the well-known system that does not have a /dev/null :-)
  58.  
  59.   if ((fd = my_open(fname, O_RDONLY, MYF(MY_WME))) < 0)
  60.   {
  61.     errmsg = "Failed on my_open()";
  62.     goto err;
  63.   }
  64.  
  65.   while ((bytes = (int) my_read(fd, (byte*) buf, sizeof(buf),
  66.                 MYF(MY_WME))) > 0)
  67.   {
  68.     if (my_net_write(net, buf, bytes))
  69.     {
  70.       errmsg = "Failed on my_net_write()";
  71.       goto err;
  72.     }
  73.   }
  74.  
  75.  end:
  76.   if (my_net_write(net, "", 0) || net_flush(net) ||
  77.       (my_net_read(net) == packet_error))
  78.   {
  79.     errmsg = "failed negotiating file transfer close";
  80.     goto err;
  81.   }
  82.   error = 0;
  83.  
  84.  err:
  85.   thd->net.timeout = old_timeout;
  86.   if(fd >= 0)
  87.     (void) my_close(fd, MYF(MY_WME));
  88.   if (errmsg)
  89.   {
  90.     sql_print_error("failed in send_file() : %s", errmsg);
  91.     DBUG_PRINT("error", (errmsg));
  92.   }
  93.   DBUG_RETURN(error);
  94. }
  95.  
  96.  
  97. static File open_log(IO_CACHE *log, const char *log_file_name,
  98.              const char **errmsg)
  99. {
  100.   File file;
  101.   char magic[4];
  102.   if ((file = my_open(log_file_name, O_RDONLY | O_BINARY, MYF(MY_WME))) < 0 ||
  103.       init_io_cache(log, file, IO_SIZE*2, READ_CACHE, 0, 0,
  104.             MYF(MY_WME)))
  105.   {
  106.     *errmsg = "Could not open log file";        // This will not be sent
  107.     goto err;
  108.   }
  109.   
  110.   if (my_b_read(log, (byte*) magic, sizeof(magic)))
  111.   {
  112.     *errmsg = "I/O error reading binlog magic number";
  113.     goto err;
  114.   }
  115.   if (memcmp(magic, BINLOG_MAGIC, 4))
  116.   {
  117.     *errmsg = "Binlog has bad magic number, fire your magician";
  118.     goto err;
  119.   }
  120.   return file;
  121.  
  122. err:
  123.   if (file > 0)
  124.     my_close(file,MYF(0));
  125.   end_io_cache(log);
  126.   return -1;
  127. }
  128.  
  129.  
  130. void adjust_linfo_offsets(my_off_t purge_offset)
  131. {
  132.   THD *tmp;
  133.   
  134.   pthread_mutex_lock(&LOCK_thread_count);
  135.   I_List_iterator<THD> it(threads);
  136.   
  137.   while((tmp=it++))
  138.     {
  139.       LOG_INFO* linfo;
  140.     if((linfo = tmp->current_linfo))
  141.     {
  142.       pthread_mutex_lock(&linfo->lock);
  143.       // no big deal if we just started reading the log
  144.       // nothing to adjust
  145.       if(linfo->index_file_offset < purge_offset)
  146.         linfo->fatal = (linfo->index_file_offset != 0);
  147.       else
  148.         linfo->index_file_offset -= purge_offset;
  149.       pthread_mutex_unlock(&linfo->lock);
  150.     }
  151.    }
  152.  
  153.   pthread_mutex_unlock(&LOCK_thread_count);
  154. }
  155.  
  156.  
  157. bool log_in_use(const char* log_name)
  158. {
  159.   int log_name_len = strlen(log_name) + 1;
  160.   THD *tmp;
  161.   bool result = 0;
  162.   
  163.   pthread_mutex_lock(&LOCK_thread_count);
  164.   I_List_iterator<THD> it(threads);
  165.   
  166.   while((tmp=it++))
  167.     {
  168.       LOG_INFO* linfo;
  169.       if((linfo = tmp->current_linfo))
  170.     {
  171.       pthread_mutex_lock(&linfo->lock);
  172.       result = !memcmp(log_name, linfo->log_file_name, log_name_len);
  173.       pthread_mutex_unlock(&linfo->lock);
  174.       if(result) break;
  175.     }
  176.    }
  177.  
  178.   pthread_mutex_unlock(&LOCK_thread_count);
  179.   return result;
  180. }
  181.  
  182.  
  183. int purge_master_logs(THD* thd, const char* to_log)
  184. {
  185.   char search_file_name[FN_REFLEN];
  186.   mysql_bin_log.make_log_name(search_file_name, to_log);
  187.   int res = mysql_bin_log.purge_logs(thd, search_file_name);
  188.   const char* errmsg = 0;
  189.   switch(res)
  190.     {
  191.     case 0: break;
  192.     case LOG_INFO_EOF: errmsg = "Target log not found in binlog index"; break;
  193.     case LOG_INFO_IO: errmsg = "I/O error reading log index file"; break;
  194.     case LOG_INFO_INVALID: errmsg = "Server configuration does not permit \
  195. binlog purge"; break;
  196.     case LOG_INFO_SEEK: errmsg = "Failed on fseek()"; break;
  197.     case LOG_INFO_PURGE_NO_ROTATE: errmsg = "Cannot purge unrotatable log";
  198.       break;
  199.     case LOG_INFO_MEM: errmsg = "Out of memory"; break;
  200.     case LOG_INFO_FATAL: errmsg = "Fatal error during purge"; break;
  201.     case LOG_INFO_IN_USE: errmsg = "A purgable log is in use, will not purge";
  202.       break;
  203.     default:
  204.       errmsg = "Unknown error during purge"; break;
  205.     }
  206.   
  207.   if(errmsg)
  208.     {
  209.      send_error(&thd->net, 0, errmsg);
  210.      return 1;
  211.     }
  212.   else
  213.     send_ok(&thd->net);
  214.   
  215.   return 0;
  216. }
  217.  
  218.  
  219. void mysql_binlog_send(THD* thd, char* log_ident, ulong pos, ushort flags)
  220. {
  221.   LOG_INFO linfo;
  222.   char *log_file_name = linfo.log_file_name;
  223.   char search_file_name[FN_REFLEN];
  224.   IO_CACHE log;
  225.   File file = -1;
  226.   String* packet = &thd->packet;
  227.   int error;
  228.   const char *errmsg = "Unknown error";
  229.   NET* net = &thd->net;
  230.   DBUG_ENTER("mysql_binlog_send");
  231.  
  232.   bzero((char*) &log,sizeof(log));
  233.  
  234.   if(!mysql_bin_log.is_open())
  235.   {
  236.     errmsg = "Binary log is not open";
  237.     goto err;
  238.   }
  239.  
  240.   if (log_ident[0])
  241.     mysql_bin_log.make_log_name(search_file_name, log_ident);
  242.   else
  243.     search_file_name[0] = 0;
  244.   
  245.   linfo.index_file_offset = 0;
  246.   thd->current_linfo = &linfo;
  247.  
  248.   if (mysql_bin_log.find_first_log(&linfo, search_file_name))
  249.   {
  250.     errmsg = "Could not find first log";
  251.     goto err;
  252.   }
  253.  
  254.   if ((file=open_log(&log, log_file_name, &errmsg)) < 0)
  255.     goto err;
  256.  
  257.   if(pos < 4)
  258.   {
  259.     errmsg = "Congratulations! You have hit the magic number and can win \
  260. sweepstakes if you report the bug";
  261.     goto err;
  262.   }
  263.  
  264.   my_b_seek(&log, pos);                // Seek will done on next read
  265.   packet->length(0);
  266.   packet->append("\0", 1);
  267.   // we need to start a packet with something other than 255
  268.   // to distiquish it from error
  269.  
  270.   while(!net->error && net->vio != 0 && !thd->killed)
  271.   {
  272.     pthread_mutex_t *log_lock = mysql_bin_log.get_log_lock();
  273.       
  274.     while (!(error = Log_event::read_log_event(&log, packet, log_lock)))
  275.     {
  276.       if(my_net_write(net, (char*)packet->ptr(), packet->length()) )
  277.       {
  278.     errmsg = "Failed on my_net_write()";
  279.     goto err;
  280.       }
  281.       DBUG_PRINT("info", ("log event code %d",
  282.               (*packet)[LOG_EVENT_OFFSET+1] ));
  283.       if((*packet)[LOG_EVENT_OFFSET+1] == LOAD_EVENT)
  284.       {
  285.     if(send_file(thd))
  286.     {
  287.       errmsg = "failed in send_file()";
  288.       goto err;
  289.     }
  290.       }
  291.       packet->length(0);
  292.       packet->append("\0",1);
  293.     }
  294.     
  295.     
  296.     if(error != LOG_READ_EOF)
  297.     {
  298.       switch(error)
  299.       {
  300.       case LOG_READ_BOGUS: 
  301.     errmsg = "bogus data in log event";
  302.     break;
  303.       case LOG_READ_IO:
  304.     errmsg = "I/O error reading log event";
  305.     break;
  306.       case LOG_READ_MEM:
  307.     errmsg = "memory allocation failed reading log event";
  308.     break;
  309.       case LOG_READ_TRUNC:
  310.     errmsg = "binlog truncated in the middle of event";
  311.     break;
  312.       default:
  313.     errmsg = "unknown error reading log event on the master";
  314.     break;
  315.       }
  316.       goto err;
  317.     }
  318.  
  319.     if(!(flags & BINLOG_DUMP_NON_BLOCK) &&
  320.        mysql_bin_log.is_active(log_file_name))
  321.       // block until there is more data in the log
  322.       // unless non-blocking mode requested
  323.     {
  324.       if(net_flush(net))
  325.       {
  326.     errmsg = "failed on net_flush()";
  327.     goto err;
  328.       }
  329.  
  330.       // we may have missed the update broadcast from the log
  331.       // that has just happened, let's try to catch it if it did
  332.       // if we did not miss anything, we just wait for other threads
  333.       // to signal us
  334.       {
  335.     log.error=0;
  336.  
  337.     // tell the kill thread how to wake us up
  338.     pthread_mutex_lock(&thd->mysys_var->mutex);
  339.     thd->mysys_var->current_mutex = log_lock;
  340.     thd->mysys_var->current_cond = &COND_binlog_update;
  341.     const char* proc_info = thd->proc_info;
  342.     thd->proc_info = "Waiting for update";
  343.     pthread_mutex_unlock(&thd->mysys_var->mutex);
  344.  
  345.     bool read_packet = 0, fatal_error = 0;
  346.  
  347.     // no one will update the log while we are reading
  348.     // now, but we'll be quick and just read one record
  349.     switch(Log_event::read_log_event(&log, packet, log_lock))
  350.     {
  351.     case 0:
  352.       read_packet = 1;
  353.       // we read successfully, so we'll need to send it to the
  354.       // slave
  355.       break;
  356.     case LOG_READ_EOF:
  357.       pthread_mutex_lock(log_lock);
  358.       pthread_cond_wait(&COND_binlog_update, log_lock);
  359.       pthread_mutex_unlock(log_lock);
  360.       break;
  361.  
  362.     default:
  363.       fatal_error = 1;
  364.       break;
  365.     }
  366.  
  367.     pthread_mutex_lock(&thd->mysys_var->mutex);
  368.     thd->mysys_var->current_mutex= 0;
  369.     thd->mysys_var->current_cond= 0;
  370.     thd->proc_info= proc_info;
  371.     pthread_mutex_unlock(&thd->mysys_var->mutex);
  372.  
  373.     if(read_packet)
  374.     {
  375.       thd->proc_info = "sending update to slave";
  376.       if(my_net_write(net, (char*)packet->ptr(), packet->length()) )
  377.       {
  378.         errmsg = "Failed on my_net_write()";
  379.         goto err;
  380.       }
  381.  
  382.       if((*packet)[LOG_EVENT_OFFSET+1] == LOAD_EVENT)
  383.       {
  384.         if(send_file(thd))
  385.         {
  386.           errmsg = "failed in send_file()";
  387.           goto err;
  388.         }
  389.       }
  390.       packet->length(0);
  391.       packet->append("\0",1);
  392.       // no need to net_flush because we will get to flush later when
  393.       // we hit EOF pretty quick
  394.     }
  395.  
  396.     if(fatal_error)
  397.     {
  398.       errmsg = "error reading log entry";
  399.       goto err;
  400.     }
  401.     log.error=0;
  402.       }
  403.     }
  404.     else
  405.     {
  406.       bool loop_breaker = 0;
  407.       // need this to break out of the for loop from switch
  408.       thd->proc_info = "switching to next log";
  409.       switch(mysql_bin_log.find_next_log(&linfo))
  410.       {
  411.       case LOG_INFO_EOF:
  412.     loop_breaker = (flags & BINLOG_DUMP_NON_BLOCK);
  413.     break;
  414.       case 0:
  415.     break;
  416.       default:
  417.     errmsg = "could not find next log";
  418.     goto err;
  419.       }
  420.  
  421.       if(loop_breaker)
  422.     break;
  423.  
  424.       end_io_cache(&log);
  425.       (void) my_close(file, MYF(MY_WME));
  426.       if ((file=open_log(&log, log_file_name, &errmsg)) < 0)
  427.     goto err;
  428.  
  429.       // fake Rotate_log event just in case it did not make it to the log
  430.       // otherwise the slave make get confused about the offset
  431.       {
  432.     char header[LOG_EVENT_HEADER_LEN];
  433.     memset(header, 0, 4); // when does not matter
  434.     header[EVENT_TYPE_OFFSET] = ROTATE_EVENT;
  435.     char* p = strrchr(log_file_name, FN_LIBCHAR);
  436.     // find the last slash
  437.     if(p)
  438.       p++;
  439.     else
  440.       p = log_file_name;
  441.  
  442.     uint ident_len = (uint) strlen(p);
  443.     ulong event_len = ident_len + sizeof(header);
  444.     int4store(header + EVENT_TYPE_OFFSET + 1, server_id);
  445.     int4store(header + EVENT_LEN_OFFSET, event_len);
  446.     packet->append(header, sizeof(header));
  447.     packet->append(p,ident_len);
  448.     if(my_net_write(net, (char*)packet->ptr(), packet->length()))
  449.     {
  450.       errmsg = "failed on my_net_write()";
  451.       goto err;
  452.     }
  453.     packet->length(0);
  454.     packet->append("\0",1);
  455.       }
  456.     }
  457.   }
  458.  
  459.   end_io_cache(&log);
  460.   (void)my_close(file, MYF(MY_WME));
  461.   
  462.   send_eof(&thd->net);
  463.   thd->proc_info = "waiting to finalize termination";
  464.   pthread_mutex_lock(&LOCK_thread_count);
  465.   thd->current_linfo = 0;
  466.   pthread_mutex_unlock(&LOCK_thread_count);
  467.   DBUG_VOID_RETURN;
  468.  err:
  469.   thd->proc_info = "waiting to finalize termination";
  470.   end_io_cache(&log);
  471.   pthread_mutex_lock(&LOCK_thread_count);
  472.   // exclude  iteration through thread list
  473.   // this is needed for purge_logs() - it will iterate through
  474.   // thread list and update thd->current_linfo->index_file_offset
  475.   // this mutex will make sure that it never tried to update our linfo
  476.   // after we return from this stack frame
  477.   thd->current_linfo = 0;
  478.   pthread_mutex_unlock(&LOCK_thread_count);
  479.   if (file >= 0)
  480.     (void) my_close(file, MYF(MY_WME));
  481.   send_error(&thd->net, my_errno, errmsg);
  482.   DBUG_VOID_RETURN;
  483. }
  484.  
  485. int start_slave(THD* thd , bool net_report)
  486. {
  487.   if(!thd) thd = current_thd;
  488.   NET* net = &thd->net;
  489.   const char* err = 0;
  490.   if (check_access(thd, PROCESS_ACL, any_db))
  491.     return 1;
  492.   pthread_mutex_lock(&LOCK_slave);
  493.   if(!slave_running)
  494.     if(glob_mi.inited && glob_mi.host)
  495.       {
  496.     pthread_t hThread;
  497.     if(pthread_create(&hThread, &connection_attrib, handle_slave, 0))
  498.       {
  499.         err = "cannot create slave thread";
  500.       }
  501.       }
  502.     else
  503.       err = "Master host not set or master info not initialized";
  504.   else
  505.     err =  "Slave already running";
  506.  
  507.   pthread_mutex_unlock(&LOCK_slave);
  508.   if(err)
  509.     {
  510.       if(net_report) send_error(net, 0, err);
  511.       return 1;
  512.     }
  513.   else if(net_report)
  514.     send_ok(net);
  515.  
  516.   return 0;
  517. }
  518.  
  519. int stop_slave(THD* thd, bool net_report )
  520. {
  521.   if(!thd) thd = current_thd;
  522.   NET* net = &thd->net;
  523.   const char* err = 0;
  524.  
  525.   if (check_access(thd, PROCESS_ACL, any_db))
  526.     return 1;
  527.  
  528.   pthread_mutex_lock(&LOCK_slave);
  529.   if (slave_running)
  530.   {
  531.     abort_slave = 1;
  532.     thr_alarm_kill(slave_real_id);
  533.     // do not abort the slave in the middle of a query, so we do not set
  534.     // thd->killed for the slave thread
  535.     thd->proc_info = "waiting for slave to die";
  536.     pthread_cond_wait(&COND_slave_stopped, &LOCK_slave);
  537.   }
  538.   else
  539.     err = "Slave is not running";
  540.  
  541.   pthread_mutex_unlock(&LOCK_slave);
  542.   thd->proc_info = 0;
  543.  
  544.   if(err)
  545.     {
  546.      if(net_report) send_error(net, 0, err);
  547.      return 1;
  548.     }
  549.   else if(net_report)
  550.     send_ok(net);
  551.  
  552.   return 0;
  553. }
  554.  
  555. void reset_slave()
  556. {
  557.   MY_STAT stat_area;
  558.   char fname[FN_REFLEN];
  559.   bool slave_was_running = slave_running;
  560.  
  561.   if(slave_running)
  562.     stop_slave(0,0);
  563.  
  564.   fn_format(fname, master_info_file, mysql_data_home, "", 4+16+32);
  565.   if(my_stat(fname, &stat_area, MYF(0)))
  566.     if(my_delete(fname, MYF(MY_WME)))
  567.         return;
  568.  
  569.   if(slave_was_running)
  570.     start_slave(0,0);
  571. }
  572.  
  573. void kill_zombie_dump_threads(uint32 slave_server_id)
  574. {
  575.   pthread_mutex_lock(&LOCK_thread_count);
  576.   I_List_iterator<THD> it(threads);
  577.   THD *tmp;
  578.  
  579.   while((tmp=it++))
  580.     {
  581.       if(tmp->command == COM_BINLOG_DUMP &&
  582.      tmp->server_id == slave_server_id)
  583.     {
  584.       // here we do not call kill_one_thread()
  585.       // it will be slow because it will iterate through the list
  586.       // again. Plus it double-locks LOCK_thread_count, which
  587.       // make safe_mutex complain and abort
  588.       // so we just to our own thread murder
  589.       
  590.       thr_alarm_kill(tmp->real_id);
  591.       tmp->killed = 1;
  592.       pthread_mutex_lock(&tmp->mysys_var->mutex);
  593.           tmp->mysys_var->abort = 1;
  594.       if(tmp->mysys_var->current_mutex)
  595.         {
  596.           pthread_mutex_lock(tmp->mysys_var->current_mutex);
  597.           pthread_cond_broadcast(tmp->mysys_var->current_cond);
  598.           pthread_mutex_unlock(tmp->mysys_var->current_mutex);
  599.         }
  600.       pthread_mutex_unlock(&tmp->mysys_var->mutex);
  601.     }
  602.    }
  603.   
  604.   pthread_mutex_unlock(&LOCK_thread_count);
  605. }
  606.  
  607. int change_master(THD* thd)
  608. {
  609.   bool slave_was_running;
  610.   // kill slave thread
  611.   pthread_mutex_lock(&LOCK_slave);
  612.   if((slave_was_running = slave_running))
  613.     {
  614.       abort_slave = 1;
  615.       thr_alarm_kill(slave_real_id);
  616.       thd->proc_info = "waiting for slave to die";
  617.       pthread_cond_wait(&COND_slave_stopped, &LOCK_slave); // wait until done
  618.     }
  619.   pthread_mutex_unlock(&LOCK_slave);
  620.   thd->proc_info = "changing master";
  621.   LEX_MASTER_INFO* lex_mi = &thd->lex.mi;
  622.  
  623.   if(!glob_mi.inited)
  624.     init_master_info(&glob_mi);
  625.   
  626.   pthread_mutex_lock(&glob_mi.lock);
  627.   if((lex_mi->host || lex_mi->port) && !lex_mi->log_file_name && !lex_mi->pos)
  628.     {
  629.       // if we change host or port, we must reset the postion
  630.       glob_mi.log_file_name[0] = 0;
  631.       glob_mi.pos = 4; // skip magic number
  632.     }
  633.  
  634.   if(lex_mi->log_file_name)
  635.     strmake(glob_mi.log_file_name, lex_mi->log_file_name,
  636.         sizeof(glob_mi.log_file_name));
  637.   if(lex_mi->pos)
  638.     glob_mi.pos = lex_mi->pos;
  639.  
  640.   if(lex_mi->host)
  641.     strmake(glob_mi.host, lex_mi->host, sizeof(glob_mi.host));
  642.   if(lex_mi->user)
  643.     strmake(glob_mi.user, lex_mi->user, sizeof(glob_mi.user));
  644.   if(lex_mi->password)
  645.     strmake(glob_mi.password, lex_mi->password, sizeof(glob_mi.password));
  646.   if(lex_mi->port)
  647.     glob_mi.port = lex_mi->port;
  648.   if(lex_mi->connect_retry)
  649.     glob_mi.connect_retry = lex_mi->connect_retry;
  650.  
  651.   flush_master_info(&glob_mi);
  652.   pthread_mutex_unlock(&glob_mi.lock);
  653.   thd->proc_info = "starting slave";
  654.   if(slave_was_running)
  655.     start_slave(0,0);
  656.   thd->proc_info = 0;
  657.  
  658.   send_ok(&thd->net);
  659.   return 0;
  660. }
  661.  
  662. void reset_master()
  663. {
  664.   if(!mysql_bin_log.is_open())
  665.   {
  666.     my_error(ER_FLUSH_MASTER_BINLOG_CLOSED,  MYF(ME_BELL+ME_WAITTANG));
  667.     return;
  668.   }
  669.  
  670.   LOG_INFO linfo;
  671.   if (mysql_bin_log.find_first_log(&linfo, ""))
  672.     return;
  673.  
  674.   for(;;)
  675.   {
  676.     my_delete(linfo.log_file_name, MYF(MY_WME));
  677.     if (mysql_bin_log.find_next_log(&linfo))
  678.       break;
  679.   }
  680.   mysql_bin_log.close(1); // exiting close
  681.   my_delete(mysql_bin_log.get_index_fname(), MYF(MY_WME));
  682.   mysql_bin_log.open(opt_bin_logname,LOG_BIN);
  683.  
  684. }
  685.  
  686. int show_binlog_info(THD* thd)
  687. {
  688.   DBUG_ENTER("show_binlog_info");
  689.   List<Item> field_list;
  690.   field_list.push_back(new Item_empty_string("File", FN_REFLEN));
  691.   field_list.push_back(new Item_empty_string("Position",20));
  692.   field_list.push_back(new Item_empty_string("Binlog_do_db",20));
  693.   field_list.push_back(new Item_empty_string("Binlog_ignore_db",20));
  694.  
  695.   if(send_fields(thd, field_list, 1))
  696.     DBUG_RETURN(-1);
  697.   String* packet = &thd->packet;
  698.   packet->length(0);
  699.  
  700.   if(mysql_bin_log.is_open())
  701.     {
  702.       LOG_INFO li;
  703.       mysql_bin_log.get_current_log(&li);
  704.       int dir_len = dirname_length(li.log_file_name);
  705.       net_store_data(packet, li.log_file_name + dir_len);
  706.       net_store_data(packet, (longlong)li.pos);
  707.       net_store_data(packet, &binlog_do_db);
  708.       net_store_data(packet, &binlog_ignore_db);
  709.     }
  710.   else
  711.     {
  712.       net_store_null(packet);
  713.       net_store_null(packet);
  714.       net_store_null(packet);
  715.       net_store_null(packet);
  716.     }
  717.  
  718.   if(my_net_write(&thd->net, (char*)thd->packet.ptr(), packet->length()))
  719.     DBUG_RETURN(-1);
  720.  
  721.   send_eof(&thd->net);
  722.   DBUG_RETURN(0);
  723. }
  724.  
  725. int show_binlogs(THD* thd)
  726. {
  727.   const char* errmsg = 0;
  728.   File index_file;
  729.   char fname[FN_REFLEN];
  730.   NET* net = &thd->net;
  731.   List<Item> field_list;
  732.   String* packet = &thd->packet;
  733.   IO_CACHE io_cache;
  734.   uint length;
  735.   
  736.   if(!mysql_bin_log.is_open())
  737.   {
  738.     errmsg = "binlog is not open";
  739.     goto err;
  740.   }
  741.  
  742.   field_list.push_back(new Item_empty_string("Log_name", 128));
  743.   if(send_fields(thd, field_list, 1))
  744.   {
  745.     sql_print_error("Failed in send_fields");
  746.     return 1;
  747.   }
  748.   
  749.   mysql_bin_log.lock_index();
  750.   index_file = mysql_bin_log.get_index_file();
  751.   if (index_file < 0)
  752.   {
  753.     errmsg = "Uninitialized index file pointer";
  754.     goto err2;
  755.   }
  756.   if (init_io_cache(&io_cache, index_file, IO_SIZE, READ_CACHE, 0, 0,
  757.            MYF(MY_WME)))
  758.   {
  759.     errmsg = "Failed on init_io_cache()";
  760.     goto err2;
  761.   }
  762.   while ((length=my_b_gets(&io_cache, fname, sizeof(fname))))
  763.   {
  764.     fname[--length]=0;
  765.     int dir_len = dirname_length(fname);
  766.     packet->length(0);
  767.     net_store_data(packet, fname + dir_len, length-dir_len);
  768.     if(my_net_write(net, (char*) packet->ptr(), packet->length()))
  769.     {
  770.       sql_print_error("Failed in my_net_write");
  771.       end_io_cache(&io_cache);
  772.       mysql_bin_log.unlock_index();
  773.       return 1;
  774.     }
  775.   }
  776.   
  777.   mysql_bin_log.unlock_index();
  778.   end_io_cache(&io_cache);
  779.   send_eof(net);   
  780.   return 0;
  781.  
  782. err2:
  783.   mysql_bin_log.unlock_index();
  784.   end_io_cache(&io_cache);
  785. err:
  786.   send_error(net, 0, errmsg);
  787.   return 1;
  788. }
  789.  
  790.  
  791.  
  792.