MySQL redo log恢复原理 | StoneDB技术分享会 #5

  recv_recovery_from_checkpoint_start(*log_sys, flushed_lsn);
    // 每个ib_logfile文件有2KB的header，在header的第2个log block和第4个log block中的8字节偏移量处分别存有checkpoint1和checkpoint2
    // 当checkpoint_no为偶数时，写入checkpoint1，为奇数时，写入checkpoint2
    // 遍历所有的ib_logfile文件，分别从其header中取出两个checkpoint lsn，取最大值返回
    // note: 其实在第一个ib_logfile中寻找checkpoint lsn即可，因为做checkpoint的时候只会往第一个ib_logfile中写入
    Log_checkpoint_location checkpoint;
    recv_find_max_checkpoint(log, checkpoint)

    // 从checkpoint lsn开始解析redo log并且apply
    recv_recovery_begin
      recv_read_log_seg
      recv_scan_log_recs
        recv_parse_log_recs
          recv_single_rec
            recv_parse_log_rec
              mlog_parse_initial_log_record
              recv_parse_or_apply_log_rec_body
          recv_multi_rec
            recv_parse_log_rec
              mlog_parse_initial_log_record
              recv_parse_or_apply_log_rec_body

  // 将哈希表中的redo log进行重放
  recv_apply_hashed_log_recs

  // 初始化recv_sys
  recv_sys->len = 0;
  ...

  // checkpoint_lsn向下向512KB对齐
  lsn_t start_lsn = ut_uint64_align_down(checkpoint_lsn, OS_FILE_LOG_BLOCK_SIZE);

  bool finished = false;

  // 循环读取ib_logfile中的内容到
  while (!finished) {
    // 读取从start_lsn开始的64KB的数据到log.buf中
    const lsn_t end_lsn =
        recv_read_log_seg(log, log.buf, start_lsn, start_lsn + RECV_SCAN_SIZE);

    if (end_lsn == start_lsn) {
      /* This could happen if we crashed just after completing file,
      and before next file has been successfully created. */
      break;
    }

    dberr_t err;

    finished = recv_scan_log_recs(log, max_mem, log.buf, end_lsn - start_lsn,
                                  start_lsn, &log.m_scanned_lsn, err);

    if (err != DB_SUCCESS) {
      return err;
    }

    start_lsn = end_lsn;
  }

  return DB_SUCCESS;
}

  // 找到start_lsn所在的ib_logfile文件
  auto file = log.m_files.find(start_lsn);

  if (file == log.m_files.end()) {
    /* Missing valid file ! */
    return start_lsn;
  }

  do {

    os_offset_t source_offset;

    // 计算start_lsn在ib_logfile文件中的偏移量
    // LOG_FILE_HDR_SIZE + (lsn - file_start_lsn);
    source_offset = file->offset(start_lsn);

    os_offset_t len = end_lsn - start_lsn;

    bool switch_to_next_file = false;

    if (source_offset + len > file->m_size_in_bytes) {
      len = file->m_size_in_bytes - source_offset;
      switch_to_next_file = true;
    }

    // 读取文件
    const dberr_t err =
        log_data_blocks_read(file_handle, source_offset, len, buf);

    start_lsn += len;
    buf += len;

    if (switch_to_next_file) {

      // 切换到下一个文件
      ...

    }

  } while (start_lsn != end_lsn);

  return end_lsn;
}

// 每个ib_logfile文件的header中记录有该文件起始的file_start_lsn
os_offset_t offset(lsn_t lsn)
  os_offset_t offset(lsn_t lsn, lsn_t file_start_lsn)
    return LOG_FILE_HDR_SIZE + (lsn - file_start_lsn);

  /** Offset up to which this block has data inside, computed from the
  beginning of the block. */
  // 该log block中前m_data_len个字节是有内容的
  uint16_t m_data_len;

  /** Offset to the first mtr starting in this block, or 0 if there is no
  mtr starting in this block. */
  // 该log block中第一个从该block中开始的mtr的起始位置
  uint16_t m_first_rec_group;
};

static bool recv_scan_log_recs(log_t &log,
                               size_t max_memory, const byte *buf, size_t len,
                               lsn_t start_lsn, lsn_t *read_upto_lsn,
                               dberr_t &err) {

  const byte *log_block = buf;
  lsn_t scanned_lsn = start_lsn;
  bool finished = false;
  bool more_data = false;

  // 每个log block有header和trail，导致跨block的日志是不连续的，不能直接解析
  // 所以需要先将每个block的header和trail去掉，将所有block的主体内容拼起来
  do {

    // 解析log block header
    Log_data_block_header block_header;
    log_data_block_header_deserialize(log_block, block_header);

    ...

    const auto data_len = block_header.m_data_len;

    ...

    // 如果解析redo log的起点位置还没确定并且存在mtr从该block中开始，就确定解析的起点
    if (!recv_sys->parse_start_lsn && block_header.m_first_rec_group > 0) {

      recv_sys->parse_start_lsn = scanned_lsn + block_header.m_first_rec_group;

      if (recv_sys->parse_start_lsn checkpoint_lsn) {
        recv_sys->bytes_to_ignore_before_checkpoint =
            recv_sys->checkpoint_lsn - recv_sys->parse_start_lsn;
      }

      recv_sys->scanned_lsn = recv_sys->parse_start_lsn;
      recv_sys->recovered_lsn = recv_sys->parse_start_lsn;
    }

    scanned_lsn += data_len;

    if (scanned_lsn > recv_sys->scanned_lsn) {

      // buf空间不够用，扩容
      if (recv_sys->len + 4 * OS_FILE_LOG_BLOCK_SIZE >= recv_sys->buf_len) {
        recv_sys_resize_buf();
      }

      if (!recv_sys->found_corrupt_log) {
        // 将该log block去掉header和trail后接到recv_sys->buf的尾部
        more_data = recv_sys_add_to_parsing_buf(log_block, scanned_lsn);
      }

      recv_sys->scanned_lsn = scanned_lsn;
    }

    // 该log block没有满，那么解析redo log的终点就是这个block
    if (data_len recovered_offset > recv_sys->buf_len / 4) {
      /* Move parsing buffer data to the buffer start */

      recv_reset_buffer();
    }

  }

  return finished;
}

  // 解析redo log以mtr为基本单位
  for (;;) {
    byte *ptr = recv_sys->buf + recv_sys->recovered_offset;

    byte *end_ptr = recv_sys->buf + recv_sys->len;

    if (ptr == end_ptr) {
      return;
    }

    bool single_rec;

    switch (*ptr) {
      case MLOG_DUMMY_RECORD:
        single_rec = true;
        break;
      default:
        // 解析Type最高位的标志位，看该mtr是由单条redo log构成还是多条redo log构成
        single_rec = !!(*ptr & MLOG_SINGLE_REC_FLAG);
    }

    if (single_rec) {
      if (recv_single_rec(ptr, end_ptr)) { // 单条redo log构成的mtr的解析入口
        return;
      }

    } else if (recv_multi_rec(ptr, end_ptr)) { // 多条redo log构成的mtr的解析入口
      return;
    }
  }
}

  lsn_t old_lsn = recv_sys->recovered_lsn;

  byte *body;
  mlog_id_t type;
  page_no_t page_no;
  space_id_t space_id;

  // 解析单条redo log
  ulint len =
      recv_parse_log_rec(&type, ptr, end_ptr, &space_id, &page_no, &body);

  lsn_t new_recovered_lsn;

  new_recovered_lsn = recv_calc_lsn_on_data_add(old_lsn, len);

  if (new_recovered_lsn > recv_sys->scanned_lsn) {
    /* The log record filled a log block, and we
    require that also the next log block should
    have been scanned in */

    return true;
  }

  ...

  recv_sys->recovered_offset += len;
  recv_sys->recovered_lsn = new_recovered_lsn;

  if (recv_recovery_on) {

    // 将redo log加入到哈希表中
    // 不直接重放的原因是可能会有很多redo log作用在同一个page上，将这些redo log使用一次IO进行重放，可以加快重放的速度
    // 哈希表包括两层，第一层以space_id为key，第二层以page_no为key
    recv_add_to_hash_table(type, space_id, page_no, body, ptr + len,
                                 old_lsn, recv_sys->recovered_lsn);

  }

  return false;
}

  ulint n_recs = 0;
  ulint total_len = 0;

  // 先找到mtr的终点，即MLOG_MULTI_REC_END类型的记录
  for (;;) {
    mlog_id_t type = MLOG_BIGGEST_TYPE;
    byte *body;
    page_no_t page_no = 0;
    space_id_t space_id = 0;

    ulint len =
        recv_parse_log_rec(&type, ptr, end_ptr, &space_id, &page_no, &body);

    // 将部分解析的redo log缓存起来
    recv_sys->save_rec(n_recs, space_id, page_no, type, body, len);

    total_len += len;
    ++n_recs;

    ptr += len;

    if (type == MLOG_MULTI_REC_END) {
      break;
    }
  }

  lsn_t new_recovered_lsn =
      recv_calc_lsn_on_data_add(recv_sys->recovered_lsn, total_len);

  // 重置ptr的位置，开始扫第二遍
  ptr = recv_sys->buf + recv_sys->recovered_offset;

  for (ulint i = 0; i recovered_lsn;

    space_id_t space_id = 0;
    page_no_t page_no = 0;

    mlog_id_t type = MLOG_BIGGEST_TYPE;

    byte *body = nullptr;
    size_t len = 0;

    // 从第一遍扫的缓存中取出一条redo log
    recv_sys->get_saved_rec(i, space_id, page_no, type, body, len);

    recv_sys->recovered_offset += len;

    recv_sys->recovered_lsn = recv_calc_lsn_on_data_add(old_lsn, len);

    if (recv_recovery_on) {
      // 将redo log加入到哈希表中
      recv_add_to_hash_table(type, space_id, page_no, body, ptr + len,
                                   old_lsn, new_recovered_lsn);
    }

    ptr += len;
  }

  return false;
}

  byte *new_ptr;

  *body = nullptr;

  switch (*ptr) {
    case MLOG_MULTI_REC_END:
    case MLOG_DUMMY_RECORD:
      *page_no = FIL_NULL;
      *space_id = SPACE_UNKNOWN;
      *type = static_cast(*ptr);
      return 1;

    ...
  }

  // 解析Type、Space ID、Page Number
  new_ptr =
      mlog_parse_initial_log_record(ptr, end_ptr, type, space_id, page_no);

  *body = new_ptr;

  if (new_ptr == nullptr) {
    return 0;
  }

  // 解析body部分
  new_ptr = recv_parse_or_apply_log_rec_body(
      *type, new_ptr, end_ptr, *space_id, *page_no, nullptr, nullptr,
      new_ptr - ptr, recv_sys->recovered_lsn);

  if (new_ptr == nullptr) {
    return 0;
  }

  return new_ptr - ptr;
}

    i = DATA_ROLL_PTR - 1 + n_uniq;
    ind->fields[i].col = &table->cols[n + DATA_ROLL_PTR];
    ind->fields[i].col->set_phy_pos(table->cols[i].get_phy_pos());
  }

  return ptr;
}