Bug#35145188: innodb.log_file_resize_1 is failing sporadically in pb2

innodb_redo_log_capacity_update changes log capacity, and waits for
the next governor thread iteration to finish, but the governor thread
might not actually be aware of the change, as it might have been running in paralell
already. The routine log_files_wait_until_next_governor_iteration
in this case just waits for the current iteration to finish.

This patch alters log_files_wait_until_next_governor_iteration,
to make sure it waits for a full iteration to complete.

Change-Id: Ia359ea371405df3eab1ec5234a86f29d50552250

Author: GBuella

storage/innobase/handler/ha_innodb.cc

@@ -731,6 +731,7 @@ static PSI_mutex_info all_innodb_mutexes[] = {
     PSI_MUTEX_KEY(log_flusher_mutex, 0, 0, PSI_DOCUMENT_ME),
     PSI_MUTEX_KEY(log_write_notifier_mutex, 0, 0, PSI_DOCUMENT_ME),
     PSI_MUTEX_KEY(log_flush_notifier_mutex, 0, 0, PSI_DOCUMENT_ME),
+    PSI_MUTEX_KEY(log_governor_mutex, 0, 0, PSI_DOCUMENT_ME),
     PSI_MUTEX_KEY(log_sys_arch_mutex, 0, 0, PSI_DOCUMENT_ME),
     PSI_MUTEX_KEY(log_cmdq_mutex, 0, 0, PSI_DOCUMENT_ME),
     PSI_MUTEX_KEY(log_sn_mutex, 0, 0, PSI_DOCUMENT_ME),

storage/innobase/include/log0sys.h

@@ -440,6 +440,10 @@ struct alignas(ut::INNODB_CACHE_LINE_SIZE) log_t {
   /** Event used by log files governor thread to wait. */
   os_event_t m_files_governor_event;
 
+  /** Mutex which can be used to pause log governor thread. */
+  alignas(ut::INNODB_CACHE_LINE_SIZE) mutable ib_mutex_t
+      governor_iteration_mutex;
+
   /** Event used by other threads to wait until log files governor finished
   its next iteration. This is useful when some sys_var gets changed to wait
   until log files governor re-computed everything and then check if the

storage/innobase/include/sync0sync.h

@@ -120,6 +120,7 @@ extern mysql_pfs_key_t log_write_notifier_mutex_key;
 extern mysql_pfs_key_t log_flush_notifier_mutex_key;
 extern mysql_pfs_key_t log_limits_mutex_key;
 extern mysql_pfs_key_t log_files_mutex_key;
+extern mysql_pfs_key_t log_governor_mutex_key;
 extern mysql_pfs_key_t log_cmdq_mutex_key;
 extern mysql_pfs_key_t log_sn_lock_key;
 extern mysql_pfs_key_t log_sn_mutex_key;

storage/innobase/include/sync0types.h

@@ -250,6 +250,7 @@ enum latch_level_t {
   SYNC_LOG_CHECKPOINTER,
   SYNC_LOG_SN,
   SYNC_LOG_SN_MUTEX,
+  SYNC_LOG_GOVERNOR_MUTEX,
   SYNC_PAGE_ARCH,
   SYNC_PAGE_ARCH_CLIENT,
   SYNC_LOG_ARCH,
@@ -383,6 +384,7 @@ enum latch_id_t {
   LATCH_ID_LOG_FLUSH_NOTIFIER,
   LATCH_ID_LOG_LIMITS,
   LATCH_ID_LOG_FILES,
+  LATCH_ID_LOG_GOVERNOR_MUTEX,
   LATCH_ID_PARSER,
   LATCH_ID_LOG_ARCH,
   LATCH_ID_PAGE_ARCH,

storage/innobase/log/log0files_governor.cc

@@ -1304,6 +1304,8 @@ static Log_files_governor_iteration_result log_files_governor_iteration_low(
 }
 
 static void log_files_governor_iteration(log_t &log) {
+  IB_mutex_guard iteration_latch{&(log.governor_iteration_mutex),
+                                 UT_LOCATION_HERE};
   using Iteration_result = Log_files_governor_iteration_result;
 
   /* We can't use log_writer_mutex_own() here, because it could return true
@@ -2017,8 +2019,10 @@ void log_files_initialize_on_existing_redo(log_t &log) {
 Notifies the log_files_governor thread (to ensure it is soon).
 @param[in,out]  log   redo log */
 static void log_files_wait_until_next_governor_iteration(log_t &log) {
+  mutex_enter(&log.governor_iteration_mutex);
   const auto sig_count = os_event_reset(log.m_files_governor_iteration_event);
   os_event_set(log.m_files_governor_event);
+  mutex_exit(&log.governor_iteration_mutex);
   os_event_wait_low(log.m_files_governor_iteration_event, sig_count);
 }
 

storage/innobase/log/log0log.cc

@@ -640,6 +640,7 @@ static void log_sys_create() {
   mutex_create(LATCH_ID_LOG_LIMITS, &log.limits_mutex);
   mutex_create(LATCH_ID_LOG_FILES, &log.m_files_mutex);
   mutex_create(LATCH_ID_LOG_SN_MUTEX, &log.sn_x_lock_mutex);
+  mutex_create(LATCH_ID_LOG_GOVERNOR_MUTEX, &log.governor_iteration_mutex);
 
 #ifdef UNIV_PFS_RWLOCK
   /* pfs_psi is separated from sn_lock_inst,
@@ -835,6 +836,7 @@ static void log_sys_free() {
   mutex_free(&log.writer_mutex);
   mutex_free(&log.closer_mutex);
   mutex_free(&log.checkpointer_mutex);
+  mutex_free(&log.governor_iteration_mutex);
 
   os_event_destroy(log.next_checkpoint_event);
   os_event_destroy(log.write_notifier_event);

storage/innobase/sync/sync0debug.cc

@@ -479,6 +479,7 @@ LatchDebug::LatchDebug() {
   LEVEL_MAP_INSERT(SYNC_LOG_WRITER);
   LEVEL_MAP_INSERT(SYNC_LOG_WRITE_NOTIFIER);
   LEVEL_MAP_INSERT(SYNC_LOG_FLUSH_NOTIFIER);
+  LEVEL_MAP_INSERT(SYNC_LOG_GOVERNOR_MUTEX);
   LEVEL_MAP_INSERT(SYNC_LOG_CLOSER);
   LEVEL_MAP_INSERT(SYNC_LOG_CHECKPOINTER);
   LEVEL_MAP_INSERT(SYNC_LOG_ARCH);
@@ -728,6 +729,7 @@ Latches *LatchDebug::check_order(const latch_t *latch,
     case SYNC_LOG_WRITE_NOTIFIER:
     case SYNC_LOG_FLUSH_NOTIFIER:
     case SYNC_LOG_LIMITS:
+    case SYNC_LOG_GOVERNOR_MUTEX:
     case SYNC_LOG_FILES:
     case SYNC_LOG_ARCH:
     case SYNC_PAGE_ARCH:
@@ -1288,6 +1290,9 @@ static void sync_latch_meta_init() UNIV_NOTHROW {
 
   LATCH_ADD_MUTEX(LOG_FILES, SYNC_LOG_FILES, log_files_mutex_key);
 
+  LATCH_ADD_MUTEX(LOG_GOVERNOR_MUTEX, SYNC_LOG_GOVERNOR_MUTEX,
+                  log_governor_mutex_key);
+
   LATCH_ADD_RWLOCK(LOG_SN, SYNC_LOG_SN, log_sn_lock_key);
 
   LATCH_ADD_MUTEX(LOG_SN_MUTEX, SYNC_LOG_SN_MUTEX, log_sn_mutex_key);

storage/innobase/sync/sync0sync.cc

@@ -87,6 +87,7 @@ mysql_pfs_key_t log_write_notifier_mutex_key;
 mysql_pfs_key_t log_flush_notifier_mutex_key;
 mysql_pfs_key_t log_limits_mutex_key;
 mysql_pfs_key_t log_files_mutex_key;
+mysql_pfs_key_t log_governor_mutex_key;
 mysql_pfs_key_t log_cmdq_mutex_key;
 mysql_pfs_key_t log_sn_lock_key;
 mysql_pfs_key_t log_sn_mutex_key;