問題
最近碰到一個 case，一臺主機上，部署了多個例項。之前使用的是 MySQL 8.0，啟動時沒有任何問題。但升級到 MySQL 8.4 後，部分例項在啟動時出現了以下錯誤。
[Warning] [MY-012582] [InnoDB] io_setup() failed with EAGAIN. Will make 5 attempts before giving up.
[Warning] [MY-012583] [InnoDB] io_setup() attempt 1.
[Warning] [MY-012583] [InnoDB] io_setup() attempt 2.
[Warning] [MY-012583] [InnoDB] io_setup() attempt 3.
[Warning] [MY-012583] [InnoDB] io_setup() attempt 4.
[Warning] [MY-012583] [InnoDB] io_setup() attempt 5.
[ERROR] [MY-012584] [InnoDB] io_setup() failed with EAGAIN after 5 attempts.
[ERROR] [MY-012954] [InnoDB] Cannot initialize AIO sub-system
[ERROR] [MY-012930] [InnoDB] Plugin initialization aborted with error Generic error.
[ERROR] [MY-010334] [Server] Failed to initialize DD Storage Engine
[ERROR] [MY-010020] [Server] Data Dictionary initialization failed.
[ERROR] [MY-010119] [Server] Aborting
[System] [MY-010910] [Server] /usr/local/mysql/bin/mysqld: Shutdown complete (mysqld 8.4.0) MySQL Community Server - GPL.
[System] [MY-015016] [Server] MySQL Server - end.
下面我們來分析下這個報錯的具體原因及解決方法。
定位過程
首先搜尋下這個報錯是在哪個檔案產生的。
# grep "io_setup() failed" -r /usr/src/mysql-8.4.0
/usr/src/mysql-8.4.0/storage/innobase/os/os0file.cc: ib::warn(ER_IB_MSG_757) << "io_setup() failed with EAGAIN."
/usr/src/mysql-8.4.0/storage/innobase/os/os0file.cc: << "io_setup() failed with EAGAIN after "
接著分析該檔案中產生報錯的具體函式。
// storage/innobase/os/os0file.cc
bool AIO::linux_create_io_ctx(ulint max_events, io_context_t *io_ctx) {
ssize_t n_retries = 0;
for (;;) {
memset(io_ctx, 0x0, sizeof(*io_ctx));
int ret = io_setup(max_events, io_ctx);
if (ret == 0) {
/* Success. Return now. */
return (true);
}
switch (ret) {
case -EAGAIN:
if (n_retries == 0) {
/* First time around. */
ib::warn(ER_IB_MSG_757) << "io_setup() failed with EAGAIN."
" Will make "
<< OS_AIO_IO_SETUP_RETRY_ATTEMPTS
<< " attempts before giving up.";
}
if (n_retries < OS_AIO_IO_SETUP_RETRY_ATTEMPTS) {
++n_retries;
ib::warn(ER_IB_MSG_758) << "io_setup() attempt " << n_retries << ".";
std::this_thread::sleep_for(OS_AIO_IO_SETUP_RETRY_SLEEP);
continue;
}
/* Have tried enough. Better call it a day. */
ib::error(ER_IB_MSG_759)
<< "io_setup() failed with EAGAIN after "
<< OS_AIO_IO_SETUP_RETRY_ATTEMPTS << " attempts.";
break;
...
}
ib::info(ER_IB_MSG_762) << "You can disable Linux Native AIO by"
" setting innodb_use_native_aio = 0 in my.cnf";
break;
}
return (false);
}
可以看到，錯誤資訊主要是在執行io_setup，產生 EAGAIN 錯誤時列印的。
函式中的io_setup是一個 Linux 系統呼叫，用於初始化一個非同步 I/O (AIO) 上下文（context）。非同步 I/O（AIO）允許程式在發出 I/O 操作請求後繼續執行其他工作，而不是等待操作完成。io_setup是 Linux 核心提供的非同步 I/O 介面，通常用於高效能應用程式和資料庫系統，以實現非阻塞 I/O 操作。max_events 指定了這個非同步 I/O 上下文可以處理的最大併發 I/O 請求數。io_setup執行成功時會返回 0，失敗時則返回 -1，並透過 errno 表示具體錯誤。
當返回的錯誤是 EAGAIN 時，則意味著指定的 max_events 超過了系統允許的最大非同步 I/O (AIO) 事件數。
系統允許建立的最大非同步 I/O 事件數是在/proc/sys/fs/aio-max-nr中定義的，預設值跟系統有關，通常是 65536。
所以，解決方法找到了，直接調整/proc/sys/fs/aio-max-nr的值即可。
# echo 1048576 > /proc/sys/fs/aio-max-nr
注意這種只是臨時修改，系統重啟就會失效。如果要永久修改，需調整 /etc/sysctl.conf。
# vim /etc/sysctl.conf
fs.aio-max-nr=1048576
# sysctl -p
問題解決了，接下來我們分析下同一臺主機，為什麼之前的 MySQL 8.0 沒問題，升級到 MySQL 8.4 就報錯了呢？
這個時候，就需要分析函式中 max_events 的生成邏輯了。
堆疊資訊
下面是AIO::linux_create_io_ctx函式被呼叫的堆疊資訊。
#0 AIO::linux_create_io_ctx (max_events=256, io_ctx=0x7fffe02d1500)
at /usr/src/mysql-8.4.0/storage/innobase/os/os0file.cc:2559
#1 0x0000000004db1649 in AIO::init_linux_native_aio (this=0x7fffe02d1d70)
at /usr/src/mysql-8.4.0/storage/innobase/os/os0file.cc:6139
#2 0x0000000004db16ed in AIO::init (this=0x7fffe02d1d70)
at /usr/src/mysql-8.4.0/storage/innobase/os/os0file.cc:6167
#3 0x0000000004db1826 in AIO::create (id=LATCH_ID_OS_AIO_IBUF_MUTEX, n=256, n_segments=1)
at /usr/src/mysql-8.4.0/storage/innobase/os/os0file.cc:6200
#4 0x0000000004db1a2b in AIO::start (n_per_seg=256, n_readers=64, n_writers=4)
at /usr/src/mysql-8.4.0/storage/innobase/os/os0file.cc:6254
#5 0x0000000004db261a in os_aio_init (n_readers=64, n_writers=4)
at /usr/src/mysql-8.4.0/storage/innobase/os/os0file.cc:6514
#6 0x0000000004ee6b4d in srv_start (create_new_db=false)
at /usr/src/mysql-8.4.0/storage/innobase/srv/srv0start.cc:1743
#7 0x0000000004bdfc92 in innobase_init_files (dict_init_mode=DICT_INIT_CHECK_FILES, tablespaces=0x7fffe77bf720)
at /usr/src/mysql-8.4.0/storage/innobase/handler/ha_innodb.cc:5744
#8 0x0000000004bf0e22 in innobase_ddse_dict_init (dict_init_mode=DICT_INIT_CHECK_FILES, tables=0x7fffe77bf740,
tablespaces=0x7fffe77bf720) at /usr/src/mysql-8.4.0/storage/innobase/handler/ha_innodb.cc:13133
#9 0x00000000049153b8 in dd::bootstrap::DDSE_dict_init (thd=0xb7ce6b0, dict_init_mode=DICT_INIT_CHECK_FILES,
version=80300) at /usr/src/mysql-8.4.0/sql/dd/impl/bootstrap/bootstrapper.cc:746
#10 0x0000000004916195 in dd::bootstrap::restart_dictionary (thd=0xb7ce6b0)
at /usr/src/mysql-8.4.0/sql/dd/impl/bootstrap/bootstrapper.cc:907
#11 0x0000000003814e54 in bootstrap::handle_bootstrap (arg=0x7fffffffcf20)
at /usr/src/mysql-8.4.0/sql/bootstrap.cc:340
#12 0x0000000005792a92 in pfs_spawn_thread (arg=0xb7ece50) at /usr/src/mysql-8.4.0/storage/perfschema/pfs.cc:3051
#13 0x00007ffff7bc6ea5 in start_thread () from /lib64/libpthread.so.0
#14 0x00007ffff5ff0b0d in clone () from /lib64/libc.so.6
堆疊中的重點是 #6 的srv_start函式，這個函式會呼叫os_aio_init來初始化非同步 I/O 系統。
// storage/innobase/srv/srv0start.cc
dberr_t srv_start(bool create_new_db) {
...
if (!os_aio_init(srv_n_read_io_threads, srv_n_write_io_threads)) {
ib::error(ER_IB_MSG_1129);
return (srv_init_abort(DB_ERROR));
}
...
呼叫 os_aio_init 時，會傳遞兩個引數：srv_n_read_io_threads 和 srv_n_write_io_threads。這兩個引數實際上對應的就是 MySQL 中的 innodb_read_io_threads 和 innodb_write_io_threads，這兩個引數分別用來表示 InnoDB 中用於讀操作、寫操作的 I/O 執行緒數。
如果初始化失敗，會列印ER_IB_MSG_1129錯誤。
ER_IB_MSG_1129是一個預定義的錯誤程式碼，對應的錯誤資訊是在share/messages_to_error_log.txt中定義的。
ER_IB_MSG_1129
eng "Cannot initialize AIO sub-system"
所以，錯誤日誌中看到的[ERROR] [MY-012954] [InnoDB] Cannot initialize AIO sub-system其實就是在這裡列印的。
有的童鞋可能猜到了，非同步 I/O 系統初始化失敗與 innodb_read_io_threads 和 innodb_write_io_threads 的設定有關，事實也確實如此。
下面，我們分析下 MySQL 啟動過程中需要初始化多少個非同步 I/O 請求。
MySQL 啟動過程中需要初始化多少個非同步 I/O 請求？
非同步 I/O 的初始化主要是在AIO::linux_create_io_ctx中進行的，接下來，我們分析下AIO::linux_create_io_ctx的呼叫場景：
場景1：AIO::is_linux_native_aio_supported
該函式用來判斷系統是否支援 AIO。
bool AIO::is_linux_native_aio_supported() {
...
if (!linux_create_io_ctx(1, &io_ctx)) {
return (false);
}
...
}
這裡只會初始化 1 個非同步 I/O 請求。
場景2：AIO::init_linux_native_aio
該函式是用來初始化 Linux 原生非同步 I/O 的。
dberr_t AIO::init_linux_native_aio() {
...
ulint max_events = slots_per_segment();
for (ulint i = 0; i < m_n_segments; ++i, ++ctx) {
if (!linux_create_io_ctx(max_events, ctx)) {
return (DB_IO_ERROR);
}
}
return (DB_SUCCESS);
}
函式中的 m_n_segments 是需要建立的非同步 I/O (AIO) 上下文的數量，max_events 是每個非同步 I/O (AIO) 上下文支援的最大併發 I/O 請求數。所以，這個函式會初始化 m_n_segments * max_events 個非同步 I/O 請求。
在 MySQL 的啟動過程中，AIO::is_linux_native_aio_supported 只被呼叫一次，而 AIO::init_linux_native_aio 則會被呼叫三次，分別用於 insert buffer 執行緒、讀執行緒和寫執行緒的初始化。
這兩個函式都是在AIO::start中呼叫的。
// storage/innobase/os/os0file.cc
bool AIO::start(ulint n_per_seg, ulint n_readers, ulint n_writers) {
#if defined(LINUX_NATIVE_AIO)
/* Check if native aio is supported on this system and tmpfs */
if (srv_use_native_aio && !is_linux_native_aio_supported()) {
ib::warn(ER_IB_MSG_829) << "Linux Native AIO disabled.";
srv_use_native_aio = false;
}
#endif /* LINUX_NATIVE_AIO */
...
if (0 < n_extra) {
...
s_ibuf = create(LATCH_ID_OS_AIO_IBUF_MUTEX, n_per_seg, 1);
...
}
...
s_reads =
create(LATCH_ID_OS_AIO_READ_MUTEX, n_readers * n_per_seg, n_readers);
...
s_writes =
create(LATCH_ID_OS_AIO_WRITE_MUTEX, n_writers * n_per_seg, n_writers);
...
return true;
}
函式中的 n_per_seg 實際上就是 max_events。
n_per_seg 等於 8 * OS_AIO_N_PENDING_IOS_PER_THREAD，因為 OS_AIO_N_PENDING_IOS_PER_THREAD 是個常量，值為 32，所以 n_per_seg 等於 256。
而AIO::init_linux_native_aio 中的 m_n_segments 實際上表示的是執行緒的數量：對於 insert buffer 執行緒，執行緒數為 1；對於讀操作執行緒，執行緒數為 n_readers；對於寫操作執行緒，執行緒數為 n_writers。
怎麼知道 m_n_segments 就是執行緒的數量？
關鍵是在建立 AIO 物件時，會呼叫 AIO 的建構函式，而建構函式中的 m_slots 又決定了 max_events 的值。
AIO *AIO::create(latch_id_t id, ulint n, ulint n_segments) {
...
AIO *array =
ut::new_withkey<AIO>(UT_NEW_THIS_FILE_PSI_KEY, id, n, n_segments);
...
}
AIO::AIO(latch_id_t id, ulint n, ulint segments)
: m_slots(n),
m_n_segments(segments),
...
[[nodiscard]] ulint slots_per_segment() const {
return (m_slots.size() / m_n_segments);
}
以讀執行緒為例，AIO::create中的 n 等於 n_readers * n_per_seg，n_segments 等於 n_readers。
在初始化 AIO 物件時，n_readers * n_per_seg 將賦值給 m_slots，n_readers 將賦值給 m_n_segments。
所以AIO::init_linux_native_aio中的 max_events = slots_per_segment() = m_slots.size() / m_n_segments = n_readers * n_per_seg / n_readers = n_per_seg。
計算公式
基於上面的分析，我們可以推論出 MySQL 在啟動過程中需要初始化的非同步 I/O 請求數的計算公式。
(1 + innodb_read_io_threads + innodb_write_io_threads) * 256 + 1
最後一個 1 是判斷系統是否支援 AIO。
驗證
下面透過一個具體的案例來驗證下上面的計算公式是否正確。
首先透過/proc/sys/fs/aio-nr檢視當前系統中已分配的非同步 I/O 請求的數量。
# cat /proc/sys/fs/aio-nr
4866
接著，啟動一個 MySQL 8.4 例項，啟動命令中顯式設定 innodb_read_io_threads 和 innodb_write_io_threads。
# /usr/local/mysql8.4/bin/mysqld --defaults-file=/etc/my_3308.cnf --innodb-read-io-threads=64 --innodb-write-io-threads=4 &
例項啟動後，再次檢視/proc/sys/fs/aio-nr。
# cat /proc/sys/fs/aio-nr
22531
兩個數之間的差值是 17665。
按照之前的公式計算，也是 17665，完全吻合。
(1 + 64 + 4) * 256 + 1 = 17665
為什麼 MySQL 8.4 啟動會報錯呢？
因為 innodb_read_io_threads 的預設值在 MySQL 8.4 中發生了變化。
在 MySQL 8.4 之前，innodb_read_io_threads 預設為 4，而在 MySQL 8.4 中，innodb_read_io_threads 預設等於主機邏輯 CPU 的一半，最小是 4，最大是 64。
static MYSQL_SYSVAR_ULONG(
read_io_threads, srv_n_read_io_threads,
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
"Number of background read I/O threads in InnoDB.", nullptr, nullptr,
std::clamp(std::thread::hardware_concurrency() / 2, 4U, 64U), 1, 64, 0);
不巧，問題 case 主機的邏輯 CPU 是 128 核，所以就導致了 innodb_read_io_threads 等於 64。
這就意味著，在/proc/sys/fs/aio-max-nr等於 65536（預設值）的情況下，該主機上只能啟動 3（65536/17665） 個 MySQL 8.4 例項。
結論
- MySQL 在啟動時，如果出現
io_setup() failed with EAGAIN錯誤，可適當增加/proc/sys/fs/aio-max-nr的值。 - MySQL 在啟動過程中需要初始化的非同步 I/O 請求數等於
(1 + innodb_read_io_threads + innodb_write_io_threads) * 256 + 1 - innodb_read_io_threads 的預設值在 MySQL 8.4 中發生了變化，建議在配置檔案中顯式指定。
參考資料
io_setup(2) — Linux manual page: https://www.man7.org/linux/man-pages/man2/io_setup.2.html