1. 22 Feb, 2008 1 commit
    • svoj@mysql.com/june.mysql.com's avatar
      BUG#13861 - START SLAVE UNTIL may stop 1 evnt too late if · fe3b1c8e
      svoj@mysql.com/june.mysql.com authored
                  log-slave-updates and circul repl
      
      Slave SQL thread may execute one extra event when there are events
      skipped by slave I/O thread (e.g. originated by the same server).
      Whereas it was requested not to do so by the UNTIL condition.
      
      This happens because we compare with the end position of previously
      executed event. This is fine when there are no skipped by slave I/O
      thread events, as end position of previous event equals to start
      position of to be executed event. Otherwise this position equals to
      start position of skipped event.
      
      This is fixed by:
      - reading the event to be executed before checking if the until condition
        is satisfied.
      - comparing the start position of the event to be executed. Since we do
        not have the start position available, we compute it by subtracting
        event length from end position (which is available).
      - if there are no events on the event queue at the slave sql starting
        time, that meet until condition, we stop immediately, as in this
        case we do not want to wait for next event.
      fe3b1c8e
  2. 15 Feb, 2008 1 commit
  3. 14 Feb, 2008 4 commits
  4. 12 Feb, 2008 1 commit
  5. 11 Feb, 2008 3 commits
  6. 08 Feb, 2008 2 commits
  7. 07 Feb, 2008 2 commits
  8. 06 Feb, 2008 2 commits
  9. 05 Feb, 2008 1 commit
    • aelkin/elkin@koti.dsl.inet.fi's avatar
      Bug #34305 show slave status handling segfaults when slave io is about · 51b33ea3
      aelkin/elkin@koti.dsl.inet.fi authored
          to leave
      
      The artifact was caused by
      a flaw in concurrent accessing the slave's io thd by
      the io itself and a handling show slave status thread.
      Namely, show_master_info did not acquire mi->run_lock mutex that is
      specified for mi->io_thd member.
      
      Fixed with deploying the mutex locking and unlocking. The mutex is kept
      short time and without interleaving with mi->data_lock mutex.
      
      Todo: to report and fix an issue with 
          sys_var_slave_skip_counter::{methods} 
      seem to acquire incorrectly
           active_mi->rli.run_lock
      instead of the specified
           active_mi->rli.data_lock
      
      A test case is difficult to compose, so rpl_packet should continue serving
      as the indicator.
      51b33ea3
  10. 04 Feb, 2008 2 commits
  11. 01 Feb, 2008 6 commits
  12. 31 Jan, 2008 4 commits
  13. 30 Jan, 2008 4 commits
  14. 29 Jan, 2008 3 commits
    • hezx@mail.hezx.com's avatar
      update test result · 7572a9e3
      hezx@mail.hezx.com authored
      7572a9e3
    • istruewing@stella.local's avatar
      Merge stella.local:/home2/mydev/mysql-5.0-amain · 252dcbe8
      istruewing@stella.local authored
      into  stella.local:/home2/mydev/mysql-5.0-axmrg
      252dcbe8
    • hezx@mail.hezx.com's avatar
      BUG#26489 Corruption in relay logs · e4f37eab
      hezx@mail.hezx.com authored
      Here is the scenario that causes the failure.(by Mats)
      
      1. The to-be corrupt log event (let's call it X), is split into two
         packets B and C on the network level (net_write_buff()). The parts
         are X = (x',x''). The part x' ends up in packet B and part x''
         ends up in packet C. Prior to the corrupt event X, the event Y has
         been written successfully, but has been split into two packets as
         well, which we call (y',y'').
      2. The master sends packet A = (y'',x') to the slave, increases the
         packet sequence number, the slave receives the packet, but fails
         to reply before the master gets a timeout.
      3. Since the master got a timeout, it reports failure, and aborts
         sending the binary log by exiting mysql_binlog_send(). However, it
         leaves the buffer intact, still holding y'' (but not x', since the
         write_pos is not increased).
      4. After exiting mysql_binlog_send(), the master does a
         disconnection of the client thread, which involves sending an
         error message e to the client (i.e., the slave).
      5. In this case, net_write_buff() is used again, but this time the
         old contents of the packet is used so that the new packet is
         D = (y'',e). Note that this will use a new packet sequence number,
         since the packet number was increased in step 2.
      6. The slave receives the tail y'' of the Y log event, concatenates
         this with x' (which it already received), and writes the event
         (x',y'') it to the relay log since it hasn't noticed anything is
         amiss.
      7. It then tries to read more bytes, which is either e (if the length
         given for X just happened to match the length given for Y, or just
         plain garbage because the slave is out of sync with what is
         actually sent.
      8. After a while, the SQL thread tries to execute the event (x',y''),
         which is very likely to be just nonsense.
      
      The problem can be fixed by not resetting net->error after the call of 
      mysql_binlog_send, so the error message will not be sent and the connection
      will be closed.
      e4f37eab
  15. 27 Jan, 2008 1 commit
  16. 25 Jan, 2008 3 commits