MDEV-36234: dualstack aio/io_uring add innodb_linux_aio variable

This controls which linux implementation to use under the
assumption that innodb_native_aio is true.

"auto" select liburing first, if fails, tries libaio with
a filesystem test, and if fails, falls back to no-async.
"aio" starts is per auto, but skips liburing step.

Author: grooverdan

mysql-test/mariadb-test-run.pl

@@ -4522,7 +4522,7 @@ ($$)
      qr|InnoDB: io_setup\(\) attempt|,
      qr|InnoDB: io_setup\(\) failed with EAGAIN|,
      qr|io_uring_queue_init\(\) failed with|,
-     qr|InnoDB: liburing disabled|,
+     qr|InnoDB: io_uring failed: falling back to libaio|,
      qr/InnoDB: Failed to set O_DIRECT on file/,
      qr|setrlimit could not change the size of core files to 'infinity';|,
      qr|failed to retrieve the MAC address|,

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

@@ -0,0 +1,21 @@
+select @@global.innodb_linux_aio;
+@@global.innodb_linux_aio
+auto
+select @@session.innodb_linux_aio;
+ERROR HY000: Variable 'innodb_linux_aio' is a GLOBAL variable
+show global variables like 'innodb_linux_aio';
+Variable_name	Value
+innodb_linux_aio	auto
+show session variables like 'innodb_linux_aio';
+Variable_name	Value
+innodb_linux_aio	auto
+select * from information_schema.global_variables where variable_name='innodb_linux_aio';
+VARIABLE_NAME	VARIABLE_VALUE
+INNODB_LINUX_AIO	auto
+select * from information_schema.session_variables where variable_name='innodb_linux_aio';
+VARIABLE_NAME	VARIABLE_VALUE
+INNODB_LINUX_AIO	auto
+set global innodb_linux_aio='auto';
+ERROR HY000: Variable 'innodb_linux_aio' is a read only variable
+set session innodb_linux_aio='aio';
+ERROR HY000: Variable 'innodb_linux_aio' is a read only variable

mysql-test/suite/sys_vars/t/innodb_linux_aio_basic.test

@@ -0,0 +1,23 @@
+--source include/have_innodb.inc
+--source include/linux.inc
+# enum readonly
+
+#
+# show values;
+#
+select @@global.innodb_linux_aio;
+--error ER_INCORRECT_GLOBAL_LOCAL_VAR
+select @@session.innodb_linux_aio;
+show global variables like 'innodb_linux_aio';
+show session variables like 'innodb_linux_aio';
+select * from information_schema.global_variables where variable_name='innodb_linux_aio';
+select * from information_schema.session_variables where variable_name='innodb_linux_aio';
+
+#
+# show that it's read-only
+#
+--error ER_INCORRECT_GLOBAL_LOCAL_VAR
+set global innodb_linux_aio='auto';
+--error ER_INCORRECT_GLOBAL_LOCAL_VAR
+set session innodb_linux_aio='aio';
+

mysql-test/suite/sys_vars/t/sysvars_innodb.test

@@ -16,5 +16,6 @@ select VARIABLE_NAME, SESSION_VALUE, DEFAULT_VALUE, VARIABLE_SCOPE, VARIABLE_TYP
     'innodb_numa_interleave',           # only available WITH_NUMA
     'innodb_evict_tables_on_commit_debug', # one may want to override this
     'innodb_use_native_aio',            # default value depends on OS
+    'innodb_linux_aio',                 # existance depends on OS
     'innodb_buffer_pool_load_pages_abort')            # debug build only, and is only for testing
   order by variable_name;

storage/innobase/handler/ha_innodb.cc

@@ -313,6 +313,25 @@ static TYPELIB innodb_stats_method_typelib = {
 	NULL
 };
 
+/** Possible values for system variable "innodb_linux_aio" */
+#ifdef __linux__
+static const char* innodb_linux_aio_names[] = {
+	"auto",     /* SRV_LINUX_AIO_AUTO */
+	"io_uring", /* SRV_LINUX_AIO_IO_URING */
+	"aio",      /* SRV_LINUX_AIO_LIBAIO */
+	NullS
+};
+
+/** Used to define an enumerate type of the system variable
+innodb_linux_aio. */
+static TYPELIB innodb_linux_aio_typelib = {
+	array_elements(innodb_linux_aio_names) - 1,
+	"innodb_linux_aio_typelib",
+	innodb_linux_aio_names,
+	NULL
+};
+#endif
+
 /** Possible values of the parameter innodb_checksum_algorithm */
 const char* innodb_checksum_algorithm_names[] = {
 	"crc32",
@@ -19491,6 +19510,15 @@ static MYSQL_SYSVAR_BOOL(use_native_aio, srv_use_native_aio,
   "Use native AIO if supported on this platform.",
   NULL, NULL, TRUE);
 
+#ifdef __linux__
+static MYSQL_SYSVAR_ENUM(linux_aio, srv_linux_aio_method,
+  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+  "Specifies which InnoDB AIO implementaiton should"
+  " used. Possible value are \"auto\" (default) to select io_uring"
+  " and fallback to aio, or explictly \"io_uring\" and \"aio\"",
+  nullptr, nullptr, SRV_LINUX_AIO_AUTO, &innodb_linux_aio_typelib);
+#endif
+
 #ifdef HAVE_LIBNUMA
 static MYSQL_SYSVAR_BOOL(numa_interleave, srv_numa_interleave,
   PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
@@ -19874,6 +19902,9 @@ static struct st_mysql_sys_var* innobase_system_variables[]= {
   MYSQL_SYSVAR(autoinc_lock_mode),
   MYSQL_SYSVAR(version),
   MYSQL_SYSVAR(use_native_aio),
+#ifdef __linux__
+  MYSQL_SYSVAR(linux_aio),
+#endif
 #ifdef HAVE_LIBNUMA
   MYSQL_SYSVAR(numa_interleave),
 #endif /* HAVE_LIBNUMA */

storage/innobase/include/fil0fil.h

@@ -77,6 +77,19 @@ enum srv_flush_t
 #endif
 };
 
+/** Possible values of innodb_linux_aio */
+#ifdef __linux__
+enum srv_linux_aio_t
+{
+  /** auto, io_uring first and then aio */
+  SRV_LINUX_AIO_AUTO,
+  /** io_uring */
+  SRV_LINUX_AIO_IO_URING,
+  /** aio (libaio interface) */
+  SRV_LINUX_AIO_LIBAIO
+};
+#endif
+
 /** innodb_flush_method */
 extern ulong srv_file_flush_method;
 

storage/innobase/include/srv0srv.h

@@ -231,6 +231,12 @@ OS (provided we compiled Innobase with it in), otherwise we will
 use simulated aio.
 Currently we support native aio on windows and linux */
 extern my_bool	srv_use_native_aio;
+
+#ifdef __linux__
+/* This enum is defined which linux native io method to use */
+extern ulong	srv_linux_aio_method;
+#endif
+
 extern my_bool	srv_numa_interleave;
 
 /* Use atomic writes i.e disable doublewrite buffer */

storage/innobase/os/os0file.cc

@@ -3387,35 +3387,50 @@ int os_aio_init() noexcept
   int max_read_events= int(srv_n_read_io_threads *
                            OS_AIO_N_PENDING_IOS_PER_THREAD);
   int max_events= max_read_events + max_write_events;
-  int ret;
-#if LINUX_NATIVE_AIO
-  if (srv_use_native_aio && !is_linux_native_aio_supported())
-    goto disable;
-#endif
-
-  ret= srv_thread_pool->configure_aio(srv_use_native_aio, max_events);
+  int ret= 1;
 
-#ifdef LINUX_NATIVE_AIO
-  if (ret)
+#ifdef __linux__
+  if (srv_use_native_aio)
   {
-    ut_ad(srv_use_native_aio);
-disable:
-    ib::warn() << "Linux Native AIO disabled.";
-    srv_use_native_aio= false;
-    ret= srv_thread_pool->configure_aio(false, max_events);
-  }
+    switch (srv_linux_aio_method)
+    {
+    case SRV_LINUX_AIO_AUTO:
+    case SRV_LINUX_AIO_IO_URING:
+#ifdef HAVE_URING
+      ret= srv_thread_pool->configure_aio(srv_use_native_aio,
+                                          max_events,
+                                          tpool::OS_IO_URING);
 #endif
-
+#ifdef LINUX_NATIVE_AIO
 #ifdef HAVE_URING
-  if (ret)
-  {
-    ut_ad(srv_use_native_aio);
-    ib::warn()
-	    << "liburing disabled: falling back to innodb_use_native_aio=OFF";
-    srv_use_native_aio= false;
-    ret= srv_thread_pool->configure_aio(false, max_events);
-  }
+      if (ret && srv_linux_aio_method == SRV_LINUX_AIO_AUTO)
+        ib::warn() << "io_uring failed: falling back to libaio";
+      else
+        break;
+      /* fallthough */
+#endif /* HAVE_URING */
+    case SRV_LINUX_AIO_LIBAIO:
+      ret= srv_thread_pool->configure_aio(srv_use_native_aio,
+                                          max_events,
+                                          tpool::OS_AIO);
+      if (!ret && !is_linux_native_aio_supported())
+      {
+	ret= 1;
+      }
 #endif
+    }
+    if (ret)
+    {
+      ib::warn() << "native AIO failed: falling back to innodb_use_native_aio=OFF";
+      srv_use_native_aio= false;
+    }
+  }
+#endif /* linux */
+
+  if (ret)
+    ret= srv_thread_pool->configure_aio(srv_use_native_aio,
+                                        max_events,
+                                        tpool::OS_DEFAULT);
 
   if (!ret)
   {

storage/innobase/srv/srv0srv.cc

@@ -138,6 +138,10 @@ OS (provided we compiled Innobase with it in), otherwise we will
 use simulated aio we build below with threads.
 Currently we support native aio on windows and linux */
 my_bool	srv_use_native_aio;
+#ifdef __linux__
+/* This enum is defined which linux native io method to use */
+ulong	srv_linux_aio_method;
+#endif
 my_bool	srv_numa_interleave;
 /** copy of innodb_use_atomic_writes; @see innodb_init_params() */
 my_bool	srv_use_atomic_writes;

tpool/aio_liburing.cc

@@ -206,16 +206,24 @@ namespace tpool
 aio *create_libaio(thread_pool* tp, int max_io);
 #endif
 
-aio *create_linux_aio(thread_pool *pool, int max_aio)
+aio *create_linux_aio(thread_pool *pool, int max_aio, aio_implementation implementation)
 {
-  try {
-    return new aio_uring(pool, max_aio);
-  } catch (std::runtime_error& error) {
+  switch (implementation)
+  {
+  case OS_DEFAULT:
+  case OS_IO_URING:
+    try {
+      return new aio_uring(pool, max_aio);
+    } catch (std::runtime_error& error) {
+      return nullptr;
+    }
+    break;
 #ifdef LINUX_NATIVE_AIO
+  case OS_AIO:
     return create_libaio(pool, max_aio);
-#else
-    return nullptr;
 #endif
+  default:
+    return nullptr;
   }
 }
 

tpool/aio_linux.cc

@@ -180,9 +180,10 @@ namespace tpool
 {
 
 #ifdef HAVE_URING
-# define create_linux_aio create_libaio
+aio *create_libaio(thread_pool *pool, int max_io)
+#else
+aio *create_linux_aio(thread_pool *pool, int max_io, aio_implementation implementation __attribute__((unused)))
 #endif
-aio *create_linux_aio(thread_pool *pool, int max_io)
 {
   io_context_t ctx;
   memset(&ctx, 0, sizeof ctx);

tpool/tpool.h

@@ -210,12 +210,21 @@ class thread_pool;
 
 extern aio *create_simulated_aio(thread_pool *tp);
 
+enum aio_implementation
+{
+  OS_DEFAULT
+#ifdef __linux__
+  , OS_IO_URING
+  , OS_AIO
+#endif
+};
+
 class thread_pool
 {
 protected:
   /* AIO handler */
   std::unique_ptr<aio> m_aio;
-  virtual aio *create_native_aio(int max_io)= 0;
+  virtual aio *create_native_aio(int max_io, aio_implementation implementation)= 0;
 
 public:
   /**
@@ -238,10 +247,10 @@ class thread_pool
     m_worker_init_callback= init;
     m_worker_destroy_callback= destroy;
   }
-  int configure_aio(bool use_native_aio, int max_io)
+  int configure_aio(bool use_native_aio, int max_io, aio_implementation implementation)
   {
     if (use_native_aio)
-      m_aio.reset(create_native_aio(max_io));
+      m_aio.reset(create_native_aio(max_io, implementation));
     else
       m_aio.reset(create_simulated_aio(this));
     return !m_aio ? -1 : 0;

tpool/tpool_generic.cc

@@ -40,7 +40,7 @@ namespace tpool
 
 #ifdef __linux__
 #if defined(HAVE_URING) || defined(LINUX_NATIVE_AIO)
-  extern aio* create_linux_aio(thread_pool* tp, int max_io);
+  extern aio* create_linux_aio(thread_pool* tp, int max_io, aio_implementation implementation);
 #else
   aio *create_linux_aio(thread_pool *, int) { return nullptr; };
 #endif
@@ -299,12 +299,12 @@ class thread_pool_generic : public thread_pool
   void wait_begin() override;
   void wait_end() override;
   void submit_task(task *task) override;
-  aio *create_native_aio(int max_io) override
+  aio *create_native_aio(int max_io, aio_implementation implementation) override
   {
 #ifdef _WIN32
     return create_win_aio(this, max_io);
 #elif defined(__linux__)
-    return create_linux_aio(this,max_io);
+    return create_linux_aio(this, max_io, implementation);
 #else
     return nullptr;
 #endif