MDEV-30100: Assertion purge_sys.tail.trx_no <= purge_sys.rseg->last_trx_no()

trx_t::commit_empty(): A special case of transaction "commit" when
the transaction was actually rolled back or the persistent undo log
is empty. In this case, we need to change the undo log header state to
TRX_UNDO_CACHED and move the undo log from rseg->undo_list to
rseg->undo_cached for fast reuse. Furthermore, unless this is the only
undo log record in the page, we will remove the record and rewind
TRX_UNDO_PAGE_START, TRX_UNDO_PAGE_FREE, TRX_UNDO_LAST_LOG.

Even though it is not going to be written persistently anywhere,
we will invoke trx_sys.assign_new_trx_no(this), so that in the test
innodb.instant_alter everything will be purged as expected.

trx_t::write_serialisation_history(): Renamed from
trx_write_serialisation_history(). If there is no undo log,
invoke commit_empty().

trx_purge_add_undo_to_history(): Simplify an assertion and remove a
comment. This function will not be invoked on an empty undo log
anymore.

trx_undo_header_create(): Add a debug assertion.

trx_undo_mem_create_at_db_start(): Remove a duplicated assignment.

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

@@ -182,7 +182,7 @@ ROLLBACK;
 connection stop_purge;
 COMMIT;
 connection default;
-InnoDB		2 transactions not purged
+InnoDB		1 transactions not purged
 SET DEBUG_SYNC='now SIGNAL logged';
 connection ddl;
 connection default;

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

@@ -200,7 +200,7 @@ COMMIT;
 connection default;
 
 # Wait for purge to empty the table.
-let $wait_all_purged=2;
+let $wait_all_purged=1;
 --source include/wait_all_purged.inc
 let $wait_all_purged=0;
 

storage/innobase/include/trx0trx.h

@@ -963,11 +963,19 @@ struct trx_t : ilist_node<>
   /** Commit the transaction in a mini-transaction.
   @param mtr  mini-transaction (if there are any persistent modifications) */
   void commit_low(mtr_t *mtr= nullptr);
+  /** Commit an empty transaction.
+  @param mtr   mini-transaction */
+  void commit_empty(mtr_t *mtr);
+  /** Commit an empty transaction.
+  @param mtr   mini-transaction */
+  /** Assign the transaction its history serialisation number and write the
+  UNDO log to the assigned rollback segment.
+  @param mtr   mini-transaction */
+  inline void write_serialisation_history(mtr_t *mtr);
 public:
   /** Commit the transaction. */
   void commit();
 
-
   /** Try to drop a persistent table.
   @param table       persistent table
   @param fk          whether to drop FOREIGN KEY metadata

storage/innobase/trx/trx0purge.cc

@@ -307,11 +307,7 @@ trx_purge_add_undo_to_history(const trx_t* trx, trx_undo_t*& undo, mtr_t* mtr)
 
   undo= nullptr;
 
-  /* After the purge thread has been given permission to exit,
-  we may roll back transactions (trx->undo_no==0)
-  in THD::cleanup() invoked from unlink_thd() in fast shutdown,
-  or in trx_rollback_recovered() in slow shutdown.
-
+  /*
   Before any transaction-generating background threads or the purge
   have been started, we can start transactions in
   row_merge_drop_temp_indexes(), and roll back recovered transactions.
@@ -323,12 +319,10 @@ trx_purge_add_undo_to_history(const trx_t* trx, trx_undo_t*& undo, mtr_t* mtr)
 
   During fast shutdown, we may also continue to execute user
   transactions. */
-  ut_ad(srv_undo_sources || trx->undo_no == 0 ||
+  ut_ad(srv_undo_sources || srv_fast_shutdown ||
         (!purge_sys.enabled() &&
          (srv_is_being_started ||
-          trx_rollback_is_active ||
-          srv_force_recovery >= SRV_FORCE_NO_BACKGROUND)) ||
-        srv_fast_shutdown);
+          srv_force_recovery >= SRV_FORCE_NO_BACKGROUND)));
 
 #ifdef WITH_WSREP
   if (wsrep_is_wsrep_xid(&trx->xid))

storage/innobase/trx/trx0trx.cc

@@ -968,15 +968,102 @@ trx_start_low(
 	ut_a(trx->error_state == DB_SUCCESS);
 }
 
+/** Release an empty undo log that was associated with a transaction. */
+ATTRIBUTE_COLD
+void trx_t::commit_empty(mtr_t *mtr)
+{
+  trx_rseg_t *rseg= rsegs.m_redo.rseg;
+  trx_undo_t *&undo= rsegs.m_redo.undo;
+
+  ut_ad(undo->state == TRX_UNDO_ACTIVE || undo->state == TRX_UNDO_PREPARED);
+  ut_ad(undo->size == 1);
+
+  if (buf_block_t *u=
+      buf_page_get(page_id_t(rseg->space->id, undo->hdr_page_no), 0,
+                   RW_X_LATCH, mtr))
+  {
+    ut_d(const uint16_t state=
+         mach_read_from_2(TRX_UNDO_SEG_HDR + TRX_UNDO_STATE + u->page.frame));
+    ut_ad(state == undo->state || state == TRX_UNDO_ACTIVE);
+    static_assert(TRX_UNDO_PAGE_START + 2 == TRX_UNDO_PAGE_FREE,
+                  "compatibility");
+    ut_ad(!memcmp(TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_START + u->page.frame,
+                  TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_FREE + u->page.frame, 2));
+    ut_ad(mach_read_from_4(TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_NODE + FLST_PREV +
+                           FIL_ADDR_PAGE + u->page.frame) == FIL_NULL);
+    ut_ad(mach_read_from_2(TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_NODE + FLST_PREV +
+                           FIL_ADDR_BYTE + u->page.frame) == 0);
+    ut_ad(!memcmp(TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_NODE + FLST_PREV +
+                  u->page.frame,
+                  TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_NODE + FLST_NEXT +
+                  u->page.frame, FIL_ADDR_SIZE));
+
+    /* Delete the last undo log header, which must be for this transaction. */
+    for (byte *last= &u->page.frame[TRX_UNDO_SEG_HDR + TRX_UNDO_SEG_HDR_SIZE],
+           *prev= nullptr;;)
+    {
+      /* TRX_UNDO_PREV_LOG is only being read in debug assertions, and
+      written in trx_undo_header_create(). */
+      ut_ad(mach_read_from_2(TRX_UNDO_PREV_LOG + last) ==
+            (reinterpret_cast<size_t>(prev) & (srv_page_size - 1)));
+
+      if (uint16_t next= mach_read_from_2(TRX_UNDO_NEXT_LOG + last))
+      {
+        ut_ad(ulint{next} + TRX_UNDO_LOG_XA_HDR_SIZE < srv_page_size - 100);
+        ut_ad(&u->page.frame[next] > last);
+        ut_ad(mach_read_from_2(TRX_UNDO_LOG_START + last) <= next);
+        prev= last;
+        last= &u->page.frame[next];
+        continue;
+      }
+
+      ut_ad(mach_read_from_8(TRX_UNDO_TRX_ID + last) == id);
+      ut_ad(!mach_read_from_8(TRX_UNDO_TRX_NO + last));
+      ut_ad(!memcmp(TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_START + u->page.frame,
+                    TRX_UNDO_LOG_START + last, 2));
+
+      if (prev)
+      {
+        mtr->memcpy(*u, TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_START +
+                    u->page.frame, prev + TRX_UNDO_LOG_START, 2);
+        const ulint free= page_offset(last);
+        mtr->write<2>(*u, TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_FREE +
+                      u->page.frame, free);
+        mtr->write<2>(*u, TRX_UNDO_SEG_HDR + TRX_UNDO_STATE + u->page.frame,
+                      TRX_UNDO_CACHED);
+        mtr->write<2>(*u, TRX_UNDO_SEG_HDR + TRX_UNDO_LAST_LOG + u->page.frame,
+                      page_offset(prev));
+        mtr->write<2>(*u, prev + TRX_UNDO_NEXT_LOG, 0U);
+        mtr->memset(u, free, srv_page_size - FIL_PAGE_DATA_END - free, 0);
+      }
+      else
+        mtr->write<2>(*u, TRX_UNDO_SEG_HDR + TRX_UNDO_STATE + u->page.frame,
+                      TRX_UNDO_CACHED);
+      break;
+    }
+  }
+  else
+    ut_ad("undo log page was not found" == 0);
+
+  UT_LIST_REMOVE(rseg->undo_list, undo);
+  UT_LIST_ADD_FIRST(rseg->undo_cached, undo);
+  undo->state= TRX_UNDO_CACHED;
+  undo= nullptr;
+
+  /* We must assign an "end" identifier even though we are not going
+  to persistently write it anywhere, to make sure that the purge of
+  history will not be stuck. */
+  trx_sys.assign_new_trx_no(this);
+}
+
 /** Assign the transaction its history serialisation number and write the
 UNDO log to the assigned rollback segment.
-@param trx   persistent transaction
 @param mtr   mini-transaction */
-static void trx_write_serialisation_history(trx_t *trx, mtr_t *mtr)
+inline void trx_t::write_serialisation_history(mtr_t *mtr)
 {
-  ut_ad(!trx->read_only);
-  trx_rseg_t *rseg= trx->rsegs.m_redo.rseg;
-  trx_undo_t *&undo= trx->rsegs.m_redo.undo;
+  ut_ad(!read_only);
+  trx_rseg_t *rseg= rsegs.m_redo.rseg;
+  trx_undo_t *&undo= rsegs.m_redo.undo;
   if (UNIV_LIKELY(undo != nullptr))
   {
     MONITOR_INC(MONITOR_TRX_COMMIT_UNDO);
@@ -988,26 +1075,32 @@ static void trx_write_serialisation_history(trx_t *trx, mtr_t *mtr)
     ut_ad(undo->rseg == rseg);
     /* Assign the transaction serialisation number and add any
     undo log to the purge queue. */
-    if (rseg->last_page_no == FIL_NULL)
+    if (UNIV_UNLIKELY(!undo_no))
+    {
+      /* The transaction was rolled back. */
+      commit_empty(mtr);
+      goto done;
+    }
+    else if (rseg->last_page_no == FIL_NULL)
     {
       mysql_mutex_lock(&purge_sys.pq_mutex);
-      trx_sys.assign_new_trx_no(trx);
-      const trx_id_t end{trx->rw_trx_hash_element->no};
-      /* If the rollback segment is not empty, trx->no cannot be less
-      than any trx_t::no already in rseg. User threads only produce
-      events when a rollback segment is empty. */
+      trx_sys.assign_new_trx_no(this);
+      const trx_id_t end{rw_trx_hash_element->no};
+      /* end cannot be less than anything in rseg. User threads only
+      produce events when a rollback segment is empty. */
       purge_sys.purge_queue.push(TrxUndoRsegs{end, *rseg});
       mysql_mutex_unlock(&purge_sys.pq_mutex);
       rseg->last_page_no= undo->hdr_page_no;
       rseg->set_last_commit(undo->hdr_offset, end);
     }
     else
-      trx_sys.assign_new_trx_no(trx);
+      trx_sys.assign_new_trx_no(this);
     UT_LIST_REMOVE(rseg->undo_list, undo);
     /* Change the undo log segment state from TRX_UNDO_ACTIVE, to
     define the transaction as committed in the file based domain,
     at mtr->commit_lsn() obtained in mtr->commit() below. */
-    trx_purge_add_undo_to_history(trx, undo, mtr);
+    trx_purge_add_undo_to_history(this, undo, mtr);
+  done:
     rseg->release();
     rseg->latch.wr_unlock();
   }
@@ -1217,7 +1310,7 @@ ATTRIBUTE_NOINLINE static void trx_commit_cleanup(trx_undo_t *&undo)
 
 TRANSACTIONAL_INLINE inline void trx_t::commit_in_memory(const mtr_t *mtr)
 {
-  /* We already detached from rseg in trx_write_serialisation_history() */
+  /* We already detached from rseg in write_serialisation_history() */
   ut_ad(!rsegs.m_redo.undo);
   read_view.close();
 
@@ -1408,7 +1501,7 @@ TRANSACTIONAL_TARGET void trx_t::commit_low(mtr_t *mtr)
     different rollback segments. However, if a transaction T2 is
     able to see modifications made by a transaction T1, T2 will always
     get a bigger transaction number and a bigger commit lsn than T1. */
-    trx_write_serialisation_history(this, mtr);
+    write_serialisation_history(mtr);
   }
   else if (trx_rseg_t *rseg= rsegs.m_redo.rseg)
   {

storage/innobase/trx/trx0undo.cc

@@ -497,8 +497,7 @@ trx_undo_seg_create(fil_space_t *space, buf_block_t *rseg_hdr, ulint *id,
 
 	ut_ad(slot_no < TRX_RSEG_N_SLOTS);
 
-	*err = fsp_reserve_free_extents(&n_reserved, space, 2, FSP_UNDO,
-					   mtr);
+	*err = fsp_reserve_free_extents(&n_reserved, space, 2, FSP_UNDO, mtr);
 	if (UNIV_UNLIKELY(*err != DB_SUCCESS)) {
 		return NULL;
 	}
@@ -569,6 +568,7 @@ static uint16_t trx_undo_header_create(buf_block_t *undo_page, trx_id_t trx_id,
               start, 2);
   uint16_t prev_log= mach_read_from_2(TRX_UNDO_SEG_HDR + TRX_UNDO_LAST_LOG +
                                       undo_page->page.frame);
+  ut_ad(prev_log < free);
   alignas(4) byte buf[4];
   mach_write_to_2(buf, TRX_UNDO_ACTIVE);
   mach_write_to_2(buf + 2, free);
@@ -1022,7 +1022,6 @@ trx_undo_mem_create_at_db_start(trx_rseg_t *rseg, ulint id, uint32_t page_no)
 	case TRX_UNDO_ACTIVE:
 	case TRX_UNDO_PREPARED:
 		if (UNIV_LIKELY(type != 1)) {
-			trx_no = trx_id + 1;
 			break;
 		}
 		sql_print_error("InnoDB: upgrade from older version than"