slave.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:144k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000-2003 MySQL 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. #include "mysql_priv.h"
  17. #ifdef HAVE_REPLICATION
  18. #include <mysql.h>
  19. #include <myisam.h>
  20. #include "slave.h"
  21. #include "sql_repl.h"
  22. #include "repl_failsafe.h"
  23. #include <thr_alarm.h>
  24. #include <my_dir.h>
  25. #include <sql_common.h>
  26. #define MAX_SLAVE_RETRY_PAUSE 5
  27. bool use_slave_mask = 0;
  28. MY_BITMAP slave_error_mask;
  29. typedef bool (*CHECK_KILLED_FUNC)(THD*,void*);
  30. volatile bool slave_sql_running = 0, slave_io_running = 0;
  31. char* slave_load_tmpdir = 0;
  32. MASTER_INFO *active_mi;
  33. HASH replicate_do_table, replicate_ignore_table;
  34. DYNAMIC_ARRAY replicate_wild_do_table, replicate_wild_ignore_table;
  35. bool do_table_inited = 0, ignore_table_inited = 0;
  36. bool wild_do_table_inited = 0, wild_ignore_table_inited = 0;
  37. bool table_rules_on= 0, replicate_same_server_id;
  38. ulonglong relay_log_space_limit = 0;
  39. /*
  40.   When slave thread exits, we need to remember the temporary tables so we
  41.   can re-use them on slave start.
  42.   TODO: move the vars below under MASTER_INFO
  43. */
  44. int disconnect_slave_event_count = 0, abort_slave_event_count = 0;
  45. int events_till_abort = -1;
  46. static int events_till_disconnect = -1;
  47. typedef enum { SLAVE_THD_IO, SLAVE_THD_SQL} SLAVE_THD_TYPE;
  48. static int process_io_rotate(MASTER_INFO* mi, Rotate_log_event* rev);
  49. static int process_io_create_file(MASTER_INFO* mi, Create_file_log_event* cev);
  50. static bool wait_for_relay_log_space(RELAY_LOG_INFO* rli);
  51. static inline bool io_slave_killed(THD* thd,MASTER_INFO* mi);
  52. static inline bool sql_slave_killed(THD* thd,RELAY_LOG_INFO* rli);
  53. static int count_relay_log_space(RELAY_LOG_INFO* rli);
  54. static int init_slave_thread(THD* thd, SLAVE_THD_TYPE thd_type);
  55. static int safe_connect(THD* thd, MYSQL* mysql, MASTER_INFO* mi);
  56. static int safe_reconnect(THD* thd, MYSQL* mysql, MASTER_INFO* mi,
  57.   bool suppress_warnings);
  58. static int connect_to_master(THD* thd, MYSQL* mysql, MASTER_INFO* mi,
  59.      bool reconnect, bool suppress_warnings);
  60. static int safe_sleep(THD* thd, int sec, CHECK_KILLED_FUNC thread_killed,
  61.       void* thread_killed_arg);
  62. static int request_table_dump(MYSQL* mysql, const char* db, const char* table);
  63. static int create_table_from_dump(THD* thd, MYSQL *mysql, const char* db,
  64.   const char* table_name, bool overwrite);
  65. static int get_master_version_and_clock(MYSQL* mysql, MASTER_INFO* mi);
  66. /*
  67.   Find out which replications threads are running
  68.   SYNOPSIS
  69.     init_thread_mask()
  70.     mask Return value here
  71.     mi master_info for slave
  72.     inverse If set, returns which threads are not running
  73.   IMPLEMENTATION
  74.     Get a bit mask for which threads are running so that we can later restart
  75.     these threads.
  76.   RETURN
  77.     mask If inverse == 0, running threads
  78. If inverse == 1, stopped threads    
  79. */
  80. void init_thread_mask(int* mask,MASTER_INFO* mi,bool inverse)
  81. {
  82.   bool set_io = mi->slave_running, set_sql = mi->rli.slave_running;
  83.   register int tmp_mask=0;
  84.   if (set_io)
  85.     tmp_mask |= SLAVE_IO;
  86.   if (set_sql)
  87.     tmp_mask |= SLAVE_SQL;
  88.   if (inverse)
  89.     tmp_mask^= (SLAVE_IO | SLAVE_SQL);
  90.   *mask = tmp_mask;
  91. }
  92. /*
  93.   lock_slave_threads()
  94. */
  95. void lock_slave_threads(MASTER_INFO* mi)
  96. {
  97.   //TODO: see if we can do this without dual mutex
  98.   pthread_mutex_lock(&mi->run_lock);
  99.   pthread_mutex_lock(&mi->rli.run_lock);
  100. }
  101. /*
  102.   unlock_slave_threads()
  103. */
  104. void unlock_slave_threads(MASTER_INFO* mi)
  105. {
  106.   //TODO: see if we can do this without dual mutex
  107.   pthread_mutex_unlock(&mi->rli.run_lock);
  108.   pthread_mutex_unlock(&mi->run_lock);
  109. }
  110. /* Initialize slave structures */
  111. int init_slave()
  112. {
  113.   DBUG_ENTER("init_slave");
  114.   /*
  115.     This is called when mysqld starts. Before client connections are
  116.     accepted. However bootstrap may conflict with us if it does START SLAVE.
  117.     So it's safer to take the lock.
  118.   */
  119.   pthread_mutex_lock(&LOCK_active_mi);
  120.   /*
  121.     TODO: re-write this to interate through the list of files
  122.     for multi-master
  123.   */
  124.   active_mi= new MASTER_INFO;
  125.   /*
  126.     If master_host is not specified, try to read it from the master_info file.
  127.     If master_host is specified, create the master_info file if it doesn't
  128.     exists.
  129.   */
  130.   if (!active_mi)
  131.   {
  132.     sql_print_error("Failed to allocate memory for the master info structure");
  133.     goto err;
  134.   }
  135.     
  136.   if (init_master_info(active_mi,master_info_file,relay_log_info_file,
  137.        !master_host, (SLAVE_IO | SLAVE_SQL)))
  138.   {
  139.     sql_print_error("Failed to initialize the master info structure");
  140.     goto err;
  141.   }
  142.   if (server_id && !master_host && active_mi->host[0])
  143.     master_host= active_mi->host;
  144.   /* If server id is not set, start_slave_thread() will say it */
  145.   if (master_host && !opt_skip_slave_start)
  146.   {
  147.     if (start_slave_threads(1 /* need mutex */,
  148.     0 /* no wait for start*/,
  149.     active_mi,
  150.     master_info_file,
  151.     relay_log_info_file,
  152.     SLAVE_IO | SLAVE_SQL))
  153.     {
  154.       sql_print_error("Failed to create slave threads");
  155.       goto err;
  156.     }
  157.   }
  158.   pthread_mutex_unlock(&LOCK_active_mi);
  159.   DBUG_RETURN(0);
  160. err:
  161.   pthread_mutex_unlock(&LOCK_active_mi);
  162.   DBUG_RETURN(1);
  163. }
  164. static void free_table_ent(TABLE_RULE_ENT* e)
  165. {
  166.   my_free((gptr) e, MYF(0));
  167. }
  168. static byte* get_table_key(TABLE_RULE_ENT* e, uint* len,
  169.    my_bool not_used __attribute__((unused)))
  170. {
  171.   *len = e->key_len;
  172.   return (byte*)e->db;
  173. }
  174. /*
  175.   Open the given relay log
  176.   SYNOPSIS
  177.     init_relay_log_pos()
  178.     rli Relay information (will be initialized)
  179.     log Name of relay log file to read from. NULL = First log
  180.     pos Position in relay log file 
  181.     need_data_lock Set to 1 if this functions should do mutex locks
  182.     errmsg Store pointer to error message here
  183.   DESCRIPTION
  184.   - Close old open relay log files.
  185.   - If we are using the same relay log as the running IO-thread, then set
  186.     rli->cur_log to point to the same IO_CACHE entry.
  187.   - If not, open the 'log' binary file.
  188.   TODO
  189.     - check proper initialization of group_master_log_name/group_master_log_pos
  190.   RETURN VALUES
  191.     0 ok
  192.     1 error.  errmsg is set to point to the error message
  193. */
  194. int init_relay_log_pos(RELAY_LOG_INFO* rli,const char* log,
  195.        ulonglong pos, bool need_data_lock,
  196.        const char** errmsg)
  197. {
  198.   DBUG_ENTER("init_relay_log_pos");
  199.   *errmsg=0;
  200.   pthread_mutex_t *log_lock=rli->relay_log.get_log_lock();
  201.   
  202.   if (need_data_lock)
  203.     pthread_mutex_lock(&rli->data_lock);
  204.   
  205.   pthread_mutex_lock(log_lock);
  206.   
  207.   /* Close log file and free buffers if it's already open */
  208.   if (rli->cur_log_fd >= 0)
  209.   {
  210.     end_io_cache(&rli->cache_buf);
  211.     my_close(rli->cur_log_fd, MYF(MY_WME));
  212.     rli->cur_log_fd = -1;
  213.   }
  214.   
  215.   rli->group_relay_log_pos = rli->event_relay_log_pos = pos;
  216.   /*
  217.     Test to see if the previous run was with the skip of purging
  218.     If yes, we do not purge when we restart
  219.   */
  220.   if (rli->relay_log.find_log_pos(&rli->linfo, NullS, 1))
  221.   {
  222.     *errmsg="Could not find first log during relay log initialization";
  223.     goto err;
  224.   }
  225.   if (log && rli->relay_log.find_log_pos(&rli->linfo, log, 1))
  226.   {
  227.     *errmsg="Could not find target log during relay log initialization";
  228.     goto err;
  229.   }
  230.   strmake(rli->group_relay_log_name,rli->linfo.log_file_name,
  231.   sizeof(rli->group_relay_log_name)-1);
  232.   strmake(rli->event_relay_log_name,rli->linfo.log_file_name,
  233.   sizeof(rli->event_relay_log_name)-1);
  234.   if (rli->relay_log.is_active(rli->linfo.log_file_name))
  235.   {
  236.     /*
  237.       The IO thread is using this log file.
  238.       In this case, we will use the same IO_CACHE pointer to
  239.       read data as the IO thread is using to write data.
  240.     */
  241.     rli->cur_log= rli->relay_log.get_log_file();
  242.     if (my_b_tell(rli->cur_log) == 0 &&
  243. check_binlog_magic(rli->cur_log, errmsg))
  244.       goto err;
  245.     rli->cur_log_old_open_count=rli->relay_log.get_open_count();
  246.   }
  247.   else
  248.   {
  249.     /*
  250.       Open the relay log and set rli->cur_log to point at this one
  251.     */
  252.     if ((rli->cur_log_fd=open_binlog(&rli->cache_buf,
  253.      rli->linfo.log_file_name,errmsg)) < 0)
  254.       goto err;
  255.     rli->cur_log = &rli->cache_buf;
  256.   }
  257.   if (pos >= BIN_LOG_HEADER_SIZE)
  258.     my_b_seek(rli->cur_log,(off_t)pos);
  259. err:
  260.   /*
  261.     If we don't purge, we can't honour relay_log_space_limit ;
  262.     silently discard it
  263.   */
  264.   if (!relay_log_purge)
  265.     rli->log_space_limit= 0;
  266.   pthread_cond_broadcast(&rli->data_cond);
  267.   
  268.   pthread_mutex_unlock(log_lock);
  269.   if (need_data_lock)
  270.     pthread_mutex_unlock(&rli->data_lock);
  271.   DBUG_RETURN ((*errmsg) ? 1 : 0);
  272. }
  273. /*
  274.   Init functio to set up array for errors that should be skipped for slave
  275.   SYNOPSIS
  276.     init_slave_skip_errors()
  277.     arg List of errors numbers to skip, separated with ','
  278.   NOTES
  279.     Called from get_options() in mysqld.cc on start-up
  280. */
  281. void init_slave_skip_errors(const char* arg)
  282. {
  283.   const char *p;
  284.   if (bitmap_init(&slave_error_mask,0,MAX_SLAVE_ERROR,0))
  285.   {
  286.     fprintf(stderr, "Badly out of memory, please check your system statusn");
  287.     exit(1);
  288.   }
  289.   use_slave_mask = 1;
  290.   for (;my_isspace(system_charset_info,*arg);++arg)
  291.     /* empty */;
  292.   if (!my_strnncoll(system_charset_info,(uchar*)arg,4,(const uchar*)"all",4))
  293.   {
  294.     bitmap_set_all(&slave_error_mask);
  295.     return;
  296.   }
  297.   for (p= arg ; *p; )
  298.   {
  299.     long err_code;
  300.     if (!(p= str2int(p, 10, 0, LONG_MAX, &err_code)))
  301.       break;
  302.     if (err_code < MAX_SLAVE_ERROR)
  303.        bitmap_set_bit(&slave_error_mask,(uint)err_code);
  304.     while (!my_isdigit(system_charset_info,*p) && *p)
  305.       p++;
  306.   }
  307. }
  308. void st_relay_log_info::inc_group_relay_log_pos(ulonglong val,
  309.                                                 ulonglong log_pos,
  310.                                                 bool skip_lock)
  311. {
  312.   if (!skip_lock)
  313.     pthread_mutex_lock(&data_lock);
  314.   inc_event_relay_log_pos(val);
  315.   group_relay_log_pos= event_relay_log_pos;
  316.   strmake(group_relay_log_name,event_relay_log_name,
  317.           sizeof(group_relay_log_name)-1);
  318.   notify_group_relay_log_name_update();
  319.         
  320.   /*
  321.     If the slave does not support transactions and replicates a transaction,
  322.     users should not trust group_master_log_pos (which they can display with
  323.     SHOW SLAVE STATUS or read from relay-log.info), because to compute
  324.     group_master_log_pos the slave relies on log_pos stored in the master's
  325.     binlog, but if we are in a master's transaction these positions are always
  326.     the BEGIN's one (excepted for the COMMIT), so group_master_log_pos does
  327.     not advance as it should on the non-transactional slave (it advances by
  328.     big leaps, whereas it should advance by small leaps).
  329.   */
  330.   if (log_pos) // 3.23 binlogs don't have log_posx
  331.   {
  332. #if MYSQL_VERSION_ID < 50000
  333.     /*
  334.       If the event was converted from a 3.23 format, get_event_len() has
  335.       grown by 6 bytes (at least for most events, except LOAD DATA INFILE
  336.       which is already a big problem for 3.23->4.0 replication); 6 bytes is
  337.       the difference between the header's size in 4.0 (LOG_EVENT_HEADER_LEN)
  338.       and the header's size in 3.23 (OLD_HEADER_LEN). Note that using
  339.       mi->old_format will not help if the I/O thread has not started yet.
  340.       Yes this is a hack but it's just to make 3.23->4.x replication work;
  341.       3.23->5.0 replication is working much better.
  342.     */
  343.     group_master_log_pos= log_pos + val -
  344.       (mi->old_format ? (LOG_EVENT_HEADER_LEN - OLD_HEADER_LEN) : 0);
  345. #else
  346.     group_master_log_pos= log_pos+ val;
  347. #endif /* MYSQL_VERSION_ID < 5000 */
  348.   }
  349.   pthread_cond_broadcast(&data_cond);
  350.   if (!skip_lock)
  351.     pthread_mutex_unlock(&data_lock);
  352. }
  353. void st_relay_log_info::close_temporary_tables()
  354. {
  355.   TABLE *table,*next;
  356.   for (table=save_temporary_tables ; table ; table=next)
  357.   {
  358.     next=table->next;
  359.     /*
  360.       Don't ask for disk deletion. For now, anyway they will be deleted when
  361.       slave restarts, but it is a better intention to not delete them.
  362.     */
  363.     close_temporary(table, 0);
  364.   }
  365.   save_temporary_tables= 0;
  366.   slave_open_temp_tables= 0;
  367. }
  368. /*
  369.   purge_relay_logs()
  370.   NOTES
  371.     Assumes to have a run lock on rli and that no slave thread are running.
  372. */
  373. int purge_relay_logs(RELAY_LOG_INFO* rli, THD *thd, bool just_reset,
  374.      const char** errmsg)
  375. {
  376.   int error=0;
  377.   DBUG_ENTER("purge_relay_logs");
  378.   /*
  379.     Even if rli->inited==0, we still try to empty rli->master_log_* variables.
  380.     Indeed, rli->inited==0 does not imply that they already are empty.
  381.     It could be that slave's info initialization partly succeeded : 
  382.     for example if relay-log.info existed but *relay-bin*.*
  383.     have been manually removed, init_relay_log_info reads the old 
  384.     relay-log.info and fills rli->master_log_*, then init_relay_log_info
  385.     checks for the existence of the relay log, this fails and
  386.     init_relay_log_info leaves rli->inited to 0.
  387.     In that pathological case, rli->master_log_pos* will be properly reinited
  388.     at the next START SLAVE (as RESET SLAVE or CHANGE
  389.     MASTER, the callers of purge_relay_logs, will delete bogus *.info files
  390.     or replace them with correct files), however if the user does SHOW SLAVE
  391.     STATUS before START SLAVE, he will see old, confusing rli->master_log_*.
  392.     In other words, we reinit rli->master_log_* for SHOW SLAVE STATUS 
  393.     to display fine in any case.
  394.   */
  395.   rli->group_master_log_name[0]= 0;
  396.   rli->group_master_log_pos= 0;
  397.   if (!rli->inited)
  398.   {
  399.     DBUG_PRINT("info", ("rli->inited == 0"));
  400.     DBUG_RETURN(0);
  401.   }
  402.   DBUG_ASSERT(rli->slave_running == 0);
  403.   DBUG_ASSERT(rli->mi->slave_running == 0);
  404.   rli->slave_skip_counter=0;
  405.   pthread_mutex_lock(&rli->data_lock);
  406.   if (rli->relay_log.reset_logs(thd))
  407.   {
  408.     *errmsg = "Failed during log reset";
  409.     error=1;
  410.     goto err;
  411.   }
  412.   /* Save name of used relay log file */
  413.   strmake(rli->group_relay_log_name, rli->relay_log.get_log_fname(),
  414.   sizeof(rli->group_relay_log_name)-1);
  415.   strmake(rli->event_relay_log_name, rli->relay_log.get_log_fname(),
  416.     sizeof(rli->event_relay_log_name)-1);
  417.   // Just first log with magic number and nothing else
  418.   rli->log_space_total= BIN_LOG_HEADER_SIZE;
  419.   rli->group_relay_log_pos= rli->event_relay_log_pos= BIN_LOG_HEADER_SIZE;
  420.   rli->relay_log.reset_bytes_written();
  421.   if (!just_reset)
  422.     error= init_relay_log_pos(rli, rli->group_relay_log_name, rli->group_relay_log_pos,
  423.          0 /* do not need data lock */, errmsg);
  424.   
  425. err:
  426. #ifndef DBUG_OFF
  427.   char buf[22];
  428. #endif  
  429.   DBUG_PRINT("info",("log_space_total: %s",llstr(rli->log_space_total,buf)));
  430.   pthread_mutex_unlock(&rli->data_lock);
  431.   DBUG_RETURN(error);
  432. }
  433. int terminate_slave_threads(MASTER_INFO* mi,int thread_mask,bool skip_lock)
  434. {
  435.   if (!mi->inited)
  436.     return 0; /* successfully do nothing */
  437.   int error,force_all = (thread_mask & SLAVE_FORCE_ALL);
  438.   pthread_mutex_t *sql_lock = &mi->rli.run_lock, *io_lock = &mi->run_lock;
  439.   pthread_mutex_t *sql_cond_lock,*io_cond_lock;
  440.   DBUG_ENTER("terminate_slave_threads");
  441.   sql_cond_lock=sql_lock;
  442.   io_cond_lock=io_lock;
  443.   
  444.   if (skip_lock)
  445.   {
  446.     sql_lock = io_lock = 0;
  447.   }
  448.   if ((thread_mask & (SLAVE_IO|SLAVE_FORCE_ALL)) && mi->slave_running)
  449.   {
  450.     DBUG_PRINT("info",("Terminating IO thread"));
  451.     mi->abort_slave=1;
  452.     if ((error=terminate_slave_thread(mi->io_thd,io_lock,
  453.       io_cond_lock,
  454.       &mi->stop_cond,
  455.       &mi->slave_running)) &&
  456. !force_all)
  457.       DBUG_RETURN(error);
  458.   }
  459.   if ((thread_mask & (SLAVE_SQL|SLAVE_FORCE_ALL)) && mi->rli.slave_running)
  460.   {
  461.     DBUG_PRINT("info",("Terminating SQL thread"));
  462.     DBUG_ASSERT(mi->rli.sql_thd != 0) ;
  463.     mi->rli.abort_slave=1;
  464.     if ((error=terminate_slave_thread(mi->rli.sql_thd,sql_lock,
  465.       sql_cond_lock,
  466.       &mi->rli.stop_cond,
  467.       &mi->rli.slave_running)) &&
  468. !force_all)
  469.       DBUG_RETURN(error);
  470.   }
  471.   DBUG_RETURN(0);
  472. }
  473. int terminate_slave_thread(THD* thd, pthread_mutex_t* term_lock,
  474.    pthread_mutex_t *cond_lock,
  475.    pthread_cond_t* term_cond,
  476.    volatile uint *slave_running)
  477. {
  478.   if (term_lock)
  479.   {
  480.     pthread_mutex_lock(term_lock);
  481.     if (!*slave_running)
  482.     {
  483.       pthread_mutex_unlock(term_lock);
  484.       return ER_SLAVE_NOT_RUNNING;
  485.     }
  486.   }
  487.   DBUG_ASSERT(thd != 0);
  488.   /*
  489.     Is is criticate to test if the slave is running. Otherwise, we might
  490.     be referening freed memory trying to kick it
  491.   */
  492.   THD_CHECK_SENTRY(thd);
  493.   while (*slave_running) // Should always be true
  494.   {
  495.     KICK_SLAVE(thd);
  496.     /*
  497.       There is a small chance that slave thread might miss the first
  498.       alarm. To protect againts it, resend the signal until it reacts
  499.     */
  500.     struct timespec abstime;
  501.     set_timespec(abstime,2);
  502.     pthread_cond_timedwait(term_cond, cond_lock, &abstime);
  503.   }
  504.   if (term_lock)
  505.     pthread_mutex_unlock(term_lock);
  506.   return 0;
  507. }
  508. int start_slave_thread(pthread_handler h_func, pthread_mutex_t *start_lock,
  509.        pthread_mutex_t *cond_lock,
  510.        pthread_cond_t *start_cond,
  511.        volatile uint *slave_running,
  512.        volatile ulong *slave_run_id,
  513.        MASTER_INFO* mi,
  514.                        bool high_priority)
  515. {
  516.   pthread_t th;
  517.   ulong start_id;
  518.   DBUG_ASSERT(mi->inited);
  519.   DBUG_ENTER("start_slave_thread");
  520.   if (start_lock)
  521.     pthread_mutex_lock(start_lock);
  522.   if (!server_id)
  523.   {
  524.     if (start_cond)
  525.       pthread_cond_broadcast(start_cond);
  526.     if (start_lock)
  527.       pthread_mutex_unlock(start_lock);
  528.     sql_print_error("Server id not set, will not start slave");
  529.     DBUG_RETURN(ER_BAD_SLAVE);
  530.   }
  531.   
  532.   if (*slave_running)
  533.   {
  534.     if (start_cond)
  535.       pthread_cond_broadcast(start_cond);
  536.     if (start_lock)
  537.       pthread_mutex_unlock(start_lock);
  538.     DBUG_RETURN(ER_SLAVE_MUST_STOP);
  539.   }
  540.   start_id= *slave_run_id;
  541.   DBUG_PRINT("info",("Creating new slave thread"));
  542.   if (high_priority)
  543.     my_pthread_attr_setprio(&connection_attrib,CONNECT_PRIOR);
  544.   if (pthread_create(&th, &connection_attrib, h_func, (void*)mi))
  545.   {
  546.     if (start_lock)
  547.       pthread_mutex_unlock(start_lock);
  548.     DBUG_RETURN(ER_SLAVE_THREAD);
  549.   }
  550.   if (start_cond && cond_lock) // caller has cond_lock
  551.   {
  552.     THD* thd = current_thd;
  553.     while (start_id == *slave_run_id)
  554.     {
  555.       DBUG_PRINT("sleep",("Waiting for slave thread to start"));
  556.       const char* old_msg = thd->enter_cond(start_cond,cond_lock,
  557.     "Waiting for slave thread to start");
  558.       pthread_cond_wait(start_cond,cond_lock);
  559.       thd->exit_cond(old_msg);
  560.       pthread_mutex_lock(cond_lock); // re-acquire it as exit_cond() released
  561.       if (thd->killed)
  562. DBUG_RETURN(ER_SERVER_SHUTDOWN);
  563.     }
  564.   }
  565.   if (start_lock)
  566.     pthread_mutex_unlock(start_lock);
  567.   DBUG_RETURN(0);
  568. }
  569. /*
  570.   start_slave_threads()
  571.   NOTES
  572.     SLAVE_FORCE_ALL is not implemented here on purpose since it does not make
  573.     sense to do that for starting a slave--we always care if it actually
  574.     started the threads that were not previously running
  575. */
  576. int start_slave_threads(bool need_slave_mutex, bool wait_for_start,
  577. MASTER_INFO* mi, const char* master_info_fname,
  578. const char* slave_info_fname, int thread_mask)
  579. {
  580.   pthread_mutex_t *lock_io=0,*lock_sql=0,*lock_cond_io=0,*lock_cond_sql=0;
  581.   pthread_cond_t* cond_io=0,*cond_sql=0;
  582.   int error=0;
  583.   DBUG_ENTER("start_slave_threads");
  584.   
  585.   if (need_slave_mutex)
  586.   {
  587.     lock_io = &mi->run_lock;
  588.     lock_sql = &mi->rli.run_lock;
  589.   }
  590.   if (wait_for_start)
  591.   {
  592.     cond_io = &mi->start_cond;
  593.     cond_sql = &mi->rli.start_cond;
  594.     lock_cond_io = &mi->run_lock;
  595.     lock_cond_sql = &mi->rli.run_lock;
  596.   }
  597.   if (thread_mask & SLAVE_IO)
  598.     error=start_slave_thread(handle_slave_io,lock_io,lock_cond_io,
  599.      cond_io,
  600.      &mi->slave_running, &mi->slave_run_id,
  601.      mi, 1); //high priority, to read the most possible
  602.   if (!error && (thread_mask & SLAVE_SQL))
  603.   {
  604.     error=start_slave_thread(handle_slave_sql,lock_sql,lock_cond_sql,
  605.      cond_sql,
  606.      &mi->rli.slave_running, &mi->rli.slave_run_id,
  607.      mi, 0);
  608.     if (error)
  609.       terminate_slave_threads(mi, thread_mask & SLAVE_IO, 0);
  610.   }
  611.   DBUG_RETURN(error);
  612. }
  613. void init_table_rule_hash(HASH* h, bool* h_inited)
  614. {
  615.   hash_init(h, system_charset_info,TABLE_RULE_HASH_SIZE,0,0,
  616.     (hash_get_key) get_table_key,
  617.     (hash_free_key) free_table_ent, 0);
  618.   *h_inited = 1;
  619. }
  620. void init_table_rule_array(DYNAMIC_ARRAY* a, bool* a_inited)
  621. {
  622.   my_init_dynamic_array(a, sizeof(TABLE_RULE_ENT*), TABLE_RULE_ARR_SIZE,
  623.      TABLE_RULE_ARR_SIZE);
  624.   *a_inited = 1;
  625. }
  626. static TABLE_RULE_ENT* find_wild(DYNAMIC_ARRAY *a, const char* key, int len)
  627. {
  628.   uint i;
  629.   const char* key_end = key + len;
  630.   
  631.   for (i = 0; i < a->elements; i++)
  632.     {
  633.       TABLE_RULE_ENT* e ;
  634.       get_dynamic(a, (gptr)&e, i);
  635.       if (!my_wildcmp(system_charset_info, key, key_end, 
  636.                             (const char*)e->db,
  637.     (const char*)(e->db + e->key_len),
  638.     '\',wild_one,wild_many))
  639. return e;
  640.     }
  641.   
  642.   return 0;
  643. }
  644. /*
  645.   Checks whether tables match some (wild_)do_table and (wild_)ignore_table
  646.   rules (for replication)
  647.   SYNOPSIS
  648.     tables_ok()
  649.     thd             thread (SQL slave thread normally)
  650.     tables          list of tables to check
  651.   NOTES
  652.     Note that changing the order of the tables in the list can lead to
  653.     different results. Note also the order of precedence of the do/ignore 
  654.     rules (see code below). For that reason, users should not set conflicting 
  655.     rules because they may get unpredicted results (precedence order is
  656.     explained in the manual).
  657.     
  658.   RETURN VALUES
  659.     0           should not be logged/replicated
  660.     1           should be logged/replicated                  
  661. */
  662. bool tables_ok(THD* thd, TABLE_LIST* tables)
  663. {
  664.   bool some_tables_updating= 0;
  665.   DBUG_ENTER("tables_ok");
  666.   for (; tables; tables = tables->next)
  667.   {
  668.     char hash_key[2*NAME_LEN+2];
  669.     char *end;
  670.     uint len;
  671.     if (!tables->updating) 
  672.       continue;
  673.     some_tables_updating= 1;
  674.     end= strmov(hash_key, tables->db ? tables->db : thd->db);
  675.     *end++= '.';
  676.     len= (uint) (strmov(end, tables->real_name) - hash_key);
  677.     if (do_table_inited) // if there are any do's
  678.     {
  679.       if (hash_search(&replicate_do_table, (byte*) hash_key, len))
  680. DBUG_RETURN(1);
  681.     }
  682.     if (ignore_table_inited) // if there are any ignores
  683.     {
  684.       if (hash_search(&replicate_ignore_table, (byte*) hash_key, len))
  685. DBUG_RETURN(0); 
  686.     }
  687.     if (wild_do_table_inited && find_wild(&replicate_wild_do_table,
  688.   hash_key, len))
  689.       DBUG_RETURN(1);
  690.     if (wild_ignore_table_inited && find_wild(&replicate_wild_ignore_table,
  691.       hash_key, len))
  692.       DBUG_RETURN(0);
  693.   }
  694.   /*
  695.     If no table was to be updated, ignore statement (no reason we play it on
  696.     slave, slave is supposed to replicate _changes_ only).
  697.     If no explicit rule found and there was a do list, do not replicate.
  698.     If there was no do list, go ahead
  699.   */
  700.   DBUG_RETURN(some_tables_updating &&
  701.               !do_table_inited && !wild_do_table_inited);
  702. }
  703. /*
  704.   Checks whether a db matches wild_do_table and wild_ignore_table
  705.   rules (for replication)
  706.   SYNOPSIS
  707.     db_ok_with_wild_table()
  708.     db name of the db to check.
  709. Is tested with check_db_name() before calling this function.
  710.   NOTES
  711.     Here is the reason for this function.
  712.     We advise users who want to exclude a database 'db1' safely to do it
  713.     with replicate_wild_ignore_table='db1.%' instead of binlog_ignore_db or
  714.     replicate_ignore_db because the two lasts only check for the selected db,
  715.     which won't work in that case:
  716.     USE db2;
  717.     UPDATE db1.t SET ... #this will be replicated and should not
  718.     whereas replicate_wild_ignore_table will work in all cases.
  719.     With replicate_wild_ignore_table, we only check tables. When
  720.     one does 'DROP DATABASE db1', tables are not involved and the
  721.     statement will be replicated, while users could expect it would not (as it
  722.     rougly means 'DROP db1.first_table, DROP db1.second_table...').
  723.     In other words, we want to interpret 'db1.%' as "everything touching db1".
  724.     That is why we want to match 'db1' against 'db1.%' wild table rules.
  725.   RETURN VALUES
  726.     0           should not be logged/replicated
  727.     1           should be logged/replicated
  728.  */
  729. int db_ok_with_wild_table(const char *db)
  730. {
  731.   char hash_key[NAME_LEN+2];
  732.   char *end;
  733.   int len;
  734.   end= strmov(hash_key, db);
  735.   *end++= '.';
  736.   len= end - hash_key ;
  737.   if (wild_do_table_inited && find_wild(&replicate_wild_do_table,
  738.                                         hash_key, len))
  739.     return 1;
  740.   if (wild_ignore_table_inited && find_wild(&replicate_wild_ignore_table,
  741.                                             hash_key, len))
  742.     return 0;
  743.   
  744.   /*
  745.     If no explicit rule found and there was a do list, do not replicate.
  746.     If there was no do list, go ahead
  747.   */
  748.   return !wild_do_table_inited;
  749. }
  750. int add_table_rule(HASH* h, const char* table_spec)
  751. {
  752.   const char* dot = strchr(table_spec, '.');
  753.   if (!dot) return 1;
  754.   // len is always > 0 because we know the there exists a '.'
  755.   uint len = (uint)strlen(table_spec);
  756.   TABLE_RULE_ENT* e = (TABLE_RULE_ENT*)my_malloc(sizeof(TABLE_RULE_ENT)
  757.  + len, MYF(MY_WME));
  758.   if (!e) return 1;
  759.   e->db = (char*)e + sizeof(TABLE_RULE_ENT);
  760.   e->tbl_name = e->db + (dot - table_spec) + 1;
  761.   e->key_len = len;
  762.   memcpy(e->db, table_spec, len);
  763.   (void)my_hash_insert(h, (byte*)e);
  764.   return 0;
  765. }
  766. /*
  767.   Add table expression with wildcards to dynamic array
  768. */
  769. int add_wild_table_rule(DYNAMIC_ARRAY* a, const char* table_spec)
  770. {
  771.   const char* dot = strchr(table_spec, '.');
  772.   if (!dot) return 1;
  773.   uint len = (uint)strlen(table_spec);
  774.   TABLE_RULE_ENT* e = (TABLE_RULE_ENT*)my_malloc(sizeof(TABLE_RULE_ENT)
  775.  + len, MYF(MY_WME));
  776.   if (!e) return 1;
  777.   e->db = (char*)e + sizeof(TABLE_RULE_ENT);
  778.   e->tbl_name = e->db + (dot - table_spec) + 1;
  779.   e->key_len = len;
  780.   memcpy(e->db, table_spec, len);
  781.   insert_dynamic(a, (gptr)&e);
  782.   return 0;
  783. }
  784. static void free_string_array(DYNAMIC_ARRAY *a)
  785. {
  786.   uint i;
  787.   for (i = 0; i < a->elements; i++)
  788.     {
  789.       char* p;
  790.       get_dynamic(a, (gptr) &p, i);
  791.       my_free(p, MYF(MY_WME));
  792.     }
  793.   delete_dynamic(a);
  794. }
  795. #ifdef NOT_USED_YET
  796. static int end_slave_on_walk(MASTER_INFO* mi, gptr /*unused*/)
  797. {
  798.   end_master_info(mi);
  799.   return 0;
  800. }
  801. #endif
  802. /*
  803.   Free all resources used by slave
  804.   SYNOPSIS
  805.     end_slave()
  806. */
  807. void end_slave()
  808. {
  809.   /*
  810.     This is called when the server terminates, in close_connections().
  811.     It terminates slave threads. However, some CHANGE MASTER etc may still be
  812.     running presently. If a START SLAVE was in progress, the mutex lock below
  813.     will make us wait until slave threads have started, and START SLAVE
  814.     returns, then we terminate them here.
  815.   */
  816.   pthread_mutex_lock(&LOCK_active_mi);
  817.   if (active_mi)
  818.   {
  819.     /*
  820.       TODO: replace the line below with
  821.       list_walk(&master_list, (list_walk_action)end_slave_on_walk,0);
  822.       once multi-master code is ready.
  823.     */
  824.     terminate_slave_threads(active_mi,SLAVE_FORCE_ALL);
  825.     end_master_info(active_mi);
  826.     if (do_table_inited)
  827.       hash_free(&replicate_do_table);
  828.     if (ignore_table_inited)
  829.       hash_free(&replicate_ignore_table);
  830.     if (wild_do_table_inited)
  831.       free_string_array(&replicate_wild_do_table);
  832.     if (wild_ignore_table_inited)
  833.       free_string_array(&replicate_wild_ignore_table);
  834.     delete active_mi;
  835.     active_mi= 0;
  836.   }
  837.   pthread_mutex_unlock(&LOCK_active_mi);
  838. }
  839. static bool io_slave_killed(THD* thd, MASTER_INFO* mi)
  840. {
  841.   DBUG_ASSERT(mi->io_thd == thd);
  842.   DBUG_ASSERT(mi->slave_running); // tracking buffer overrun
  843.   return mi->abort_slave || abort_loop || thd->killed;
  844. }
  845. static bool sql_slave_killed(THD* thd, RELAY_LOG_INFO* rli)
  846. {
  847.   DBUG_ASSERT(rli->sql_thd == thd);
  848.   DBUG_ASSERT(rli->slave_running == 1);// tracking buffer overrun
  849.   return rli->abort_slave || abort_loop || thd->killed;
  850. }
  851. /*
  852.   Writes an error message to rli->last_slave_error and rli->last_slave_errno
  853.   (which will be displayed by SHOW SLAVE STATUS), and prints it to stderr.
  854.   SYNOPSIS
  855.     slave_print_error()
  856.     rli
  857.     err_code    The error code
  858.     msg         The error message (usually related to the error code, but can
  859.                 contain more information).
  860.     ...         (this is printf-like format, with % symbols in msg)
  861.   RETURN VALUES
  862.     void
  863. */
  864. void slave_print_error(RELAY_LOG_INFO* rli, int err_code, const char* msg, ...)
  865. {
  866.   va_list args;
  867.   va_start(args,msg);
  868.   my_vsnprintf(rli->last_slave_error,
  869.        sizeof(rli->last_slave_error), msg, args);
  870.   rli->last_slave_errno = err_code;
  871.   /* If the error string ends with '.', do not add a ',' it would be ugly */
  872.   if (rli->last_slave_error[0] && 
  873.       (*(strend(rli->last_slave_error)-1) == '.'))
  874.     sql_print_error("Slave: %s Error_code: %d", rli->last_slave_error,
  875.                     err_code);
  876.   else
  877.     sql_print_error("Slave: %s, Error_code: %d", rli->last_slave_error,
  878.                     err_code);
  879. }
  880. /*
  881.   skip_load_data_infile()
  882.   NOTES
  883.     This is used to tell a 3.23 master to break send_file()
  884. */
  885. void skip_load_data_infile(NET *net)
  886. {
  887.   (void)net_request_file(net, "/dev/null");
  888.   (void)my_net_read(net); // discard response
  889.   (void)net_write_command(net, 0, "", 0, "", 0); // Send ok
  890. }
  891. bool net_request_file(NET* net, const char* fname)
  892. {
  893.   DBUG_ENTER("net_request_file");
  894.   DBUG_RETURN(net_write_command(net, 251, fname, strlen(fname), "", 0));
  895. }
  896. const char *rewrite_db(const char* db, uint32 *new_len)
  897. {
  898.   if (replicate_rewrite_db.is_empty() || !db)
  899.     return db;
  900.   I_List_iterator<i_string_pair> it(replicate_rewrite_db);
  901.   i_string_pair* tmp;
  902.   while ((tmp=it++))
  903.   {
  904.     if (!strcmp(tmp->key, db))
  905.     {
  906.       *new_len= (uint32)strlen(tmp->val);
  907.       return tmp->val;
  908.     }
  909.   }
  910.   return db;
  911. }
  912. /*
  913.   From other comments and tests in code, it looks like
  914.   sometimes Query_log_event and Load_log_event can have db == 0
  915.   (see rewrite_db() above for example)
  916.   (cases where this happens are unclear; it may be when the master is 3.23).
  917. */
  918. const char *print_slave_db_safe(const char* db)
  919. {
  920.   return (db ? db : "");
  921. }
  922. /*
  923.   Checks whether a db matches some do_db and ignore_db rules
  924.   (for logging or replication)
  925.   SYNOPSIS
  926.     db_ok()
  927.     db              name of the db to check
  928.     do_list         either binlog_do_db or replicate_do_db
  929.     ignore_list     either binlog_ignore_db or replicate_ignore_db
  930.   RETURN VALUES
  931.     0           should not be logged/replicated
  932.     1           should be logged/replicated                  
  933. */
  934. int db_ok(const char* db, I_List<i_string> &do_list,
  935.   I_List<i_string> &ignore_list )
  936. {
  937.   if (do_list.is_empty() && ignore_list.is_empty())
  938.     return 1; // ok to replicate if the user puts no constraints
  939.   /*
  940.     If the user has specified restrictions on which databases to replicate
  941.     and db was not selected, do not replicate.
  942.   */
  943.   if (!db)
  944.     return 0;
  945.   if (!do_list.is_empty()) // if the do's are not empty
  946.   {
  947.     I_List_iterator<i_string> it(do_list);
  948.     i_string* tmp;
  949.     while ((tmp=it++))
  950.     {
  951.       if (!strcmp(tmp->ptr, db))
  952. return 1; // match
  953.     }
  954.     return 0;
  955.   }
  956.   else // there are some elements in the don't, otherwise we cannot get here
  957.   {
  958.     I_List_iterator<i_string> it(ignore_list);
  959.     i_string* tmp;
  960.     while ((tmp=it++))
  961.     {
  962.       if (!strcmp(tmp->ptr, db))
  963. return 0; // match
  964.     }
  965.     return 1;
  966.   }
  967. }
  968. static int init_strvar_from_file(char *var, int max_size, IO_CACHE *f,
  969.  const char *default_val)
  970. {
  971.   uint length;
  972.   if ((length=my_b_gets(f,var, max_size)))
  973.   {
  974.     char* last_p = var + length -1;
  975.     if (*last_p == 'n')
  976.       *last_p = 0; // if we stopped on newline, kill it
  977.     else
  978.     {
  979.       /*
  980. If we truncated a line or stopped on last char, remove all chars
  981. up to and including newline.
  982.       */
  983.       int c;
  984.       while (((c=my_b_get(f)) != 'n' && c != my_b_EOF));
  985.     }
  986.     return 0;
  987.   }
  988.   else if (default_val)
  989.   {
  990.     strmake(var,  default_val, max_size-1);
  991.     return 0;
  992.   }
  993.   return 1;
  994. }
  995. static int init_intvar_from_file(int* var, IO_CACHE* f, int default_val)
  996. {
  997.   char buf[32];
  998.   
  999.   if (my_b_gets(f, buf, sizeof(buf))) 
  1000.   {
  1001.     *var = atoi(buf);
  1002.     return 0;
  1003.   }
  1004.   else if (default_val)
  1005.   {
  1006.     *var = default_val;
  1007.     return 0;
  1008.   }
  1009.   return 1;
  1010. }
  1011. static int get_master_version_and_clock(MYSQL* mysql, MASTER_INFO* mi)
  1012. {
  1013.   const char* errmsg= 0;
  1014.   
  1015.   /*
  1016.     Note the following switch will bug when we have MySQL branch 30 ;)
  1017.   */
  1018.   switch (*mysql->server_version) {
  1019.   case '3':
  1020.     mi->old_format = 
  1021.       (strncmp(mysql->server_version, "3.23.57", 7) < 0) /* < .57 */ ?
  1022.       BINLOG_FORMAT_323_LESS_57 : 
  1023.       BINLOG_FORMAT_323_GEQ_57 ;
  1024.     break;
  1025.   case '4':
  1026.     mi->old_format = BINLOG_FORMAT_CURRENT;
  1027.     break;
  1028.   default:
  1029.     /* 5.0 is not supported */
  1030.     errmsg = "Master reported an unrecognized MySQL version. Note that 4.1 
  1031. slaves can't replicate a 5.0 or newer master.";
  1032.     break;
  1033.   }
  1034.   /*
  1035.     Compare the master and slave's clock. Do not die if master's clock is
  1036.     unavailable (very old master not supporting UNIX_TIMESTAMP()?).
  1037.   */
  1038.   MYSQL_RES *master_res= 0;
  1039.   MYSQL_ROW master_row;
  1040.   
  1041.   if (!mysql_real_query(mysql, "SELECT UNIX_TIMESTAMP()", 23) &&
  1042.       (master_res= mysql_store_result(mysql)) &&
  1043.       (master_row= mysql_fetch_row(master_res)))
  1044.   {
  1045.     mi->clock_diff_with_master= 
  1046.       (long) (time((time_t*) 0) - strtoul(master_row[0], 0, 10));
  1047.   }
  1048.   else
  1049.   {
  1050.     mi->clock_diff_with_master= 0; /* The "most sensible" value */
  1051.     sql_print_warning(""SELECT UNIX_TIMESTAMP()" failed on master, 
  1052. do not trust column Seconds_Behind_Master of SHOW SLAVE STATUS");
  1053.   }
  1054.   if (master_res)
  1055.     mysql_free_result(master_res);      
  1056.  
  1057.   /*
  1058.     Check that the master's server id and ours are different. Because if they
  1059.     are equal (which can result from a simple copy of master's datadir to slave,
  1060.     thus copying some my.cnf), replication will work but all events will be
  1061.     skipped.
  1062.     Do not die if SHOW VARIABLES LIKE 'SERVER_ID' fails on master (very old
  1063.     master?).
  1064.     Note: we could have put a @@SERVER_ID in the previous SELECT
  1065.     UNIX_TIMESTAMP() instead, but this would not have worked on 3.23 masters.
  1066.   */
  1067.   if (!mysql_real_query(mysql, "SHOW VARIABLES LIKE 'SERVER_ID'", 31) &&
  1068.       (master_res= mysql_store_result(mysql)))
  1069.   {
  1070.     if ((master_row= mysql_fetch_row(master_res)) &&
  1071.         (::server_id == strtoul(master_row[1], 0, 10)) &&
  1072.         !replicate_same_server_id)
  1073.       errmsg= "The slave I/O thread stops because master and slave have equal 
  1074. MySQL server ids; these ids must be different for replication to work (or 
  1075. the --replicate-same-server-id option must be used on slave but this does 
  1076. not always make sense; please check the manual before using it).";
  1077.     mysql_free_result(master_res);
  1078.   }
  1079.   /*
  1080.     Check that the master's global character_set_server and ours are the same.
  1081.     Not fatal if query fails (old master?).
  1082.     Note that we don't check for equality of global character_set_client and
  1083.     collation_connection (neither do we prevent their setting in
  1084.     set_var.cc). That's because from what I (Guilhem) have tested, the global
  1085.     values of these 2 are never used (new connections don't use them).
  1086.     We don't test equality of global collation_database either as it's is
  1087.     going to be deprecated (made read-only) in 4.1 very soon.
  1088.     We don't do it for <3.23.57 because masters <3.23.50 hang on
  1089.     SELECT @@unknown_var (BUG#7965 - see changelog of 3.23.50).
  1090.   */
  1091.   if (mi->old_format == BINLOG_FORMAT_323_LESS_57)
  1092.     goto err;
  1093.   if (!mysql_real_query(mysql, "SELECT @@GLOBAL.COLLATION_SERVER", 32) &&
  1094.       (master_res= mysql_store_result(mysql)))
  1095.   {
  1096.     if ((master_row= mysql_fetch_row(master_res)) &&
  1097.         strcmp(master_row[0], global_system_variables.collation_server->name))
  1098.       errmsg= "The slave I/O thread stops because master and slave have 
  1099. different values for the COLLATION_SERVER global variable. The values must 
  1100. be equal for replication to work";
  1101.     mysql_free_result(master_res);
  1102.   }
  1103.   /*
  1104.     Perform analogous check for time zone. Theoretically we also should
  1105.     perform check here to verify that SYSTEM time zones are the same on
  1106.     slave and master, but we can't rely on value of @@system_time_zone
  1107.     variable (it is time zone abbreviation) since it determined at start
  1108.     time and so could differ for slave and master even if they are really
  1109.     in the same system time zone. So we are omiting this check and just
  1110.     relying on documentation. Also according to Monty there are many users
  1111.     who are using replication between servers in various time zones. Hence 
  1112.     such check will broke everything for them. (And now everything will 
  1113.     work for them because by default both their master and slave will have 
  1114.     'SYSTEM' time zone).
  1115.   */
  1116.   if (!mysql_real_query(mysql, "SELECT @@GLOBAL.TIME_ZONE", 25) &&
  1117.       (master_res= mysql_store_result(mysql)))
  1118.   {
  1119.     if ((master_row= mysql_fetch_row(master_res)) &&
  1120.         strcmp(master_row[0], 
  1121.                global_system_variables.time_zone->get_name()->ptr()))
  1122.       errmsg= "The slave I/O thread stops because master and slave have 
  1123. different values for the TIME_ZONE global variable. The values must 
  1124. be equal for replication to work";
  1125.     mysql_free_result(master_res);
  1126.   }
  1127. err:
  1128.   if (errmsg)
  1129.   {
  1130.     sql_print_error(errmsg);
  1131.     return 1;
  1132.   }
  1133.   return 0;
  1134. }
  1135. /*
  1136.   Used by fetch_master_table (used by LOAD TABLE tblname FROM MASTER and LOAD
  1137.   DATA FROM MASTER). Drops the table (if 'overwrite' is true) and recreates it
  1138.   from the dump. Honours replication inclusion/exclusion rules.
  1139.   db must be non-zero (guarded by assertion).
  1140.   RETURN VALUES
  1141.     0           success
  1142.     1           error
  1143. */
  1144. static int create_table_from_dump(THD* thd, MYSQL *mysql, const char* db,
  1145.   const char* table_name, bool overwrite)
  1146. {
  1147.   ulong packet_len;
  1148.   char *query, *save_db;
  1149.   uint32 save_db_length;
  1150.   Vio* save_vio;
  1151.   HA_CHECK_OPT check_opt;
  1152.   TABLE_LIST tables;
  1153.   int error= 1;
  1154.   handler *file;
  1155.   ulong save_options;
  1156.   NET *net= &mysql->net;
  1157.   DBUG_ENTER("create_table_from_dump");  
  1158.   packet_len= my_net_read(net); // read create table statement
  1159.   if (packet_len == packet_error)
  1160.   {
  1161.     send_error(thd, ER_MASTER_NET_READ);
  1162.     DBUG_RETURN(1);
  1163.   }
  1164.   if (net->read_pos[0] == 255) // error from master
  1165.   {
  1166.     char *err_msg; 
  1167.     err_msg= (char*) net->read_pos + ((mysql->server_capabilities &
  1168.        CLIENT_PROTOCOL_41) ?
  1169.       3+SQLSTATE_LENGTH+1 : 3);
  1170.     net_printf(thd, ER_MASTER, err_msg);
  1171.     DBUG_RETURN(1);
  1172.   }
  1173.   thd->command = COM_TABLE_DUMP;
  1174.   thd->query_length= packet_len;
  1175.   /* Note that we should not set thd->query until the area is initalized */
  1176.   if (!(query = thd->strmake((char*) net->read_pos, packet_len)))
  1177.   {
  1178.     sql_print_error("create_table_from_dump: out of memory");
  1179.     net_printf(thd, ER_GET_ERRNO, "Out of memory");
  1180.     DBUG_RETURN(1);
  1181.   }
  1182.   thd->query= query;
  1183.   thd->query_error = 0;
  1184.   thd->net.no_send_ok = 1;
  1185.   bzero((char*) &tables,sizeof(tables));
  1186.   tables.db = (char*)db;
  1187.   tables.alias= tables.real_name= (char*)table_name;
  1188.   /* Drop the table if 'overwrite' is true */
  1189.   if (overwrite && mysql_rm_table(thd,&tables,1,0)) /* drop if exists */
  1190.   {
  1191.     send_error(thd);
  1192.     sql_print_error("create_table_from_dump: failed to drop the table");
  1193.     goto err;
  1194.   }
  1195.   /* Create the table. We do not want to log the "create table" statement */
  1196.   save_options = thd->options;
  1197.   thd->options &= ~(ulong) (OPTION_BIN_LOG);
  1198.   thd->proc_info = "Creating table from master dump";
  1199.   // save old db in case we are creating in a different database
  1200.   save_db = thd->db;
  1201.   save_db_length= thd->db_length;
  1202.   thd->db = (char*)db;
  1203.   DBUG_ASSERT(thd->db);
  1204.   thd->db_length= strlen(thd->db);
  1205.   mysql_parse(thd, thd->query, packet_len); // run create table
  1206.   thd->db = save_db; // leave things the way the were before
  1207.   thd->db_length= save_db_length;
  1208.   thd->options = save_options;
  1209.   
  1210.   if (thd->query_error)
  1211.     goto err; // mysql_parse took care of the error send
  1212.   thd->proc_info = "Opening master dump table";
  1213.   tables.lock_type = TL_WRITE;
  1214.   if (!open_ltable(thd, &tables, TL_WRITE))
  1215.   {
  1216.     send_error(thd,0,0); // Send error from open_ltable
  1217.     sql_print_error("create_table_from_dump: could not open created table");
  1218.     goto err;
  1219.   }
  1220.   
  1221.   file = tables.table->file;
  1222.   thd->proc_info = "Reading master dump table data";
  1223.   /* Copy the data file */
  1224.   if (file->net_read_dump(net))
  1225.   {
  1226.     net_printf(thd, ER_MASTER_NET_READ);
  1227.     sql_print_error("create_table_from_dump: failed in
  1228.  handler::net_read_dump()");
  1229.     goto err;
  1230.   }
  1231.   check_opt.init();
  1232.   check_opt.flags|= T_VERY_SILENT | T_CALC_CHECKSUM | T_QUICK;
  1233.   thd->proc_info = "Rebuilding the index on master dump table";
  1234.   /*
  1235.     We do not want repair() to spam us with messages
  1236.     just send them to the error log, and report the failure in case of
  1237.     problems.
  1238.   */
  1239.   save_vio = thd->net.vio;
  1240.   thd->net.vio = 0;
  1241.   /* Rebuild the index file from the copied data file (with REPAIR) */
  1242.   error=file->repair(thd,&check_opt) != 0;
  1243.   thd->net.vio = save_vio;
  1244.   if (error)
  1245.     net_printf(thd, ER_INDEX_REBUILD,tables.table->real_name);
  1246. err:
  1247.   close_thread_tables(thd);
  1248.   thd->net.no_send_ok = 0;
  1249.   DBUG_RETURN(error); 
  1250. }
  1251. int fetch_master_table(THD *thd, const char *db_name, const char *table_name,
  1252.        MASTER_INFO *mi, MYSQL *mysql, bool overwrite)
  1253. {
  1254.   int error= 1;
  1255.   const char *errmsg=0;
  1256.   bool called_connected= (mysql != NULL);
  1257.   DBUG_ENTER("fetch_master_table");
  1258.   DBUG_PRINT("enter", ("db_name: '%s'  table_name: '%s'",
  1259.        db_name,table_name));
  1260.   if (!called_connected)
  1261.   { 
  1262.     if (!(mysql = mysql_init(NULL)))
  1263.     {
  1264.       send_error(thd); // EOM
  1265.       DBUG_RETURN(1);
  1266.     }
  1267.     if (connect_to_master(thd, mysql, mi))
  1268.     {
  1269.       net_printf(thd, ER_CONNECT_TO_MASTER, mysql_error(mysql));
  1270.       mysql_close(mysql);
  1271.       DBUG_RETURN(1);
  1272.     }
  1273.     if (thd->killed)
  1274.       goto err;
  1275.   }
  1276.   if (request_table_dump(mysql, db_name, table_name))
  1277.   {
  1278.     error= ER_UNKNOWN_ERROR;
  1279.     errmsg= "Failed on table dump request";
  1280.     goto err;
  1281.   }
  1282.   if (create_table_from_dump(thd, mysql, db_name,
  1283.      table_name, overwrite))
  1284.     goto err;    // create_table_from_dump have sent the error already
  1285.   error = 0;
  1286.  err:
  1287.   thd->net.no_send_ok = 0; // Clear up garbage after create_table_from_dump
  1288.   if (!called_connected)
  1289.     mysql_close(mysql);
  1290.   if (errmsg && thd->vio_ok())
  1291.     send_error(thd, error, errmsg);
  1292.   DBUG_RETURN(test(error)); // Return 1 on error
  1293. }
  1294. void end_master_info(MASTER_INFO* mi)
  1295. {
  1296.   DBUG_ENTER("end_master_info");
  1297.   if (!mi->inited)
  1298.     DBUG_VOID_RETURN;
  1299.   end_relay_log_info(&mi->rli);
  1300.   if (mi->fd >= 0)
  1301.   {
  1302.     end_io_cache(&mi->file);
  1303.     (void)my_close(mi->fd, MYF(MY_WME));
  1304.     mi->fd = -1;
  1305.   }
  1306.   mi->inited = 0;
  1307.   DBUG_VOID_RETURN;
  1308. }
  1309. int init_relay_log_info(RELAY_LOG_INFO* rli, const char* info_fname)
  1310. {
  1311.   char fname[FN_REFLEN+128];
  1312.   int info_fd;
  1313.   const char* msg = 0;
  1314.   int error = 0;
  1315.   DBUG_ENTER("init_relay_log_info");
  1316.   if (rli->inited) // Set if this function called
  1317.     DBUG_RETURN(0);
  1318.   fn_format(fname, info_fname, mysql_data_home, "", 4+32);
  1319.   pthread_mutex_lock(&rli->data_lock);
  1320.   info_fd = rli->info_fd;
  1321.   rli->cur_log_fd = -1;
  1322.   rli->slave_skip_counter=0;
  1323.   rli->abort_pos_wait=0;
  1324.   rli->log_space_limit= relay_log_space_limit;
  1325.   rli->log_space_total= 0;
  1326.   // TODO: make this work with multi-master
  1327.   if (!opt_relay_logname)
  1328.   {
  1329.     char tmp[FN_REFLEN];
  1330.     /*
  1331.       TODO: The following should be using fn_format();  We just need to
  1332.       first change fn_format() to cut the file name if it's too long.
  1333.     */
  1334.     strmake(tmp,glob_hostname,FN_REFLEN-5);
  1335.     strmov(strcend(tmp,'.'),"-relay-bin");
  1336.     opt_relay_logname=my_strdup(tmp,MYF(MY_WME));
  1337.   }
  1338.   /*
  1339.     The relay log will now be opened, as a SEQ_READ_APPEND IO_CACHE.
  1340.     Note that the I/O thread flushes it to disk after writing every event, in
  1341.     flush_master_info(mi, 1).
  1342.   */
  1343.   /*
  1344.     For the maximum log size, we choose max_relay_log_size if it is
  1345.     non-zero, max_binlog_size otherwise. If later the user does SET
  1346.     GLOBAL on one of these variables, fix_max_binlog_size and
  1347.     fix_max_relay_log_size will reconsider the choice (for example
  1348.     if the user changes max_relay_log_size to zero, we have to
  1349.     switch to using max_binlog_size for the relay log) and update
  1350.     rli->relay_log.max_size (and mysql_bin_log.max_size).
  1351.   */
  1352.   if (open_log(&rli->relay_log, glob_hostname, opt_relay_logname,
  1353.        "-relay-bin", opt_relaylog_index_name,
  1354.        LOG_BIN, 1 /* read_append cache */,
  1355.        1 /* no auto events */,
  1356.                max_relay_log_size ? max_relay_log_size : max_binlog_size))
  1357.   {
  1358.     pthread_mutex_unlock(&rli->data_lock);
  1359.     sql_print_error("Failed in open_log() called from init_relay_log_info()");
  1360.     DBUG_RETURN(1);
  1361.   }
  1362.   /* if file does not exist */
  1363.   if (access(fname,F_OK))
  1364.   {
  1365.     /*
  1366.       If someone removed the file from underneath our feet, just close
  1367.       the old descriptor and re-create the old file
  1368.     */
  1369.     if (info_fd >= 0)
  1370.       my_close(info_fd, MYF(MY_WME));
  1371.     if ((info_fd = my_open(fname, O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0)
  1372.     {
  1373.       sql_print_error("Failed to create a new relay log info file (
  1374. file '%s', errno %d)", fname, my_errno);
  1375.       msg= current_thd->net.last_error;
  1376.       goto err;
  1377.     }
  1378.     if (init_io_cache(&rli->info_file, info_fd, IO_SIZE*2, READ_CACHE, 0L,0,
  1379.       MYF(MY_WME))) 
  1380.     {
  1381.       sql_print_error("Failed to create a cache on relay log info file '%s'",
  1382.       fname);
  1383.       msg= current_thd->net.last_error;
  1384.       goto err;
  1385.     }
  1386.     /* Init relay log with first entry in the relay index file */
  1387.     if (init_relay_log_pos(rli,NullS,BIN_LOG_HEADER_SIZE,0 /* no data lock */,
  1388.    &msg))
  1389.     {
  1390.       sql_print_error("Failed to open the relay log 'FIRST' (relay_log_pos 4)");
  1391.       goto err;
  1392.     }
  1393.     rli->group_master_log_name[0]= 0;
  1394.     rli->group_master_log_pos= 0;
  1395.     rli->info_fd= info_fd;
  1396.   }
  1397.   else // file exists
  1398.   {
  1399.     if (info_fd >= 0)
  1400.       reinit_io_cache(&rli->info_file, READ_CACHE, 0L,0,0);
  1401.     else 
  1402.     {
  1403.       int error=0;
  1404.       if ((info_fd = my_open(fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0)
  1405.       {
  1406.         sql_print_error("
  1407. Failed to open the existing relay log info file '%s' (errno %d)",
  1408. fname, my_errno);
  1409.         error= 1;
  1410.       }
  1411.       else if (init_io_cache(&rli->info_file, info_fd,
  1412.                              IO_SIZE*2, READ_CACHE, 0L, 0, MYF(MY_WME)))
  1413.       {
  1414.         sql_print_error("Failed to create a cache on relay log info file '%s'",
  1415. fname);
  1416.         error= 1;
  1417.       }
  1418.       if (error)
  1419.       {
  1420.         if (info_fd >= 0)
  1421.           my_close(info_fd, MYF(0));
  1422.         rli->info_fd= -1;
  1423.         rli->relay_log.close(LOG_CLOSE_INDEX | LOG_CLOSE_STOP_EVENT);
  1424.         pthread_mutex_unlock(&rli->data_lock);
  1425.         DBUG_RETURN(1);
  1426.       }
  1427.     }
  1428.          
  1429.     rli->info_fd = info_fd;
  1430.     int relay_log_pos, master_log_pos;
  1431.     if (init_strvar_from_file(rli->group_relay_log_name,
  1432.       sizeof(rli->group_relay_log_name),
  1433.                               &rli->info_file, "") ||
  1434.        init_intvar_from_file(&relay_log_pos,
  1435.      &rli->info_file, BIN_LOG_HEADER_SIZE) ||
  1436.        init_strvar_from_file(rli->group_master_log_name,
  1437.      sizeof(rli->group_master_log_name),
  1438.                              &rli->info_file, "") ||
  1439.        init_intvar_from_file(&master_log_pos, &rli->info_file, 0))
  1440.     {
  1441.       msg="Error reading slave log configuration";
  1442.       goto err;
  1443.     }
  1444.     strmake(rli->event_relay_log_name,rli->group_relay_log_name,
  1445.             sizeof(rli->event_relay_log_name)-1);
  1446.     rli->group_relay_log_pos= rli->event_relay_log_pos= relay_log_pos;
  1447.     rli->group_master_log_pos= master_log_pos;
  1448.     if (init_relay_log_pos(rli,
  1449.    rli->group_relay_log_name,
  1450.    rli->group_relay_log_pos,
  1451.    0 /* no data lock*/,
  1452.    &msg))
  1453.     {
  1454.       char llbuf[22];
  1455.       sql_print_error("Failed to open the relay log '%s' (relay_log_pos %s)",
  1456.       rli->group_relay_log_name,
  1457.       llstr(rli->group_relay_log_pos, llbuf));
  1458.       goto err;
  1459.     }
  1460.   }
  1461.   DBUG_ASSERT(rli->event_relay_log_pos >= BIN_LOG_HEADER_SIZE);
  1462.   DBUG_ASSERT(my_b_tell(rli->cur_log) == rli->event_relay_log_pos);
  1463.   /*
  1464.     Now change the cache from READ to WRITE - must do this
  1465.     before flush_relay_log_info
  1466.   */
  1467.   reinit_io_cache(&rli->info_file, WRITE_CACHE,0L,0,1);
  1468.   if ((error= flush_relay_log_info(rli)))
  1469.     sql_print_error("Failed to flush relay log info file");
  1470.   if (count_relay_log_space(rli))
  1471.   {
  1472.     msg="Error counting relay log space";
  1473.     goto err;
  1474.   }
  1475.   rli->inited= 1;
  1476.   pthread_mutex_unlock(&rli->data_lock);
  1477.   DBUG_RETURN(error);
  1478. err:
  1479.   sql_print_error(msg);
  1480.   end_io_cache(&rli->info_file);
  1481.   if (info_fd >= 0)
  1482.     my_close(info_fd, MYF(0));
  1483.   rli->info_fd= -1;
  1484.   rli->relay_log.close(LOG_CLOSE_INDEX | LOG_CLOSE_STOP_EVENT);
  1485.   pthread_mutex_unlock(&rli->data_lock);
  1486.   DBUG_RETURN(1);
  1487. }
  1488. static inline int add_relay_log(RELAY_LOG_INFO* rli,LOG_INFO* linfo)
  1489. {
  1490.   MY_STAT s;
  1491.   DBUG_ENTER("add_relay_log");
  1492.   if (!my_stat(linfo->log_file_name,&s,MYF(0)))
  1493.   {
  1494.     sql_print_error("log %s listed in the index, but failed to stat",
  1495.     linfo->log_file_name);
  1496.     DBUG_RETURN(1);
  1497.   }
  1498.   rli->log_space_total += s.st_size;
  1499. #ifndef DBUG_OFF
  1500.   char buf[22];
  1501.   DBUG_PRINT("info",("log_space_total: %s", llstr(rli->log_space_total,buf)));
  1502. #endif  
  1503.   DBUG_RETURN(0);
  1504. }
  1505. static bool wait_for_relay_log_space(RELAY_LOG_INFO* rli)
  1506. {
  1507.   bool slave_killed=0;
  1508.   MASTER_INFO* mi = rli->mi;
  1509.   const char *save_proc_info;
  1510.   THD* thd = mi->io_thd;
  1511.   DBUG_ENTER("wait_for_relay_log_space");
  1512.   pthread_mutex_lock(&rli->log_space_lock);
  1513.   save_proc_info= thd->enter_cond(&rli->log_space_cond,
  1514.   &rli->log_space_lock, 
  1515.   "
  1516. Waiting for the slave SQL thread to free enough relay log space");
  1517.   while (rli->log_space_limit < rli->log_space_total &&
  1518.  !(slave_killed=io_slave_killed(thd,mi)) &&
  1519.          !rli->ignore_log_space_limit)
  1520.     pthread_cond_wait(&rli->log_space_cond, &rli->log_space_lock);
  1521.   thd->exit_cond(save_proc_info);
  1522.   DBUG_RETURN(slave_killed);
  1523. }
  1524. static int count_relay_log_space(RELAY_LOG_INFO* rli)
  1525. {
  1526.   LOG_INFO linfo;
  1527.   DBUG_ENTER("count_relay_log_space");
  1528.   rli->log_space_total= 0;
  1529.   if (rli->relay_log.find_log_pos(&linfo, NullS, 1))
  1530.   {
  1531.     sql_print_error("Could not find first log while counting relay log space");
  1532.     DBUG_RETURN(1);
  1533.   }
  1534.   do
  1535.   {
  1536.     if (add_relay_log(rli,&linfo))
  1537.       DBUG_RETURN(1);
  1538.   } while (!rli->relay_log.find_next_log(&linfo, 1));
  1539.   /* 
  1540.      As we have counted everything, including what may have written in a
  1541.      preceding write, we must reset bytes_written, or we may count some space 
  1542.      twice.
  1543.   */
  1544.   rli->relay_log.reset_bytes_written();
  1545.   DBUG_RETURN(0);
  1546. }
  1547. /*
  1548.   Builds a Rotate from the ignored events' info and writes it to relay log.
  1549.   SYNOPSIS
  1550.   write_ignored_events_info_to_relay_log()
  1551.     thd             pointer to I/O thread's thd
  1552.     mi
  1553.   DESCRIPTION
  1554.     Slave I/O thread, going to die, must leave a durable trace of the
  1555.     ignored events' end position for the use of the slave SQL thread, by
  1556.     calling this function. Only that thread can call it (see assertion).
  1557.  */
  1558. static void write_ignored_events_info_to_relay_log(THD *thd, MASTER_INFO *mi)
  1559. {
  1560.   RELAY_LOG_INFO *rli= &mi->rli;
  1561.   pthread_mutex_t *log_lock= rli->relay_log.get_log_lock();
  1562.   DBUG_ASSERT(thd == mi->io_thd);
  1563.   pthread_mutex_lock(log_lock);
  1564.   if (rli->ign_master_log_name_end[0])
  1565.   {
  1566.     DBUG_PRINT("info",("writing a Rotate event to track down ignored events"));
  1567.     Rotate_log_event *ev= new Rotate_log_event(thd, rli->ign_master_log_name_end,
  1568.                                                0, rli->ign_master_log_pos_end,
  1569.                                                Rotate_log_event::DUP_NAME);
  1570.     rli->ign_master_log_name_end[0]= 0;
  1571.     /* can unlock before writing as slave SQL thd will soon see our Rotate */
  1572.     pthread_mutex_unlock(log_lock);
  1573.     if (likely((bool)ev))
  1574.     {
  1575.       ev->server_id= 0; // don't be ignored by slave SQL thread
  1576.       if (unlikely(rli->relay_log.append(ev)))
  1577.         sql_print_error("Slave I/O thread failed to write a Rotate event"
  1578.                         " to the relay log, "
  1579.                         "SHOW SLAVE STATUS may be inaccurate");
  1580.       rli->relay_log.harvest_bytes_written(&rli->log_space_total);
  1581.       flush_master_info(mi, 1);
  1582.       delete ev;
  1583.     }
  1584.     else
  1585.       sql_print_error("Slave I/O thread failed to create a Rotate event"
  1586.                       " (out of memory?), "
  1587.                       "SHOW SLAVE STATUS may be inaccurate");
  1588.   }
  1589.   else
  1590.     pthread_mutex_unlock(log_lock);
  1591. }
  1592. void init_master_info_with_options(MASTER_INFO* mi)
  1593. {
  1594.   mi->master_log_name[0] = 0;
  1595.   mi->master_log_pos = BIN_LOG_HEADER_SIZE; // skip magic number
  1596.   
  1597.   if (master_host)
  1598.     strmake(mi->host, master_host, sizeof(mi->host) - 1);
  1599.   if (master_user)
  1600.     strmake(mi->user, master_user, sizeof(mi->user) - 1);
  1601.   if (master_password)
  1602.     strmake(mi->password, master_password, MAX_PASSWORD_LENGTH);
  1603.   mi->port = master_port;
  1604.   mi->connect_retry = master_connect_retry;
  1605.   
  1606.   mi->ssl= master_ssl;
  1607.   if (master_ssl_ca)
  1608.     strmake(mi->ssl_ca, master_ssl_ca, sizeof(mi->ssl_ca)-1);
  1609.   if (master_ssl_capath)
  1610.     strmake(mi->ssl_capath, master_ssl_capath, sizeof(mi->ssl_capath)-1);
  1611.   if (master_ssl_cert)
  1612.     strmake(mi->ssl_cert, master_ssl_cert, sizeof(mi->ssl_cert)-1);
  1613.   if (master_ssl_cipher)
  1614.     strmake(mi->ssl_cipher, master_ssl_cipher, sizeof(mi->ssl_cipher)-1);
  1615.   if (master_ssl_key)
  1616.     strmake(mi->ssl_key, master_ssl_key, sizeof(mi->ssl_key)-1);
  1617. }
  1618. void clear_slave_error(RELAY_LOG_INFO* rli)
  1619. {
  1620.   /* Clear the errors displayed by SHOW SLAVE STATUS */
  1621.   rli->last_slave_error[0]= 0;
  1622.   rli->last_slave_errno= 0;
  1623. }
  1624. /*
  1625.     Reset UNTIL condition for RELAY_LOG_INFO
  1626.    SYNOPSYS
  1627.     clear_until_condition()
  1628.       rli - RELAY_LOG_INFO structure where UNTIL condition should be reset
  1629.  */
  1630. void clear_until_condition(RELAY_LOG_INFO* rli)
  1631. {
  1632.   rli->until_condition= RELAY_LOG_INFO::UNTIL_NONE;
  1633.   rli->until_log_name[0]= 0;
  1634.   rli->until_log_pos= 0;
  1635. }
  1636. #define LINES_IN_MASTER_INFO_WITH_SSL 14
  1637. int init_master_info(MASTER_INFO* mi, const char* master_info_fname,
  1638.      const char* slave_info_fname,
  1639.      bool abort_if_no_master_info_file,
  1640.      int thread_mask)
  1641. {
  1642.   int fd,error;
  1643.   char fname[FN_REFLEN+128];
  1644.   DBUG_ENTER("init_master_info");
  1645.   if (mi->inited)
  1646.   {
  1647.     /*
  1648.       We have to reset read position of relay-log-bin as we may have
  1649.       already been reading from 'hotlog' when the slave was stopped
  1650.       last time. If this case pos_in_file would be set and we would
  1651.       get a crash when trying to read the signature for the binary
  1652.       relay log.
  1653.       
  1654.       We only rewind the read position if we are starting the SQL
  1655.       thread. The handle_slave_sql thread assumes that the read
  1656.       position is at the beginning of the file, and will read the
  1657.       "signature" and then fast-forward to the last position read.
  1658.     */
  1659.     if (thread_mask & SLAVE_SQL)
  1660.     {
  1661.       my_b_seek(mi->rli.cur_log, (my_off_t) 0);
  1662.     }
  1663.     DBUG_RETURN(0);
  1664.   }
  1665.   mi->mysql=0;
  1666.   mi->file_id=1;
  1667.   fn_format(fname, master_info_fname, mysql_data_home, "", 4+32);
  1668.   /*
  1669.     We need a mutex while we are changing master info parameters to
  1670.     keep other threads from reading bogus info
  1671.   */
  1672.   pthread_mutex_lock(&mi->data_lock);
  1673.   fd = mi->fd;
  1674.   /* does master.info exist ? */
  1675.   
  1676.   if (access(fname,F_OK))
  1677.   {
  1678.     if (abort_if_no_master_info_file)
  1679.     {
  1680.       pthread_mutex_unlock(&mi->data_lock);
  1681.       DBUG_RETURN(0);
  1682.     }
  1683.     /*
  1684.       if someone removed the file from underneath our feet, just close
  1685.       the old descriptor and re-create the old file
  1686.     */
  1687.     if (fd >= 0)
  1688.       my_close(fd, MYF(MY_WME));
  1689.     if ((fd = my_open(fname, O_CREAT|O_RDWR|O_BINARY, MYF(MY_WME))) < 0 )
  1690.     {
  1691.       sql_print_error("Failed to create a new master info file (
  1692. file '%s', errno %d)", fname, my_errno);
  1693.       goto err;
  1694.     }
  1695.     if (init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L,0,
  1696.       MYF(MY_WME)))
  1697.     {
  1698.       sql_print_error("Failed to create a cache on master info file (
  1699. file '%s')", fname);
  1700.       goto err;
  1701.     }
  1702.     mi->fd = fd;
  1703.     init_master_info_with_options(mi);
  1704.   }
  1705.   else // file exists
  1706.   {
  1707.     if (fd >= 0)
  1708.       reinit_io_cache(&mi->file, READ_CACHE, 0L,0,0);
  1709.     else 
  1710.     {
  1711.       if ((fd = my_open(fname, O_RDWR|O_BINARY, MYF(MY_WME))) < 0 )
  1712.       {
  1713.         sql_print_error("Failed to open the existing master info file (
  1714. file '%s', errno %d)", fname, my_errno);
  1715.         goto err;
  1716.       }
  1717.       if (init_io_cache(&mi->file, fd, IO_SIZE*2, READ_CACHE, 0L,
  1718.                         0, MYF(MY_WME)))
  1719.       {
  1720.         sql_print_error("Failed to create a cache on master info file (
  1721. file '%s')", fname);
  1722.         goto err;
  1723.       }
  1724.     }
  1725.     mi->fd = fd;
  1726.     int port, connect_retry, master_log_pos, ssl= 0, lines;
  1727.     char *first_non_digit;
  1728.     
  1729.     /*
  1730.        Starting from 4.1.x master.info has new format. Now its
  1731.        first line contains number of lines in file. By reading this 
  1732.        number we will be always distinguish to which version our 
  1733.        master.info corresponds to. We can't simply count lines in 
  1734.        file since versions before 4.1.x could generate files with more
  1735.        lines than needed.
  1736.        If first line doesn't contain a number or contain number less than 
  1737.        14 then such file is treated like file from pre 4.1.1 version.
  1738.        There is no ambiguity when reading an old master.info, as before 
  1739.        4.1.1, the first line contained the binlog's name, which is either
  1740.        empty or has an extension (contains a '.'), so can't be confused 
  1741.        with an integer.
  1742.        So we're just reading first line and trying to figure which version 
  1743.        is this.
  1744.     */
  1745.     
  1746.     /* 
  1747.        The first row is temporarily stored in mi->master_log_name, 
  1748.        if it is line count and not binlog name (new format) it will be 
  1749.        overwritten by the second row later.
  1750.     */
  1751.     if (init_strvar_from_file(mi->master_log_name,
  1752.       sizeof(mi->master_log_name), &mi->file,
  1753.       ""))
  1754.       goto errwithmsg;
  1755.     
  1756.     lines= strtoul(mi->master_log_name, &first_non_digit, 10);
  1757.     if (mi->master_log_name[0]!='' && 
  1758.         *first_non_digit=='' && lines >= LINES_IN_MASTER_INFO_WITH_SSL)
  1759.     {                                          // Seems to be new format
  1760.       if (init_strvar_from_file(mi->master_log_name,     
  1761.             sizeof(mi->master_log_name), &mi->file, ""))
  1762.         goto errwithmsg;
  1763.     }
  1764.     else
  1765.       lines= 7;
  1766.     
  1767.     if (init_intvar_from_file(&master_log_pos, &mi->file, 4) ||
  1768. init_strvar_from_file(mi->host, sizeof(mi->host), &mi->file,
  1769.       master_host) ||
  1770. init_strvar_from_file(mi->user, sizeof(mi->user), &mi->file,
  1771.       master_user) || 
  1772.         init_strvar_from_file(mi->password, SCRAMBLED_PASSWORD_CHAR_LENGTH+1,
  1773.                               &mi->file, master_password) ||
  1774. init_intvar_from_file(&port, &mi->file, master_port) ||
  1775. init_intvar_from_file(&connect_retry, &mi->file,
  1776.       master_connect_retry))
  1777.       goto errwithmsg;
  1778.     /* 
  1779.        If file has ssl part use it even if we have server without 
  1780.        SSL support. But these option will be ignored later when 
  1781.        slave will try connect to master, so in this case warning 
  1782.        is printed.
  1783.      */
  1784.     if (lines >= LINES_IN_MASTER_INFO_WITH_SSL && 
  1785.         (init_intvar_from_file(&ssl, &mi->file, master_ssl) ||
  1786.          init_strvar_from_file(mi->ssl_ca, sizeof(mi->ssl_ca), 
  1787.                                &mi->file, master_ssl_ca) ||
  1788.          init_strvar_from_file(mi->ssl_capath, sizeof(mi->ssl_capath), 
  1789.                                &mi->file, master_ssl_capath) ||
  1790.          init_strvar_from_file(mi->ssl_cert, sizeof(mi->ssl_cert),
  1791.                                &mi->file, master_ssl_cert) ||
  1792.          init_strvar_from_file(mi->ssl_cipher, sizeof(mi->ssl_cipher),
  1793.                                &mi->file, master_ssl_cipher) ||
  1794.          init_strvar_from_file(mi->ssl_key, sizeof(mi->ssl_key),
  1795.                               &mi->file, master_ssl_key)))
  1796.       goto errwithmsg;
  1797. #ifndef HAVE_OPENSSL
  1798.     if (ssl)
  1799.       sql_print_error("SSL information in the master info file "
  1800.                       "('%s') are ignored because this MySQL slave was compiled "
  1801.                       "without SSL support.", fname);
  1802. #endif /* HAVE_OPENSSL */
  1803.     
  1804.     /*
  1805.       This has to be handled here as init_intvar_from_file can't handle
  1806.       my_off_t types
  1807.     */
  1808.     mi->master_log_pos= (my_off_t) master_log_pos;
  1809.     mi->port= (uint) port;
  1810.     mi->connect_retry= (uint) connect_retry;
  1811.     mi->ssl= (my_bool) ssl;
  1812.   }
  1813.   DBUG_PRINT("master_info",("log_file_name: %s  position: %ld",
  1814.     mi->master_log_name,
  1815.     (ulong) mi->master_log_pos));
  1816.   mi->rli.mi = mi;
  1817.   if (init_relay_log_info(&mi->rli, slave_info_fname))
  1818.     goto err;
  1819.   mi->inited = 1;
  1820.   // now change cache READ -> WRITE - must do this before flush_master_info
  1821.   reinit_io_cache(&mi->file, WRITE_CACHE,0L,0,1);
  1822.   if ((error=test(flush_master_info(mi, 1))))
  1823.     sql_print_error("Failed to flush master info file");
  1824.   pthread_mutex_unlock(&mi->data_lock);
  1825.   DBUG_RETURN(error);
  1826.   
  1827. errwithmsg:
  1828.   sql_print_error("Error reading master configuration");
  1829.   
  1830. err:
  1831.   if (fd >= 0)
  1832.   {
  1833.     my_close(fd, MYF(0));
  1834.     end_io_cache(&mi->file);
  1835.   }
  1836.   mi->fd= -1;
  1837.   pthread_mutex_unlock(&mi->data_lock);
  1838.   DBUG_RETURN(1);
  1839. }
  1840. int register_slave_on_master(MYSQL* mysql)
  1841. {
  1842.   char buf[1024], *pos= buf;
  1843.   uint report_host_len, report_user_len=0, report_password_len=0;
  1844.   if (!report_host)
  1845.     return 0;
  1846.   report_host_len= strlen(report_host);
  1847.   if (report_user)
  1848.     report_user_len= strlen(report_user);
  1849.   if (report_password)
  1850.     report_password_len= strlen(report_password);
  1851.   /* 30 is a good safety margin */
  1852.   if (report_host_len + report_user_len + report_password_len + 30 >
  1853.       sizeof(buf))
  1854.     return 0; // safety
  1855.   int4store(pos, server_id); pos+= 4;
  1856.   pos= net_store_data(pos, report_host, report_host_len); 
  1857.   pos= net_store_data(pos, report_user, report_user_len);
  1858.   pos= net_store_data(pos, report_password, report_password_len);
  1859.   int2store(pos, (uint16) report_port); pos+= 2;
  1860.   int4store(pos, rpl_recovery_rank); pos+= 4;
  1861.   /* The master will fill in master_id */
  1862.   int4store(pos, 0); pos+= 4;
  1863.   if (simple_command(mysql, COM_REGISTER_SLAVE, (char*) buf,
  1864. (uint) (pos- buf), 0))
  1865.   {
  1866.     sql_print_error("Error on COM_REGISTER_SLAVE: %d '%s'",
  1867.     mysql_errno(mysql),
  1868.     mysql_error(mysql));
  1869.     return 1;
  1870.   }
  1871.   return 0;
  1872. }
  1873. /*
  1874.   Builds a String from a HASH of TABLE_RULE_ENT. Cannot be used for any other 
  1875.   hash, as it assumes that the hash entries are TABLE_RULE_ENT.
  1876.   SYNOPSIS
  1877.     table_rule_ent_hash_to_str()
  1878.     s               pointer to the String to fill
  1879.     h               pointer to the HASH to read
  1880.   RETURN VALUES
  1881.     none
  1882. */
  1883. void table_rule_ent_hash_to_str(String* s, HASH* h)
  1884. {
  1885.   s->length(0);
  1886.   for (uint i=0 ; i < h->records ; i++)
  1887.   {
  1888.     TABLE_RULE_ENT* e= (TABLE_RULE_ENT*) hash_element(h, i);
  1889.     if (s->length())
  1890.       s->append(',');
  1891.     s->append(e->db,e->key_len);
  1892.   }
  1893. }
  1894. /*
  1895.   Mostly the same thing as above
  1896. */
  1897. void table_rule_ent_dynamic_array_to_str(String* s, DYNAMIC_ARRAY* a)
  1898. {
  1899.   s->length(0);
  1900.   for (uint i=0 ; i < a->elements ; i++)
  1901.   {
  1902.     TABLE_RULE_ENT* e;
  1903.     get_dynamic(a, (gptr)&e, i);
  1904.     if (s->length())
  1905.       s->append(',');
  1906.     s->append(e->db,e->key_len);
  1907.   }
  1908. }
  1909. int show_master_info(THD* thd, MASTER_INFO* mi)
  1910. {
  1911.   // TODO: fix this for multi-master
  1912.   List<Item> field_list;
  1913.   Protocol *protocol= thd->protocol;
  1914.   DBUG_ENTER("show_master_info");
  1915.   field_list.push_back(new Item_empty_string("Slave_IO_State",
  1916.      14));
  1917.   field_list.push_back(new Item_empty_string("Master_Host",
  1918.      sizeof(mi->host)));
  1919.   field_list.push_back(new Item_empty_string("Master_User",
  1920.      sizeof(mi->user)));
  1921.   field_list.push_back(new Item_return_int("Master_Port", 7,
  1922.    MYSQL_TYPE_LONG));
  1923.   field_list.push_back(new Item_return_int("Connect_Retry", 10,
  1924.    MYSQL_TYPE_LONG));
  1925.   field_list.push_back(new Item_empty_string("Master_Log_File",
  1926.      FN_REFLEN));
  1927.   field_list.push_back(new Item_return_int("Read_Master_Log_Pos", 10,
  1928.    MYSQL_TYPE_LONGLONG));
  1929.   field_list.push_back(new Item_empty_string("Relay_Log_File",
  1930.      FN_REFLEN));
  1931.   field_list.push_back(new Item_return_int("Relay_Log_Pos", 10,
  1932.    MYSQL_TYPE_LONGLONG));
  1933.   field_list.push_back(new Item_empty_string("Relay_Master_Log_File",
  1934.      FN_REFLEN));
  1935.   field_list.push_back(new Item_empty_string("Slave_IO_Running", 3));
  1936.   field_list.push_back(new Item_empty_string("Slave_SQL_Running", 3));
  1937.   field_list.push_back(new Item_empty_string("Replicate_Do_DB", 20));
  1938.   field_list.push_back(new Item_empty_string("Replicate_Ignore_DB", 20));
  1939.   field_list.push_back(new Item_empty_string("Replicate_Do_Table", 20));
  1940.   field_list.push_back(new Item_empty_string("Replicate_Ignore_Table", 23));
  1941.   field_list.push_back(new Item_empty_string("Replicate_Wild_Do_Table", 24));
  1942.   field_list.push_back(new Item_empty_string("Replicate_Wild_Ignore_Table",
  1943.      28));
  1944.   field_list.push_back(new Item_return_int("Last_Errno", 4, MYSQL_TYPE_LONG));
  1945.   field_list.push_back(new Item_empty_string("Last_Error", 20));
  1946.   field_list.push_back(new Item_return_int("Skip_Counter", 10,
  1947.    MYSQL_TYPE_LONG));
  1948.   field_list.push_back(new Item_return_int("Exec_Master_Log_Pos", 10,
  1949.    MYSQL_TYPE_LONGLONG));
  1950.   field_list.push_back(new Item_return_int("Relay_Log_Space", 10,
  1951.    MYSQL_TYPE_LONGLONG));
  1952.   field_list.push_back(new Item_empty_string("Until_Condition", 6));
  1953.   field_list.push_back(new Item_empty_string("Until_Log_File", FN_REFLEN));
  1954.   field_list.push_back(new Item_return_int("Until_Log_Pos", 10, 
  1955.                                            MYSQL_TYPE_LONGLONG));
  1956.   field_list.push_back(new Item_empty_string("Master_SSL_Allowed", 7));
  1957.   field_list.push_back(new Item_empty_string("Master_SSL_CA_File",
  1958.                                              sizeof(mi->ssl_ca)));
  1959.   field_list.push_back(new Item_empty_string("Master_SSL_CA_Path", 
  1960.                                              sizeof(mi->ssl_capath)));
  1961.   field_list.push_back(new Item_empty_string("Master_SSL_Cert", 
  1962.                                              sizeof(mi->ssl_cert)));
  1963.   field_list.push_back(new Item_empty_string("Master_SSL_Cipher", 
  1964.                                              sizeof(mi->ssl_cipher)));
  1965.   field_list.push_back(new Item_empty_string("Master_SSL_Key", 
  1966.                                              sizeof(mi->ssl_key)));
  1967.   field_list.push_back(new Item_return_int("Seconds_Behind_Master", 10,
  1968.                                            MYSQL_TYPE_LONGLONG));
  1969.   
  1970.   if (protocol->send_fields(&field_list, 1))
  1971.     DBUG_RETURN(-1);
  1972.   if (mi->host[0])
  1973.   {
  1974.     DBUG_PRINT("info",("host is set: '%s'", mi->host));
  1975.     String *packet= &thd->packet;
  1976.     protocol->prepare_for_resend();
  1977.   
  1978.     /*
  1979.       TODO: we read slave_running without run_lock, whereas these variables
  1980.       are updated under run_lock and not data_lock. In 5.0 we should lock
  1981.       run_lock on top of data_lock (with good order).
  1982.     */
  1983.     pthread_mutex_lock(&mi->data_lock);
  1984.     pthread_mutex_lock(&mi->rli.data_lock);
  1985.     protocol->store(mi->io_thd ? mi->io_thd->proc_info : "", &my_charset_bin);
  1986.     protocol->store(mi->host, &my_charset_bin);
  1987.     protocol->store(mi->user, &my_charset_bin);
  1988.     protocol->store((uint32) mi->port);
  1989.     protocol->store((uint32) mi->connect_retry);
  1990.     protocol->store(mi->master_log_name, &my_charset_bin);
  1991.     protocol->store((ulonglong) mi->master_log_pos);
  1992.     protocol->store(mi->rli.group_relay_log_name +
  1993.     dirname_length(mi->rli.group_relay_log_name),
  1994.     &my_charset_bin);
  1995.     protocol->store((ulonglong) mi->rli.group_relay_log_pos);
  1996.     protocol->store(mi->rli.group_master_log_name, &my_charset_bin);
  1997.     protocol->store(mi->slave_running == MYSQL_SLAVE_RUN_CONNECT ?
  1998.                     "Yes" : "No", &my_charset_bin);
  1999.     protocol->store(mi->rli.slave_running ? "Yes":"No", &my_charset_bin);
  2000.     protocol->store(&replicate_do_db);
  2001.     protocol->store(&replicate_ignore_db);
  2002.     /*
  2003.       We can't directly use some protocol->store for 
  2004.       replicate_*_table,
  2005.       as Protocol doesn't know the TABLE_RULE_ENT struct.
  2006.       We first build Strings and then pass them to protocol->store.
  2007.     */
  2008.     char buf[256];
  2009.     String tmp(buf, sizeof(buf), &my_charset_bin);
  2010.     table_rule_ent_hash_to_str(&tmp, &replicate_do_table);
  2011.     protocol->store(&tmp);
  2012.     table_rule_ent_hash_to_str(&tmp, &replicate_ignore_table);
  2013.     protocol->store(&tmp);
  2014.     table_rule_ent_dynamic_array_to_str(&tmp, &replicate_wild_do_table);
  2015.     protocol->store(&tmp);
  2016.     table_rule_ent_dynamic_array_to_str(&tmp, &replicate_wild_ignore_table);
  2017.     protocol->store(&tmp);
  2018.     protocol->store((uint32) mi->rli.last_slave_errno);
  2019.     protocol->store(mi->rli.last_slave_error, &my_charset_bin);
  2020.     protocol->store((uint32) mi->rli.slave_skip_counter);
  2021.     protocol->store((ulonglong) mi->rli.group_master_log_pos);
  2022.     protocol->store((ulonglong) mi->rli.log_space_total);
  2023.     protocol->store(
  2024.       mi->rli.until_condition==RELAY_LOG_INFO::UNTIL_NONE ? "None": 
  2025.         ( mi->rli.until_condition==RELAY_LOG_INFO::UNTIL_MASTER_POS? "Master":
  2026.           "Relay"), &my_charset_bin);
  2027.     protocol->store(mi->rli.until_log_name, &my_charset_bin);
  2028.     protocol->store((ulonglong) mi->rli.until_log_pos);
  2029.     
  2030. #ifdef HAVE_OPENSSL 
  2031.     protocol->store(mi->ssl? "Yes":"No", &my_charset_bin);
  2032. #else
  2033.     protocol->store(mi->ssl? "Ignored":"No", &my_charset_bin);
  2034. #endif
  2035.     protocol->store(mi->ssl_ca, &my_charset_bin);
  2036.     protocol->store(mi->ssl_capath, &my_charset_bin);
  2037.     protocol->store(mi->ssl_cert, &my_charset_bin);
  2038.     protocol->store(mi->ssl_cipher, &my_charset_bin);
  2039.     protocol->store(mi->ssl_key, &my_charset_bin);
  2040.     /*
  2041.       Seconds_Behind_Master: if SQL thread is running and I/O thread is
  2042.       connected, we can compute it otherwise show NULL (i.e. unknown).
  2043.     */
  2044.     if ((mi->slave_running == MYSQL_SLAVE_RUN_CONNECT) &&
  2045.         mi->rli.slave_running)
  2046.     {
  2047.       long tmp= (long)((time_t)time((time_t*) 0)
  2048.                                - mi->rli.last_master_timestamp)
  2049.         - mi->clock_diff_with_master;
  2050.       /*
  2051.         Apparently on some systems tmp can be <0. Here are possible reasons
  2052.         related to MySQL:
  2053.         - the master is itself a slave of another master whose time is ahead.
  2054.         - somebody used an explicit SET TIMESTAMP on the master.
  2055.         Possible reason related to granularity-to-second of time functions
  2056.         (nothing to do with MySQL), which can explain a value of -1:
  2057.         assume the master's and slave's time are perfectly synchronized, and
  2058.         that at slave's connection time, when the master's timestamp is read,
  2059.         it is at the very end of second 1, and (a very short time later) when
  2060.         the slave's timestamp is read it is at the very beginning of second