MDEV-36301: Introduce innodb_log_file_disabled

The InnoDB log may be disabled by executing
SET GLOBAL innodb_log_file_disabled=ON;
in order to speed up any bulk operations, such as setting up a replica.
After the execution of
SET GLOBAL innodb_log_file_disabled=OFF;
has completed (and InnoDB has written a log checkpoint to the newly
enabled log), the server should be crash-safe again.

log_sys.buf_size_requested: The configured innodb_log_buffer_size.
While the log is disabled, we may set log_sys.buf_size (the actual size)
differently.

log_sys.disabled: The current setting of innodb_log_file_disabled.

log_t::attach(): Handle log_sys.disabled.

log_t::disabled(): Implements SET innodb_log_file_disabled=ON.
Even if the log used to be in persistent memory, here we will
set up dummy log_sys.buf and log_sys.flush_buf so that the dummy
writes will appear to use file based writes.

log_t::skip_write_buf(): A dummy log writer implementation that is
used when log_sys.disabled holds and the log is not being resized.

log_t::resize_start(): Handle log_sys.disabled, that is,
SET GLOBAL innodb_log_file_disabled=OFF when the redo log had
previously been disabled.  If we are on persistent memory,
we will "fake" the dummy log_sys.buf to appear as memory-mapped
as well, so that log_t::resize_write() and log_t::resize_write_buf()
can assume that both log files are of the same type (memory-mapped
or file-based).  The dummy log_sys.flush_buf will be stored in
log_sys.resize_flush_buf in that case.

Author: dr-m

extra/mariabackup/xtrabackup.cc

@@ -1887,8 +1887,8 @@ struct my_option xb_server_options[] =
 
   {"innodb_log_buffer_size", OPT_INNODB_LOG_BUFFER_SIZE,
    "Redo log buffer size in bytes.",
-   (G_PTR*) &log_sys.buf_size, (G_PTR*) &log_sys.buf_size, 0,
-   GET_UINT, REQUIRED_ARG, 2U << 20,
+   (G_PTR*) &log_sys.buf_size_requested, (G_PTR*) &log_sys.buf_size_requested,
+   0, GET_UINT, REQUIRED_ARG, 2U << 20,
    2U << 20, log_sys.buf_size_max, 0, 4096, 0},
   {"innodb_log_file_mmap", OPT_INNODB_LOG_FILE_SIZE,
    "Whether ib_logfile0 should be memory-mapped",

mysql-test/suite/innodb/r/log_file_disabled.result

@@ -0,0 +1,16 @@
+# restart: --innodb-log-group-home-dir=MYSQLTEST_VARDIR/tmp/log --innodb-data-home-dir=MYSQLTEST_VARDIR/tmp/log --innodb-log-file-disabled
+SELECT * FROM INFORMATION_SCHEMA.ENGINES
+WHERE engine = 'innodb'
+AND support IN ('YES', 'DEFAULT', 'ENABLED');
+ENGINE	SUPPORT	COMMENT	TRANSACTIONS	XA	SAVEPOINTS
+InnoDB	YES	Supports transactions, row-level locking, foreign keys and encryption for tables	YES	YES	YES
+# restart: --innodb-log-group-home-dir=MYSQLTEST_VARDIR/tmp/log --innodb-data-home-dir=MYSQLTEST_VARDIR/tmp/log
+SET GLOBAL innodb_log_file_disabled=OFF;
+CREATE TABLE t ENGINE=InnoDB SELECT 1;
+SET GLOBAL innodb_log_file_disabled=ON;
+# restart: --innodb-log-group-home-dir=MYSQLTEST_VARDIR/tmp/log --innodb-data-home-dir=MYSQLTEST_VARDIR/tmp/log
+SELECT * FROM t;
+1
+1
+DROP TABLE t;
+# restart

mysql-test/suite/innodb/t/log_file_disabled.test

@@ -0,0 +1,26 @@
+--source include/have_innodb.inc
+
+let $bugdir= $MYSQLTEST_VARDIR/tmp/log;
+--mkdir $bugdir
+let $check_no_innodb=SELECT * FROM INFORMATION_SCHEMA.ENGINES
+WHERE engine = 'innodb'
+AND support IN ('YES', 'DEFAULT', 'ENABLED');
+
+--let $ibp=--innodb-log-group-home-dir=$bugdir --innodb-data-home-dir=$bugdir
+
+--let $restart_parameters= $ibp --innodb-log-file-disabled
+--source include/restart_mysqld.inc
+eval $check_no_innodb;
+--rmdir $bugdir
+--mkdir $bugdir
+--let $restart_parameters= $ibp
+--source include/restart_mysqld.inc
+SET GLOBAL innodb_log_file_disabled=OFF;
+CREATE TABLE t ENGINE=InnoDB SELECT 1;
+SET GLOBAL innodb_log_file_disabled=ON;
+--source include/restart_mysqld.inc
+SELECT * FROM t;
+DROP TABLE t;
+--let $restart_parameters=
+--source include/restart_mysqld.inc
+--rmdir $bugdir

mysql-test/suite/sys_vars/r/sysvars_innodb.result

@@ -1051,6 +1051,18 @@ NUMERIC_BLOCK_SIZE	NULL
 ENUM_VALUE_LIST	OFF,ON
 READ_ONLY	NO
 COMMAND_LINE_ARGUMENT	OPTIONAL
+VARIABLE_NAME	INNODB_LOG_FILE_DISABLED
+SESSION_VALUE	NULL
+DEFAULT_VALUE	OFF
+VARIABLE_SCOPE	GLOBAL
+VARIABLE_TYPE	BOOLEAN
+VARIABLE_COMMENT	Whether the ib_logfile0 is disabled (and InnoDB is crash-unsafe)
+NUMERIC_MIN_VALUE	NULL
+NUMERIC_MAX_VALUE	NULL
+NUMERIC_BLOCK_SIZE	NULL
+ENUM_VALUE_LIST	OFF,ON
+READ_ONLY	NO
+COMMAND_LINE_ARGUMENT	OPTIONAL
 VARIABLE_NAME	INNODB_LOG_FILE_MMAP
 SESSION_VALUE	NULL
 DEFAULT_VALUE	ON

storage/innobase/buf/buf0flu.cc

@@ -1850,7 +1850,8 @@ inline void log_t::write_checkpoint(lsn_t end_lsn) noexcept
     ut_ad(ut_is_2pow(write_size));
     ut_ad(write_size >= 512);
     ut_ad(write_size <= 4096);
-    log.write(offset, {c, write_size});
+    if (UNIV_LIKELY(!disabled))
+      log.write(offset, {c, write_size});
     if (resizing > 1 && resizing <= next_checkpoint_lsn)
     {
       resize_log.write(CHECKPOINT_1, {c, write_size});
@@ -1861,7 +1862,7 @@ inline void log_t::write_checkpoint(lsn_t end_lsn) noexcept
       aligned_free(buf);
     }
 
-    if (srv_file_flush_method != SRV_O_DSYNC)
+    if (srv_file_flush_method != SRV_O_DSYNC && UNIV_LIKELY(!disabled))
       ut_a(log.flush());
     latch.wr_lock(SRW_LOCK_CALL);
     ut_ad(checkpoint_pending);
@@ -1889,24 +1890,32 @@ inline void log_t::write_checkpoint(lsn_t end_lsn) noexcept
 
   if (resizing > 1 && resizing <= checkpoint_lsn)
   {
-    ut_ad(is_mmap() == !resize_flush_buf);
-    ut_ad(is_mmap() == !resize_log.is_opened());
+#ifdef HAVE_PMEM
+    ut_ad(is_mmap() == !resize_flush_buf || disabled);
 
-    if (!is_mmap())
+    if (resize_log.is_opened())
+#endif
     {
+      ut_ad(disabled == !log.is_opened());
       if (srv_file_flush_method != SRV_O_DSYNC)
         ut_a(resize_log.flush());
-      IF_WIN(log.close(),);
+      IF_WIN(if (!disabled) log.close(),);
     }
 
     if (resize_rename())
     {
       /* Resizing failed. Discard the ib_logfile101. */
+      /* @see log_t::resize_abort() */
 #ifdef HAVE_PMEM
-      if (is_mmap())
+      if (!resize_log.is_opened())
       {
         ut_ad(!is_opened());
+        ut_ad(disabled == !!resize_flush_buf);
         my_munmap(resize_buf, resize_target);
+        flush_buf= resize_flush_buf;
+        resize_flush_buf= nullptr;
+        if (flush_buf)
+          writer= skip_write_buf;
       }
       else
 #endif
@@ -1929,19 +1938,25 @@ inline void log_t::write_checkpoint(lsn_t end_lsn) noexcept
     {
       /* Adopt the resized log. */
 #ifdef HAVE_PMEM
-      if (is_mmap())
+      if (!resize_log.is_opened())
       {
         ut_ad(!is_opened());
-        my_munmap(buf, file_size);
+        if (disabled)
+        {
+          ut_free_dodump(buf, buf_size);
+          /* log_t::resize_start() stored the dummy flush_buf here. */
+          ut_free_dodump(resize_flush_buf, buf_size);
+        }
+        else
+          my_munmap(buf, file_size);
         buf= resize_buf;
         buf_size= unsigned(std::min<uint64_t>(resize_target - START_OFFSET,
                                               buf_size_max));
       }
       else
 #endif
       {
-        ut_ad(!is_mmap());
-        IF_WIN(,log.close());
+        IF_WIN(,if (!disabled) log.close());
         std::swap(log, resize_log);
         ut_free_dodump(buf, buf_size);
         ut_free_dodump(flush_buf, buf_size);
@@ -1953,6 +1968,7 @@ inline void log_t::write_checkpoint(lsn_t end_lsn) noexcept
       set_capacity();
     }
     ut_ad(!resize_log.is_opened());
+    disabled= false;
     resize_buf= nullptr;
     resize_flush_buf= nullptr;
     resize_target= 0;

storage/innobase/handler/ha_innodb.cc

@@ -18608,6 +18608,71 @@ buffer_pool_load_abort(
 	}
 }
 
+static void innodb_log_file_disabled_update(THD *thd, st_mysql_sys_var*,
+                                            void *var, const void *save)
+{
+  ut_ad(var == &log_sys.disabled);
+  mysql_mutex_unlock(&LOCK_global_system_variables);
+
+  if (high_level_read_only)
+    ib_senderrf(thd, IB_LOG_LEVEL_ERROR, ER_READ_ONLY_MODE);
+  else if (!*static_cast<const my_bool*>(save))
+  {
+    if (log_sys.disable())
+    in_progress:
+      my_printf_error(ER_WRONG_USAGE,
+                      "innodb_log_file_* change is already in progress",
+                      MYF(0));
+  }
+  else
+  {
+    switch (log_sys.resize_start(srv_log_file_size, thd)) {
+    case log_t::RESIZE_NO_CHANGE:
+      break;
+    case log_t::RESIZE_IN_PROGRESS:
+      goto in_progress;
+    case log_t::RESIZE_FAILED:
+      ib_senderrf(thd, IB_LOG_LEVEL_ERROR, ER_CANT_CREATE_HANDLER_FILE);
+      break;
+    case log_t::RESIZE_STARTED:
+      for (timespec abstime;;)
+      {
+        if (thd_kill_level(thd))
+        {
+          log_sys.resize_abort(thd);
+          break;
+        }
+
+        set_timespec(abstime, 5);
+        mysql_mutex_lock(&buf_pool.flush_list_mutex);
+        lsn_t resizing= log_sys.resize_in_progress();
+        if (resizing > buf_pool.get_oldest_modification(0))
+        {
+          buf_pool.page_cleaner_wakeup(true);
+          my_cond_timedwait(&buf_pool.done_flush_list,
+                            &buf_pool.flush_list_mutex.m_mutex, &abstime);
+          resizing= log_sys.resize_in_progress();
+        }
+        mysql_mutex_unlock(&buf_pool.flush_list_mutex);
+        if (!resizing || !log_sys.resize_running(thd))
+          break;
+        log_sys.latch.wr_lock(SRW_LOCK_CALL);
+        while (resizing > log_sys.get_lsn())
+        {
+          ut_ad(!log_sys.is_mmap());
+          /* The server is almost idle. Write dummy FILE_CHECKPOINT records
+          to ensure that the log resizing will complete. */
+          mtr_t mtr;
+          mtr.start();
+          mtr.commit_files(log_sys.last_checkpoint_lsn);
+        }
+        log_sys.latch.wr_unlock();
+      }
+    }
+  }
+  mysql_mutex_lock(&LOCK_global_system_variables);
+}
+
 #if defined __linux__ || defined _WIN32
 static void innodb_log_file_buffering_update(THD *thd, st_mysql_sys_var*,
                                              void *, const void *save)
@@ -18630,18 +18695,19 @@ static void innodb_log_file_size_update(THD *thd, st_mysql_sys_var*,
 #ifdef HAVE_PMEM
           !log_sys.is_mmap() &&
 #endif
-           *static_cast<const ulonglong*>(save) < log_sys.buf_size)
+           *static_cast<const ulonglong*>(save) < log_sys.buf_size_requested)
     my_printf_error(ER_WRONG_ARGUMENTS,
                     "innodb_log_file_size must be at least"
-                    " innodb_log_buffer_size=%u", MYF(0), log_sys.buf_size);
+                    " innodb_log_buffer_size=%u", MYF(0),
+                    log_sys.buf_size_requested);
   else
   {
     switch (log_sys.resize_start(*static_cast<const ulonglong*>(save), thd)) {
     case log_t::RESIZE_NO_CHANGE:
       break;
     case log_t::RESIZE_IN_PROGRESS:
       my_printf_error(ER_WRONG_USAGE,
-                      "innodb_log_file_size change is already in progress",
+                      "innodb_log_file_* change is already in progress",
                       MYF(0));
       break;
     case log_t::RESIZE_FAILED:
@@ -19517,11 +19583,16 @@ static MYSQL_SYSVAR_ULONG(page_size, srv_page_size,
   NULL, NULL, UNIV_PAGE_SIZE_DEF,
   UNIV_PAGE_SIZE_MIN, UNIV_PAGE_SIZE_MAX, 0);
 
-static MYSQL_SYSVAR_UINT(log_buffer_size, log_sys.buf_size,
+static MYSQL_SYSVAR_UINT(log_buffer_size, log_sys.buf_size_requested,
   PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
   "Redo log buffer size in bytes.",
   NULL, NULL, 16U << 20, 2U << 20, log_sys.buf_size_max, 4096);
 
+static MYSQL_SYSVAR_BOOL(log_file_disabled, log_sys.disabled,
+  PLUGIN_VAR_OPCMDARG,
+  "Whether the ib_logfile0 is disabled (and InnoDB is crash-unsafe)",
+  nullptr, innodb_log_file_disabled_update, FALSE);
+
   static constexpr const char *innodb_log_file_mmap_description=
     "Whether ib_logfile0"
     " resides in persistent memory (when supported) or"
@@ -20003,6 +20074,7 @@ static struct st_mysql_sys_var* innobase_system_variables[]= {
   MYSQL_SYSVAR(deadlock_report),
   MYSQL_SYSVAR(page_size),
   MYSQL_SYSVAR(log_buffer_size),
+  MYSQL_SYSVAR(log_file_disabled),
   MYSQL_SYSVAR(log_file_mmap),
 #if defined __linux__ || defined _WIN32
   MYSQL_SYSVAR(log_file_buffering),

storage/innobase/include/log0log.h

@@ -130,7 +130,7 @@ class log_file_t
 /** Redo log buffer */
 struct log_t
 {
-  /** The maximum buf_size */
+  /** The maximum buf_size_requested */
   static constexpr unsigned buf_size_max= os_file_request_size_max;
 
   /** The original (not version-tagged) InnoDB redo log format */
@@ -182,7 +182,7 @@ struct log_t
   /** the first guaranteed-durable log sequence number */
   std::atomic<lsn_t> flushed_to_disk_lsn;
 public:
-  /** innodb_log_buffer_size (usable append_prepare() size in bytes) */
+  /** innodb_log_buffer_size or the PMEM file_size */
   unsigned buf_size;
   /** log file size in bytes, including the header */
   lsn_t file_size;
@@ -255,7 +255,11 @@ struct log_t
   lsn_t resize_target;
   /** Buffer for writing to resize_log; @see buf */
   byte *resize_buf;
-  /** Buffer for writing to resize_log; @see flush_buf */
+  /** Buffer for writing to resize_log; @see flush_buf.
+  When a PMEM based ib_logfile101 is being created during
+  SET GLOBAL innodb_log_file_disabled=OFF, this will store
+  the original value of a dummy log_sys.flush_buf that was being used by
+  skip_write_buf(). */
   byte *resize_flush_buf;
 
   /** log sequence number when log resizing was initiated;
@@ -264,10 +268,14 @@ struct log_t
   /** the log sequence number at the start of the log file */
   lsn_t first_lsn;
 public:
+  /** innodb_log_buffer_size (usable append_prepare() size in bytes) */
+  unsigned buf_size_requested;
   /** current innodb_log_write_ahead_size */
   uint write_size;
   /** format of the redo log: e.g., FORMAT_10_8 */
   uint32_t format;
+  /** whether the log is disabled */
+  my_bool disabled;
   /** whether the memory-mapped interface is enabled for the log */
   my_bool log_mmap;
   /** the default value of log_mmap */
@@ -331,6 +339,11 @@ struct log_t
   is_mmap() && !is_opened() holds for PMEM */
   bool is_opened() const noexcept { return log.is_opened(); }
 
+  /** Try to disable the redo log.
+  @retval false if the log is or was disabled
+  @retval true  if resize_in_progress() */
+  bool disable() noexcept;
+
   /** @return LSN at which log resizing was started and is still in progress
       @retval 0 if no log resizing is in progress
       @retval 1 if resize_start() is in progress */
@@ -543,6 +556,10 @@ struct log_t
     RESIZING
   };
 
+  /** Pretend to write to (non-existing) ib_logfile0 while disabled==true
+  @return the current log sequence number */
+  static lsn_t skip_write_buf() noexcept;
+
   /** Write buf to ib_logfile0 and possibly ib_logfile101.
   @tparam resizing whether to release latch and whether resize_in_progress()>1
   @return the current log sequence number */