数据库内核月报 － 2020 / 08

/**
  @brief
  Enable or Disable SE write ahead logging.

  @param[in] thd    server thread handle
  @param[in] enable enable/disable redo logging

  @return true iff failed.
*/
typedef bool (*redo_log_set_state_t)(THD *thd, bool enable);

struct handlerton {
  ...
  redo_log_set_state_t redo_log_set_state;
  ...
}

mysql_parse
  mysql_execute_command
    Sql_cmd_alter_instance::execute
      // case ALTER_INSTANCE_ENABLE_INNODB_REDO
      // 或者 case ALTER_INSTANCE_DISABLE_INNODB_REDO
      Innodb_redo_log::execute
        /*
          Acquire shared backup lock to block concurrent backup. Acquire exclusive
          backup lock to block any concurrent DDL. This would also serialize any
          concurrent key rotation and other redo log enable/disable calls.
        */
        // 通过mdl锁阻止并发
        if (acquire_exclusive_backup_lock(m_thd, m_thd->variables.lock_wait_timeout,
                                          true) ||
            acquire_shared_backup_lock(m_thd, m_thd->variables.lock_wait_timeout)) {
          DBUG_ASSERT(m_thd->get_stmt_da()->is_error());
          return true;
        }
        hton->redo_log_set_state(m_thd, m_enable)

static bool innobase_redo_set_state(THD *thd, bool enable) {
  if (srv_read_only_mode) {
    my_error(ER_INNODB_READ_ONLY, MYF(0));
    return (true);
  }

  int err = 0;

  if (enable) {
    err = mtr_t::s_logging.enable(thd); // 开启redo
  } else {
    err = mtr_t::s_logging.disable(thd); // 关闭redo
  }

  if (err != 0) {
    return (true);
  }

  // 设置global status
  set_srv_redo_log(enable);
  return (false);
}

int mtr_t::Logging::disable(THD *) {
  // 检查是否已经是DISABLED状态
  if (is_disabled()) {
    return (0);
  }

  /* Disallow archiving to start. */
  ut_ad(m_state.load() == ENABLED);
  m_state.store(ENABLED_RESTRICT);

  /* Check if redo log archiving is active. */
  // 检查是否有redo archive正在进行
  if (meb::redo_log_archive_is_active()) {
    m_state.store(ENABLED);
    my_error(ER_INNODB_REDO_ARCHIVING_ENABLED, MYF(0));
    return (ER_INNODB_REDO_ARCHIVING_ENABLED);
  }

  /* Concurrent clone is blocked by BACKUP MDL lock except when
  clone_ddl_timeout = 0. Force any existing clone to abort. */
  // 停止clone功能
  clone_mark_abort(true);
  ut_ad(!clone_check_active());

  /* Mark that it is unsafe to crash going forward. */
  // 设置redolog的m_disable和m_crash_unsafe标志位
  // 内部调用log_files_header_fill将标志位持久化
  log_persist_disable(*log_sys);

  ib::warn(ER_IB_WRN_REDO_DISABLED);
  m_state.store(DISABLED);

  clone_mark_active();

  /* Reset sync LSN if beyond current system LSN. */
  reset_buf_flush_sync_lsn();

  return (0);
}

int mtr_t::Logging::enable(THD *thd) {
  if (is_enabled()) {
    return (0);
  }
  /* Allow mtrs to generate redo log. Concurrent clone and redo
  log archiving is still restricted till we reach a recoverable state. */
  ut_ad(m_state.load() == DISABLED);
  m_state.store(ENABLED_RESTRICT);

  /* 1. Wait for all no-log mtrs to finish and add dirty pages to disk.*/
  // 等待m_count_nologging_mtr计数器为0或者thd被kill
  auto err = wait_no_log_mtr(thd);
  if (err != 0) {
    m_state.store(DISABLED);
    return (err);
  }

  /* 2. Wait for dirty pages to flush by forcing checkpoint at current LSN.
  All no-logging page modification are done with the LSN when we stopped
  redo logging. We need to have one write mini-transaction after enabling redo
  to progress the system LSN and take a checkpoint. An easy way is to flush
  the max transaction ID which is generally done at TRX_SYS_TRX_ID_WRITE_MARGIN
  interval but safe to do any time. */
  trx_sys_mutex_enter();
  // 通过更新trx_id的接口生成一个mtr，目的是提供一个lsn推进的位点
  trx_sys_flush_max_trx_id();
  trx_sys_mutex_exit();

  /* It would ensure that the modified page in previous mtr and all other
  pages modified before are flushed to disk. Since there could be large
  number of left over pages from LAD operation, we still don't enable
  double-write at this stage. */
  // 不开double-write的状态checkpoint到最新的lsn
  log_make_latest_checkpoint(*log_sys);
  m_state.store(ENABLED_DBLWR);

  /* 3. Take another checkpoint after enabling double write to ensure any page
  being written without double write are already synced to disk. */
  // 再次checkpoint到最新的lsn
  log_make_latest_checkpoint(*log_sys);

  /* 4. Mark that it is safe to recover from crash. */
  // 设回m_disable和m_crash_unsafe标志位，并持久化
  log_persist_enable(*log_sys);

  ib::warn(ER_IB_WRN_REDO_ENABLED);
  m_state.store(ENABLED);

  return (0);
}

bool dblwr_disabled() const {
  auto state = m_state.load();
  return (state == DISABLED || state == ENABLED_RESTRICT);
}
bool is_enabled() const { return (m_state.load() == ENABLED); }
bool is_disabled() const { return (m_state.load() == DISABLED); }

ulint page_recommendation(ulint last_pages_in, bool is_sync_flush) {
  ...
  /* Set page flush target based on LSN. */
  auto n_pages = skip_lsn ? 0 : set_flush_target_by_lsn(is_sync_flush);

  /* Estimate based on only dirty pages. We don't want to flush at lesser rate
  as LSN based estimate may not represent the right picture for modifications
  without redo logging - temp tables, bulk load and global redo off. */
  n_pages = set_flush_target_by_page(n_pages);
  ...
}