List:Commits« Previous MessageNext Message »
From:He Zhenxing Date:October 29 2008 1:40pm
Subject:Re: bzr commit
into mysql-5.0-bugteam branch (alfranio.correia:2704) Bug#31665
Bug#35542 Bug#40337
View as plain text  
alfranio correia wrote:
> He Zhenxing wrote:
> > alfranio correia wrote:
> >   
> >> Hi,
> >>
> >> He Zhenxing wrote:
> >>     
> >>> Hi Alfranio
> >>>
> >>> Maybe I did not make my point very clearly in my previous mail, here is
> >>> a summary of the things that I think you need to consider:
> >>>
> >>> 1) Only include the code of your approach in your patch, remove all the
> >>> code from patches for BUG#31665
> >>>   
> >>>       
> >> I agree with that but my patch needs to be applied right after applying
> >> yours.
> >> There is an intersection between these patches.
> >>     
> >
> > Although both patches may modify some code lines at the same time, but I
> > think that your approach does not dependent on the approach implemented
> > for BUG#31665, they are two different approaches for the same problem.
> > So I don't think your patch need to be based on the patch of BUG#31665,
> > I think you can base your approach directly on the original mysql-5.0
> > code.
> >
> > Please don't hesitate to tell me if I misunderstand or miss something
> > here.
> >
> >   
> Jasonh, for the motorola case, we need to have something like this:
> 
> if (((sync_relaylog_period && count > sync_relaylog_period) ||
> relay_log_throw)

Yes, if we have to provide both approaches to motorola, but we can
handle this whem merging these two patches. 

And we probably only include your patch for the custom build for
motorola issue.

> > >>  && !error)
> 
> >> See the code below.
> >>     
> >>> 2) I think we only discard relay-log when we restart slave after a
> >>> crash, or we detected some error in the relay-log or master.info,
> >>> otherwise slave should act as normal.
> >>>
> >>> 3) the discarded relay-logs need to be purged correctly, so that there
> >>> will not be duplicated binlog events in the relay-log. (You already
> >>> commented on this, if it does, then it's OK)
> >>>
> >>> alfranio correia wrote:
> >>>   
> >>>       
> >>>> He Zhenxing wrote:
> >>>>     
> >>>>         
> >>>>> Hi Alfranio
> >>>>>
> >>>>> Thank you for your work!
> >>>>>
> >>>>> Here is my thoughts about these two approaches:
> >>>>> 1) The first approach (BUG#35542, BUG#31665) introduces
> >>>>> --sync-relay-log, which fsync the relay-log and master.info for
> every
> >>>>> sync_relay_log events, and fsync the relay-log.info every
> sync_relay_log
> >>>>> transactions.
> >>>>>  
> >>>>> 2) The second approach (BUG#40337) introduces --relay-log-throw,
> which
> >>>>> fsync the relay-log.info for EVERY transaction, and when restart
> from
> >>>>> server crash, the slave purges any relay-logs after the executed
> master
> >>>>> log position recorded in relay-log.info and re-fetch master
> binlogs from
> >>>>> that position.
> >>>>>
> >>>>> I think most part of these two approaches are orthogonal, except
> that we
> >>>>> have to make sure when both are enabled, the relay-log.info is
> only
> >>>>> flushed once for every transaction.
> >>>>>   
> >>>>>       
> >>>>>           
> >>>> Jasonh, I partially agree with that.  In order to ensure that the
> >>>> relay-log.info is synced after every transaction
> >>>> I've changed some lines in your patch:
> >>>>
> >>>> yours--->
> >>>>
> >>>> @@ -4885,10 +4890,16 @@ bool flush_relay_log_info(RELAY_LOG_INFO
> >>>>      error=1;
> >>>>    if (flush_io_cache(file))
> >>>>      error=1;
> >>>> +  static unsigned int count= 1;
> >>>>    if (sync_relaylog_period &&
> >>>>        !error &&
> >>>> -      my_sync(rli->info_fd, MYF(MY_WME)))
> >>>> -    error=1;
> >>>> +      count > sync_relaylog_period)
> >>>> +  {
> >>>> +    if (my_sync(rli->info_fd, MYF(MY_WME)))
> >>>> +      error=1;
> >>>> +    count= 1;
> >>>> +  }
> >>>>
> >>>> ----------------------
> >>>> mine--->
> >>>>
> >>>> - if (sync_relaylog_period &&
> >>>> - !error &&
> >>>> -     count > sync_relaylog_period)
> >>>> +  if (sync_relaylog_period &&
> >>>> +      !error)
> >>>> ------------------------
> >>>>
> >>>> I can do something like this:
> >>>>
> >>>> if (((sync_relaylog_period && count >
> sync_relaylog_period) || relay_log_throw)
> >>>>  && !error)
> >>>>
> >>>>     
> >>>>         
> >>>>> So I think you do not need to base your patch on mine (actually
> >>>>> Sinisa's), I think your approach and the approach proposed by
> Sinisa can
> >>>>> be seperate. It should be possible that we only add your
> approach to the
> >>>>> code. So I think your approach should only depend on option
> >>>>> --relay-log-throw, and should not have dependency on option
> >>>>> --sync-relay-log.
> >>>>>
> >>>>> BTW, since the performance of previous approach is acceptable if
> we turn
> >>>>> on hard drive cache, and it won't delete the relay-log that's
> already
> >>>>> been saved on slave, which some users may prefer, so I think the
> first
> >>>>> approach still has its use case. So I think we can have both and
> the
> >>>>> users can choose any one of them or both of them.
> >>>>>
> >>>>> There are also some inline comments.
> >>>>>
> >>>>> Alfranio Correia wrote:
> >>>>>   
> >>>>>       
> >>>>>           
> >>>>>> #At
> file:///home/acorreia/workspace.sun/playground.mysql/mysql-5.0.68-custom_build/
> >>>>>>
> >>>>>>  2704 Alfranio Correia	2008-10-27
> >>>>>>       Merged patch that was proposed by Sinisa and modified
> by He Zhenxing to fix bugs: BUG#35542 and BUG#31665. This is an update to BUG#40337.
> >>>>>>       And introduced a new recovery process that disregards
> old relay-log.bin(s) and starts
> >>>>>>       re-fetching from the master based on the information
> in relay-log.info which may be flushed and synced after each transaction commit.
> >>>>>> modified:
> >>>>>>   mysql-test/r/rpl_flush_log_loop.result
> >>>>>>   sql/log.cc
> >>>>>>   sql/mysql_priv.h
> >>>>>>   sql/mysqld.cc
> >>>>>>   sql/set_var.cc
> >>>>>>   sql/set_var.h
> >>>>>>   sql/slave.cc
> >>>>>>   sql/sql_class.h
> >>>>>>
> >>>>>> per-file messages:
> >>>>>>   mysql-test/r/rpl_flush_log_loop.result
> >>>>>>     Changed result file for a test case affected by fix
> proposed for BUG#40337
> >>>>>>   sql/log.cc
> >>>>>>     Added support to the checkpoint interval through the
> parameter --sync-relay-log.
> >>>>>>   sql/mysql_priv.h
> >>>>>>     Created parameter --relay_log_throw, default = 0 thus
> keeping the original behavior. And added support to the checkpoint interval through the
> parameter --sync-relay-log, default = 0 thus keeping the original behavior.
> >>>>>>     
> >>>>>>         
> >>>>>>             
> >>>>> Usually, we use hyphen (-) instead of underscore (_) in option
> names,
> >>>>> but the corresponding parameter name will use unserscore.
> >>>>>   
> >>>>>       
> >>>>>           
> >>>> I will fix this in the next commit.
> >>>>     
> >>>>         
> >>>>>   
> >>>>>       
> >>>>>           
> >>>>>>   sql/mysqld.cc
> >>>>>>     Created parameter --relay_log_throw, default = 0 thus
> keeping the original behavior. And added support to the checkpoint interval through the
> parameter --sync-relay-log, default = 0 thus keeping the original behavior.
> >>>>>>   sql/set_var.cc
> >>>>>>     Created parameter --relay_log_throw, default = 0 thus
> keeping the original behavior. And added support to the checkpoint interval through the
> parameter --sync-relay-log, default = 0 thus keeping the original behavior.
> >>>>>>   sql/set_var.h
> >>>>>>     Added support to the checkpoint interval through the
> parameter --sync-relay-log.
> >>>>>>   sql/slave.cc
> >>>>>>     Introduced the function init_recovery that is fired
> right after the startup and
> >>>>>>     updates the master.info according to the relay-log.info
> and throws away (i.e. ignores)the old relay-log.bin. And also added support to the
> checkpoint interval through the parameter --sync-relay-log. 
> >>>>>>     
> >>>>>>     Note that the when --sync-relay-log is on the relay-info
> is flushed and synced per transaction commit: 
> >>>>>>     
> >>>>>>           if (sync_relaylog_period &&
> >>>>>>               !error)
> >>>>>>           {
> >>>>>>             if (my_sync(rli->info_fd, MYF(MY_WME)))
> >>>>>>               error=1;
> >>>>>>           }
> >>>>>>     
> >>>>>>     This is a bit different from the patch proposed for
> BUG#35542 and BUG#31665.
> >>>>>>   sql/sql_class.h
> >>>>>>     Created sync_period that determines how often the
> master.info and relay-log.bin are flushed and synch. This parameter should be seen as a
> checkpoint based on number of events.
> >>>>>> === modified file 'mysql-test/r/rpl_flush_log_loop.result'
> >>>>>> --- a/mysql-test/r/rpl_flush_log_loop.result	2007-10-10
> 07:21:11 +0000
> >>>>>> +++ b/mysql-test/r/rpl_flush_log_loop.result	2008-10-27
> 15:09:43 +0000
> >>>>>> @@ -10,6 +10,7 @@ relay_log	MYSQLTEST_VARDIR/master-data/r
> >>>>>>  relay_log_index	
> >>>>>>  relay_log_info_file	relay-log.info
> >>>>>>  relay_log_purge	ON
> >>>>>> +relay_log_throw	OFF
> >>>>>>  relay_log_space_limit	0
> >>>>>>  stop slave;
> >>>>>>  change master to
> master_host='127.0.0.1',master_user='root',
> >>>>>>
> >>>>>> === modified file 'sql/log.cc'
> >>>>>> --- a/sql/log.cc	2008-07-24 12:28:21 +0000
> >>>>>> +++ b/sql/log.cc	2008-10-27 15:09:43 +0000
> >>>>>> @@ -32,8 +32,7 @@
> >>>>>>  #include "message.h"
> >>>>>>  #endif
> >>>>>>  
> >>>>>> -MYSQL_LOG mysql_log, mysql_slow_log, mysql_bin_log;
> >>>>>> -ulong sync_binlog_counter= 0;
> >>>>>> +MYSQL_LOG mysql_log, mysql_slow_log,
> mysql_bin_log(&sync_binlog_period);
> >>>>>>  
> >>>>>>  static Muted_query_log_event invisible_commit;
> >>>>>>  
> >>>>>> @@ -402,10 +401,11 @@ static int find_uniq_filename(char
> *name
> >>>>>>  }
> >>>>>>  
> >>>>>>
> >>>>>> -MYSQL_LOG::MYSQL_LOG()
> >>>>>> +MYSQL_LOG::MYSQL_LOG(uint *sync_period)
> >>>>>>    :bytes_written(0), last_time(0), query_start(0),
> name(0),
> >>>>>>     prepared_xids(0), log_type(LOG_CLOSED), file_id(1),
> open_count(1),
> >>>>>>     write_error(FALSE), inited(FALSE),
> need_start_event(TRUE),
> >>>>>> +   sync_period_ptr(sync_period),
> >>>>>>     description_event_for_exec(0),
> description_event_for_queue(0)
> >>>>>>  {
> >>>>>>    /*
> >>>>>> @@ -1622,6 +1622,8 @@ bool MYSQL_LOG::append(Log_event* ev)
> >>>>>>    }
> >>>>>>    bytes_written+= ev->data_written;
> >>>>>>    DBUG_PRINT("info",("max_size: %lu",max_size));
> >>>>>> +  if (flush_and_sync())
> >>>>>> +    goto err;
> >>>>>>    if ((uint) my_b_append_tell(&log_file) >
> max_size)
> >>>>>>      new_file(0);
> >>>>>>  
> >>>>>> @@ -1652,6 +1654,8 @@ bool MYSQL_LOG::appendv(const char*
> buf,
> >>>>>>      bytes_written += len;
> >>>>>>    } while ((buf=va_arg(args,const char*)) &&
> (len=va_arg(args,uint)));
> >>>>>>    DBUG_PRINT("info",("max_size: %lu",max_size));
> >>>>>> +  if (flush_and_sync())
> >>>>>> +    goto err;
> >>>>>>    if ((uint) my_b_append_tell(&log_file) >
> max_size)
> >>>>>>      new_file(0);
> >>>>>>  
> >>>>>> @@ -1758,9 +1762,10 @@ bool MYSQL_LOG::flush_and_sync()
> >>>>>>    safe_mutex_assert_owner(&LOCK_log);
> >>>>>>    if (flush_io_cache(&log_file))
> >>>>>>      return 1;
> >>>>>> -  if (++sync_binlog_counter >= sync_binlog_period
> && sync_binlog_period)
> >>>>>> +  uint sync_period= get_sync_period();
> >>>>>> +  if (sync_period && ++sync_counter >=
> sync_period)
> >>>>>>    {
> >>>>>> -    sync_binlog_counter= 0;
> >>>>>> +    sync_counter= 0;
> >>>>>>      err=my_sync(fd, MYF(MY_WME));
> >>>>>>    }
> >>>>>>    return err;
> >>>>>>
> >>>>>> === modified file 'sql/mysql_priv.h'
> >>>>>> --- a/sql/mysql_priv.h	2008-10-02 11:57:52 +0000
> >>>>>> +++ b/sql/mysql_priv.h	2008-10-27 15:09:43 +0000
> >>>>>> @@ -1310,10 +1310,11 @@ extern ulong max_binlog_size,
> max_relay_
> >>>>>>  extern ulong rpl_recovery_rank, thread_cache_size;
> >>>>>>  extern ulong back_log;
> >>>>>>  extern ulong specialflag, current_pid;
> >>>>>> -extern ulong expire_logs_days, sync_binlog_period,
> sync_binlog_counter;
> >>>>>> +extern ulong expire_logs_days;
> >>>>>> +extern uint sync_binlog_period, sync_relaylog_period;
> >>>>>>  extern ulong opt_tc_log_size, tc_log_max_pages_used,
> tc_log_page_size;
> >>>>>>  extern ulong tc_log_page_waits;
> >>>>>> -extern my_bool relay_log_purge, opt_innodb_safe_binlog,
> opt_innodb;
> >>>>>> +extern my_bool relay_log_purge, relay_log_throw,
> opt_innodb_safe_binlog, opt_innodb;
> >>>>>>  extern uint test_flags,select_errors,ha_open_options;
> >>>>>>  extern uint protocol_version, mysqld_port,
> dropping_tables;
> >>>>>>  extern uint delay_key_write_options,
> lower_case_table_names;
> >>>>>>
> >>>>>> === modified file 'sql/mysqld.cc'
> >>>>>> --- a/sql/mysqld.cc	2008-08-26 08:32:43 +0000
> >>>>>> +++ b/sql/mysqld.cc	2008-10-27 15:09:43 +0000
> >>>>>> @@ -404,7 +404,7 @@ ulong opt_ndb_cache_check_time;
> >>>>>>  const char *opt_ndb_mgmd;
> >>>>>>  ulong opt_ndb_nodeid;
> >>>>>>  #endif
> >>>>>> -my_bool opt_readonly, use_temp_pool, relay_log_purge;
> >>>>>> +my_bool opt_readonly, use_temp_pool, relay_log_purge,
> relay_log_throw;
> >>>>>>  my_bool opt_sync_frm, opt_allow_suspicious_udfs;
> >>>>>>  my_bool opt_secure_auth= 0;
> >>>>>>  char* opt_secure_file_priv= 0;
> >>>>>> @@ -466,7 +466,8 @@ ulong max_prepared_stmt_count;
> >>>>>>  */
> >>>>>>  ulong prepared_stmt_count=0;
> >>>>>>  ulong thread_id=1L,current_pid;
> >>>>>> -ulong slow_launch_threads = 0, sync_binlog_period;
> >>>>>> +ulong slow_launch_threads = 0;
> >>>>>> +uint sync_binlog_period= 0, sync_relaylog_period= 0;
> >>>>>>  ulong expire_logs_days = 0;
> >>>>>>  ulong rpl_recovery_rank=0;
> >>>>>>  
> >>>>>> @@ -4918,6 +4919,7 @@ enum options_mysqld
> >>>>>>    OPT_QUERY_CACHE_TYPE, OPT_QUERY_CACHE_WLOCK_INVALIDATE,
> OPT_RECORD_BUFFER,
> >>>>>>    OPT_RECORD_RND_BUFFER, OPT_DIV_PRECINCREMENT,
> OPT_RELAY_LOG_SPACE_LIMIT,
> >>>>>>    OPT_RELAY_LOG_PURGE,
> >>>>>> +  OPT_RELAY_LOG_THROW,
> >>>>>>    OPT_SLAVE_NET_TIMEOUT, OPT_SLAVE_COMPRESSED_PROTOCOL,
> OPT_SLOW_LAUNCH_TIME,
> >>>>>>    OPT_SLAVE_TRANS_RETRIES, OPT_READONLY, OPT_DEBUGGING,
> >>>>>>    OPT_SORT_BUFFER, OPT_TABLE_CACHE,
> >>>>>> @@ -4995,7 +4997,8 @@ enum options_mysqld
> >>>>>>    OPT_SECURE_FILE_PRIV,
> >>>>>>    OPT_KEEP_FILES_ON_CREATE,
> >>>>>>    OPT_INNODB_ADAPTIVE_HASH_INDEX,
> >>>>>> -  OPT_FEDERATED
> >>>>>> +  OPT_FEDERATED,
> >>>>>> +  OPT_SYNC_RELAY_LOG
> >>>>>>  };
> >>>>>>  
> >>>>>>
> >>>>>> @@ -6302,6 +6305,11 @@ The minimum value for this variable
> is 4
> >>>>>>     (gptr*) &relay_log_purge,
> >>>>>>     (gptr*) &relay_log_purge, 0, GET_BOOL, NO_ARG,
> >>>>>>     1, 0, 1, 0, 1, 0},
> >>>>>> +  {"relay_log_throw", OPT_RELAY_LOG_THROW,
> >>>>>> +   "0 = do not ignore retrieved relay logs. 1 = ignore
> retrieved relay logs.",
> >>>>>> +   (gptr*) &relay_log_throw,
> >>>>>> +   (gptr*) &relay_log_throw, 0, GET_BOOL, NO_ARG,
> >>>>>> +   0, 0, 1, 0, 1, 0},
> >>>>>>    {"relay_log_space_limit", OPT_RELAY_LOG_SPACE_LIMIT,
> >>>>>>     "Maximum space to use for all relay logs.",
> >>>>>>     (gptr*) &relay_log_space_limit,
> >>>>>> @@ -6342,8 +6350,13 @@ The minimum value for this variable
> is 4
> >>>>>>    {"sync-binlog", OPT_SYNC_BINLOG,
> >>>>>>     "Synchronously flush binary log to disk after every #th
> event. "
> >>>>>>     "Use 0 (default) to disable synchronous flushing.",
> >>>>>> -   (gptr*) &sync_binlog_period, (gptr*)
> &sync_binlog_period, 0, GET_ULONG,
> >>>>>> -   REQUIRED_ARG, 0, 0, ULONG_MAX, 0, 1, 0},
> >>>>>> +   (gptr*) &sync_binlog_period, (gptr*)
> &sync_binlog_period, 0, GET_UINT,
> >>>>>> +   REQUIRED_ARG, 0, 0, UINT_MAX, 0, 1, 0},
> >>>>>> +  {"sync-relay-log", OPT_SYNC_RELAY_LOG,
> >>>>>> +   "Synchronously flush relay log to disk after every #th
> event. "
> >>>>>> +   "Use 0 (default) to disable synchronous flushing.",
> >>>>>> +   (gptr *) &sync_relaylog_period, (gptr *)
> &sync_relaylog_period, 0, GET_UINT,
> >>>>>> +   REQUIRED_ARG, 0, 0, UINT_MAX, 0, 1, 0},
> >>>>>>    {"sync-frm", OPT_SYNC_FRM, "Sync .frm to disk on create.
> Enabled by default.",
> >>>>>>     (gptr*) &opt_sync_frm, (gptr*) &opt_sync_frm, 0,
> GET_BOOL, NO_ARG, 1, 0,
> >>>>>>     0, 0, 0, 0},
> >>>>>>
> >>>>>> === modified file 'sql/set_var.cc'
> >>>>>> --- a/sql/set_var.cc	2008-08-25 12:11:59 +0000
> >>>>>> +++ b/sql/set_var.cc	2008-10-27 15:09:43 +0000
> >>>>>> @@ -323,6 +323,8 @@
> sys_var_thd_ulong	sys_div_precincrement(
> >>>>>>  #ifdef HAVE_REPLICATION
> >>>>>>  sys_var_bool_ptr	sys_relay_log_purge("relay_log_purge",
> >>>>>>                                             
> &relay_log_purge);
> >>>>>> +sys_var_bool_ptr	sys_relay_log_throw("relay_log_throw",
> >>>>>> +                                           
> &relay_log_throw);
> >>>>>>  #endif
> >>>>>> 
> sys_var_long_ptr	sys_rpl_recovery_rank("rpl_recovery_rank",
> >>>>>>  					      &rpl_recovery_rank);
> >>>>>> @@ -402,7 +404,8 @@ sys_var_thd_table_type 
> sys_table_type("
> >>>>>>  sys_var_thd_storage_engine
> sys_storage_engine("storage_engine",
> >>>>>>  				       &SV::table_type);
> >>>>>>  #ifdef HAVE_REPLICATION
> >>>>>> -sys_var_sync_binlog_period
> sys_sync_binlog_period("sync_binlog", &sync_binlog_period);
> >>>>>> +sys_var_int_ptr sys_sync_binlog_period("sync_binlog",
> &sync_binlog_period);
> >>>>>> +sys_var_int_ptr sys_sync_relaylog_period("sync_relay_log",
> &sync_relaylog_period);
> >>>>>>  #endif
> >>>>>>  sys_var_bool_ptr	sys_sync_frm("sync_frm",
> &opt_sync_frm);
> >>>>>>  sys_var_const_str	sys_system_time_zone("system_time_zone",
> >>>>>> @@ -733,6 +736,7 @@ sys_var *sys_variables[]=
> >>>>>>    &sys_read_rnd_buff_size,
> >>>>>>  #ifdef HAVE_REPLICATION
> >>>>>>    &sys_relay_log_purge,
> >>>>>> +  &sys_relay_log_throw,
> >>>>>>  #endif
> >>>>>>    &sys_rpl_recovery_rank,
> >>>>>>    &sys_safe_updates,
> >>>>>> @@ -762,6 +766,7 @@ sys_var *sys_variables[]=
> >>>>>>    &sys_storage_engine,
> >>>>>>  #ifdef HAVE_REPLICATION
> >>>>>>    &sys_sync_binlog_period,
> >>>>>> +  &sys_sync_relaylog_period,
> >>>>>>  #endif
> >>>>>>    &sys_sync_frm,
> >>>>>>    &sys_system_time_zone,
> >>>>>> @@ -1052,6 +1057,7 @@ struct show_var_st init_vars[]= {
> >>>>>>    {"relay_log_index", (char*) &opt_relaylog_index_name,
> SHOW_CHAR_PTR},
> >>>>>>    {"relay_log_info_file", (char*) &relay_log_info_file,
> SHOW_CHAR_PTR},
> >>>>>>    {sys_relay_log_purge.name,  (char*)
> &sys_relay_log_purge,         SHOW_SYS},
> >>>>>> +  {sys_relay_log_throw.name,  (char*)
> &sys_relay_log_throw,         SHOW_SYS},
> >>>>>>    {"relay_log_space_limit",  (char*)
> &relay_log_space_limit,        SHOW_LONGLONG},
> >>>>>>  #endif
> >>>>>>    {sys_rpl_recovery_rank.name,(char*)
> &sys_rpl_recovery_rank,       SHOW_SYS},
> >>>>>> @@ -1090,6 +1096,7 @@ struct show_var_st init_vars[]= {
> >>>>>>    {sys_storage_engine.name,   (char*)
> &sys_storage_engine,          SHOW_SYS},
> >>>>>>  #ifdef HAVE_REPLICATION
> >>>>>>    {sys_sync_binlog_period.name,(char*)
> &sys_sync_binlog_period,     SHOW_SYS},
> >>>>>> +  {sys_sync_relaylog_period.name,(char*)
> &sys_sync_relaylog_period,     SHOW_SYS},
> >>>>>>  #endif
> >>>>>>    {sys_sync_frm.name,         (char*) &sys_sync_frm,   
>            SHOW_SYS},
> >>>>>>  #ifdef HAVE_TZNAME
> >>>>>> @@ -1486,6 +1493,23 @@ static bool get_unsigned(THD *thd,
> set_v
> >>>>>>  }
> >>>>>>  
> >>>>>>
> >>>>>> +bool sys_var_int_ptr::check(THD *thd, set_var *var)
> >>>>>> +{
> >>>>>> +  var->save_result.ulong_value= (ulong)
> var->value->val_int();
> >>>>>> +  return 0;
> >>>>>> +}
> >>>>>> +
> >>>>>> +bool sys_var_int_ptr::update(THD *thd, set_var *var)
> >>>>>> +{
> >>>>>> +  *value= (uint) var->save_result.ulong_value;
> >>>>>> +  return 0;
> >>>>>> +}
> >>>>>> +
> >>>>>> +void sys_var_int_ptr::set_default(THD *thd, enum_var_type
> type)
> >>>>>> +{
> >>>>>> +  *value= (uint) option_limits->def_value;
> >>>>>> +}
> >>>>>> +
> >>>>>>  sys_var_long_ptr::
> >>>>>>  sys_var_long_ptr(const char *name_arg, ulong
> *value_ptr_arg,
> >>>>>>                   sys_after_update_func after_update_arg)
> >>>>>> @@ -2759,13 +2783,6 @@ bool
> sys_var_slave_skip_counter::update(
> >>>>>>    pthread_mutex_unlock(&LOCK_active_mi);
> >>>>>>    return 0;
> >>>>>>  }
> >>>>>> -
> >>>>>> -
> >>>>>> -bool sys_var_sync_binlog_period::update(THD *thd, set_var
> *var)
> >>>>>> -{
> >>>>>> -  sync_binlog_period= (ulong)
> var->save_result.ulonglong_value;
> >>>>>> -  return 0;
> >>>>>> -}
> >>>>>>  #endif /* HAVE_REPLICATION */
> >>>>>>  
> >>>>>>  bool sys_var_rand_seed1::update(THD *thd, set_var *var)
> >>>>>>
> >>>>>> === modified file 'sql/set_var.h'
> >>>>>> --- a/sql/set_var.h	2008-01-23 15:03:58 +0000
> >>>>>> +++ b/sql/set_var.h	2008-10-27 15:09:43 +0000
> >>>>>> @@ -110,6 +110,26 @@ public:
> >>>>>>    { return (byte*) value; }
> >>>>>>  };
> >>>>>>  
> >>>>>> +/**
> >>>>>> +   Unsigned int system variable class
> >>>>>> + */
> >>>>>> +class sys_var_int_ptr :public sys_var
> >>>>>> +{
> >>>>>> +public:
> >>>>>> +  sys_var_int_ptr(const char *name_arg, uint
> *value_ptr_arg,
> >>>>>> +                  sys_after_update_func after_update_arg=
> NULL)
> >>>>>> +    :sys_var(name_arg, after_update_arg),
> >>>>>> +     value(value_ptr_arg)
> >>>>>> +  {}
> >>>>>> +  bool check(THD *thd, set_var *var);
> >>>>>> +  bool update(THD *thd, set_var *var);
> >>>>>> +  void set_default(THD *thd, enum_var_type type);
> >>>>>> +  SHOW_TYPE show_type() { return SHOW_INT; }
> >>>>>> +  byte *value_ptr(THD *thd, enum_var_type type, LEX_STRING
> *base)
> >>>>>> +  { return (byte*) value; }
> >>>>>> +private:
> >>>>>> +  uint *value;
> >>>>>> +};
> >>>>>>  
> >>>>>>  /*
> >>>>>>    A global ulong variable that is protected by
> LOCK_global_system_variables
> >>>>>> @@ -550,11 +570,11 @@ public:
> >>>>>>    */
> >>>>>>  };
> >>>>>>  
> >>>>>> -class sys_var_sync_binlog_period :public sys_var_long_ptr
> >>>>>> +class sys_var_sync_binlog_period :public sys_var_int_ptr
> >>>>>>  {
> >>>>>>  public:
> >>>>>> -  sys_var_sync_binlog_period(const char *name_arg, ulong
> *value_ptr_arg)
> >>>>>> -    :sys_var_long_ptr(name_arg,value_ptr_arg) {}
> >>>>>> +  sys_var_sync_binlog_period(const char *name_arg, uint
> *value_ptr_arg)
> >>>>>> +    :sys_var_int_ptr(name_arg,value_ptr_arg) {}
> >>>>>>    bool update(THD *thd, set_var *var);
> >>>>>>  };
> >>>>>>  #endif
> >>>>>>
> >>>>>> === modified file 'sql/slave.cc'
> >>>>>> --- a/sql/slave.cc	2008-03-28 20:01:05 +0000
> >>>>>> +++ b/sql/slave.cc	2008-10-27 15:09:43 +0000
> >>>>>> @@ -66,6 +66,7 @@ static bool wait_for_relay_log_space(REL
> >>>>>>  static inline bool io_slave_killed(THD* thd,MASTER_INFO*
> mi);
> >>>>>>  static inline bool sql_slave_killed(THD*
> thd,RELAY_LOG_INFO* rli);
> >>>>>>  static int count_relay_log_space(RELAY_LOG_INFO* rli);
> >>>>>> +static int init_recovery(MASTER_INFO* mi);
> >>>>>>  static int init_slave_thread(THD* thd, SLAVE_THD_TYPE
> thd_type);
> >>>>>>  static int safe_connect(THD* thd, MYSQL* mysql,
> MASTER_INFO* mi);
> >>>>>>  static int safe_reconnect(THD* thd, MYSQL* mysql,
> MASTER_INFO* mi,
> >>>>>> @@ -174,6 +175,9 @@ int init_slave()
> >>>>>>    if (server_id && !master_host &&
> active_mi->host[0])
> >>>>>>      master_host= active_mi->host;
> >>>>>>  
> >>>>>> +  if (init_recovery(active_mi))
> >>>>>> +    goto err;
> >>>>>> +
> >>>>>>    /* If server id is not set, start_slave_thread() will say
> it */
> >>>>>>  
> >>>>>>    if (master_host && !opt_skip_slave_start)
> >>>>>> @@ -197,6 +201,48 @@ err:
> >>>>>>    DBUG_RETURN(1);
> >>>>>>  }
> >>>>>>  
> >>>>>> +static int init_recovery(MASTER_INFO* mi)
> >>>>>> +{
> >>>>>> +  const char* errmsg=0;
> >>>>>> +  DBUG_ENTER("recovery_init");
> >>>>>> +
> >>>>>>     
> >>>>>>         
> >>>>>>             
> >>>>> A typo, should be "init_recovery"
> >>>>>   
> >>>>>       
> >>>>>           
> >>>> done in my own tree.
> >>>>     
> >>>>         
> >>>>>   
> >>>>>       
> >>>>>           
> >>>>>> +  RELAY_LOG_INFO* rli = &mi->rli;
> >>>>>> +  if (relay_log_throw &&
> rli->group_master_log_name[0])
> >>>>>> +  {
> >>>>>> +    mi->master_log_pos = max(BIN_LOG_HEADER_SIZE,
> >>>>>> +                             
> rli->group_master_log_pos);
> >>>>>> +    strmake(mi->master_log_name,
> rli->group_master_log_name,
> >>>>>> +      sizeof(mi->master_log_name)-1);
> >>>>>> +
> >>>>>> +    strmake(rli->group_relay_log_name,
> rli->relay_log.get_log_fname(),
> >>>>>> +            sizeof(rli->group_relay_log_name)-1);
> >>>>>> +    strmake(rli->event_relay_log_name,
> rli->relay_log.get_log_fname(),
> >>>>>> +            sizeof(mi->rli.event_relay_log_name)-1);
> >>>>>> +
> >>>>>> +    rli->group_relay_log_pos =
> rli->group_relay_log_pos = BIN_LOG_HEADER_SIZE;
> >>>>>> +
> >>>>>> +    if (init_relay_log_pos(rli,
> >>>>>> +                           rli->group_relay_log_name,
> >>>>>> +                           rli->group_relay_log_pos,
> >>>>>> +                           0 /*no data lock*/,
> >>>>>> +                           &errmsg, 0))
> >>>>>> +      DBUG_RETURN(1);
> >>>>>> +
> >>>>>> +    if (flush_master_info(mi, 0))
> >>>>>> +    {
> >>>>>> +      sql_print_error("Failed to flush master info file");
> >>>>>> +      DBUG_RETURN(1);
> >>>>>> +    }
> >>>>>> +    if (flush_relay_log_info(rli))
> >>>>>> +    {
> >>>>>> +       sql_print_error("Failed to flush master info
> file");
> >>>>>> +       DBUG_RETURN(1);
> >>>>>> +    }
> >>>>>>     
> >>>>>>         
> >>>>>>             
> >>>>> I think you need to purge the discarded relay-log files here.
> >>>>>   
> >>>>>       
> >>>>>           
> >>>> Eventually, it will be discarded in the next call to the purge
> method.
> >>>> At this point I don't have a reference to a THD which is required to
> call
> >>>> the purge method.
> >>>>     
> >>>>         
> >>>>>   
> >>>>>       
> >>>>>           
> >>>>>> +  }
> >>>>>> +
> >>>>>> +  DBUG_RETURN(0);
> >>>>>> +}
> >>>>>> +
> >>>>>>  
> >>>>>>  static void free_table_ent(TABLE_RULE_ENT* e)
> >>>>>>  {
> >>>>>> @@ -2582,6 +2628,7 @@ int flush_master_info(MASTER_INFO* mi,
> b
> >>>>>>  {
> >>>>>>    IO_CACHE* file = &mi->file;
> >>>>>>    char lbuf[22];
> >>>>>> +  int err= 0;
> >>>>>>    DBUG_ENTER("flush_master_info");
> >>>>>>    DBUG_PRINT("enter",("master_pos: %ld", (long)
> mi->master_log_pos));
> >>>>>>  
> >>>>>> @@ -2597,9 +2644,12 @@ int flush_master_info(MASTER_INFO*
> mi, b
> >>>>>>      When we come to this place in code, relay log may or
> not be initialized;
> >>>>>>      the caller is responsible for setting
> 'flush_relay_log_cache' accordingly.
> >>>>>>    */
> >>>>>> -  if (flush_relay_log_cache &&
> >>>>>> -      flush_io_cache(mi->rli.relay_log.get_log_file()))
> >>>>>> -    DBUG_RETURN(2);
> >>>>>> +  if (flush_relay_log_cache)
> >>>>>> +  {
> >>>>>> +    IO_CACHE *log_file=
> mi->rli.relay_log.get_log_file();
> >>>>>> +    if (flush_io_cache(log_file))
> >>>>>> +      DBUG_RETURN(2);
> >>>>>> +  }
> >>>>>>  
> >>>>>>    /*
> >>>>>>      We flushed the relay log BEFORE the master.info file,
> because if we crash
> >>>>>> @@ -2626,12 +2676,21 @@ int flush_master_info(MASTER_INFO*
> mi, b
> >>>>>>  	      mi->password, mi->port, mi->connect_retry,
> >>>>>>                (int)(mi->ssl), mi->ssl_ca,
> mi->ssl_capath, mi->ssl_cert,
> >>>>>>                mi->ssl_cipher, mi->ssl_key);
> >>>>>> -  DBUG_RETURN(-flush_io_cache(file));
> >>>>>> +  err= flush_io_cache(file);
> >>>>>> +  static unsigned int count=1;
> >>>>>> +  if (sync_relaylog_period && !err && count
> > sync_relaylog_period)
> >>>>>> +  {
> >>>>>> +    err= my_sync(mi->fd, MYF(MY_WME));
> >>>>>> +    count= 1;
> >>>>>> +  }
> >>>>>> +  count++;
> >>>>>> +  DBUG_RETURN(-err);
> >>>>>>  }
> >>>>>>  
> >>>>>>
> >>>>>>  st_relay_log_info::st_relay_log_info()
> >>>>>> -  :info_fd(-1), cur_log_fd(-1), save_temporary_tables(0),
> >>>>>> +  :info_fd(-1), cur_log_fd(-1),
> relay_log(&sync_relaylog_period),
> >>>>>> +   save_temporary_tables(0),
> >>>>>>     cur_log_old_open_count(0), group_master_log_pos(0),
> log_space_total(0),
> >>>>>>     ignore_log_space_limit(0), last_master_timestamp(0),
> slave_skip_counter(0),
> >>>>>>     abort_pos_wait(0), slave_run_id(0), sql_thd(0),
> last_slave_errno(0),
> >>>>>> @@ -4872,6 +4931,14 @@ bool
> flush_relay_log_info(RELAY_LOG_INFO
> >>>>>>      error=1;
> >>>>>>    if (flush_io_cache(file))
> >>>>>>      error=1;
> >>>>>> +  static unsigned int count= 1;
> >>>>>> +  if (sync_relaylog_period &&
> >>>>>> +      !error)
> >>>>>> +  {
> >>>>>> +    if (my_sync(rli->info_fd, MYF(MY_WME)))
> >>>>>> +      error=1;
> >>>>>> +  }
> >>>>>> +  count++;
> >>>>>>    /* Flushing the relay log is done by the slave I/O thread
> */
> >>>>>>    return error;
> >>>>>>  }
> >>>>>>
> >>>>>> === modified file 'sql/sql_class.h'
> >>>>>> --- a/sql/sql_class.h	2008-09-17 06:34:00 +0000
> >>>>>> +++ b/sql/sql_class.h	2008-10-27 15:09:43 +0000
> >>>>>> @@ -238,6 +238,18 @@ class MYSQL_LOG: public TC_LOG
> >>>>>>    bool no_auto_events;
> >>>>>>    friend class Log_event;
> >>>>>>  
> >>>>>> +  /* pointer to the sync period variable, for binlog this
> will be
> >>>>>> +     sync_binlog_period, for relay log this will be
> >>>>>> +     sync_relay_log_period
> >>>>>> +  */
> >>>>>> +  uint *sync_period_ptr;
> >>>>>> +  uint sync_counter;
> >>>>>> +
> >>>>>> +  inline uint get_sync_period()
> >>>>>> +  {
> >>>>>> +    return *sync_period_ptr;
> >>>>>> +  }
> >>>>>> +
> >>>>>>  public:
> >>>>>>    /*
> >>>>>>      These describe the log's format. This is used only for
> relay logs.
> >>>>>> @@ -250,7 +262,7 @@ public:
> >>>>>>    Format_description_log_event
> *description_event_for_exec,
> >>>>>>      *description_event_for_queue;
> >>>>>>  
> >>>>>> -  MYSQL_LOG();
> >>>>>> +  MYSQL_LOG(uint *sync_period=0);
> >>>>>>    /*
> >>>>>>      note that there's no destructor ~MYSQL_LOG() !
> >>>>>>      The reason is that we don't want it to be automatically
> called
> >>>>>>
> >>>>>>     
> >>>>>>         
> >>>>>>             
> >>>>>   
> >>>>>       
> >>>>>           
> >>>>     
> >>>>         
> >>>   
> >>>       
> >
> >
> >   

Thread
bzr commit into mysql-5.0-bugteam branch (alfranio.correia:2704) Bug#31665Bug#35542 Bug#40337Alfranio Correia27 Oct
  • Re: bzr commit into mysql-5.0-bugteam branch(alfranio.correia:2704) Bug#31665 Bug#35542 Bug#40337He Zhenxing28 Oct
    • Re: bzr commit into mysql-5.0-bugteam branch (alfranio.correia:2704)Bug#31665 Bug#35542 Bug#40337alfranio correia28 Oct
      • Re: bzr commit into mysql-5.0-bugteambranch (alfranio.correia:2704) Bug#31665 Bug#35542 Bug#40337He Zhenxing29 Oct
        • Re: bzr commit into mysql-5.0-bugteam branch (alfranio.correia:2704)Bug#31665 Bug#35542 Bug#40337alfranio correia29 Oct
          • Re: bzr commit intomysql-5.0-bugteam branch (alfranio.correia:2704) Bug#31665 Bug#35542Bug#40337He Zhenxing29 Oct
            • Re: bzr commit into mysql-5.0-bugteam branch (alfranio.correia:2704)Bug#31665 Bug#35542 Bug#40337alfranio correia29 Oct
              • Re: bzr commitinto mysql-5.0-bugteam branch (alfranio.correia:2704) Bug#31665Bug#35542 Bug#40337He Zhenxing29 Oct