WIP MDEV-36301: innodb_log_file_disabled

innodb_log_file_disabled: A new Boolean parameter, default OFF.
FIXME: This currently only "works" during bootstrap.

log_t::buf_size_requested: A new parameter, separate from buf_size,
which will be the log buffer size that is currently in use.

log_t::disable(): The beginnings of implementing
SET GLOBAL innodb_log_file_disabled=OFF.

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,7 @@
+# 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

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

@@ -0,0 +1,23 @@
+--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=ON;
+#--source include/restart_mysqld.inc
+#eval $check_no_innodb;
+--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);

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;
@@ -264,10 +264,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 +335,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 +552,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 */