From d3400a86fd1029543cb37db9314f2ccfaeb88687 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marko=20M=C3=A4kel=C3=A4?= Date: Thu, 9 Mar 2017 15:58:33 +0200 Subject: [PATCH] Port some cleanup from MariaDB 10.2 on top of MDEV-12288, MDEV-11585: Hard-code innodb_page_size as the undo log page size. InnoDB undo logs currently always use the innodb_page_size, whether they are stored in the system tablespace, in a dedicated undo tablespace, or in the temporary tablespace. Remove redundant page_size parameters. TrxUndoRsegsIterator::set_next(): return bool instead of page_size. Remove trx_sys_t::pending_purge_rseg_array. In MySQL 5.7, there is some redundant code for supposedly handling an upgrade from an earlier version of InnoDB. (This upgrade should be properly handled by MDEV-12289 in MariaDB 10.2.) An upgrade of InnoDB between major MySQL versions should include a slow shutdown (innodb_fast_shutdown=0) of the previous version. A comment in trx_lists_init_at_db_start() confused clean shutdown and slow shutdown. A clean shutdown does not necessarily guarantee that there are no active transactions. A slow shutdown guarantees that. Because there was no code to handle rollback of recovered transactions that happened to use the rollback segment slots that MySQL 5.7.2 repurposed for temporary undo logs, the upgrade is not working in all cases, and we may as well remove the code to handle purging. trx_sys_t::pending_purge_rseg_array: Remove. trx_undo_get_undo_rec_low(): Define as static. Remove the parameter is_redo_rseg. trx_undo_get_undo_rec(), trx_rseg_get_on_id(): Remove the parameter is_redo_rseg. trx_rseg_mem_free(): Remove the second parameter. trx_sys_get_nth_rseg(): Replace with trx_rseg_get_on_id(). trx_rseg_schedule_pending_purge(): Remove. --- storage/innobase/include/trx0purge.h | 14 ++-- storage/innobase/include/trx0rec.h | 11 --- storage/innobase/include/trx0rseg.h | 34 +++------- storage/innobase/include/trx0rseg.ic | 39 ++--------- storage/innobase/include/trx0sys.h | 18 ----- storage/innobase/include/trx0sys.ic | 25 ------- storage/innobase/include/trx0undo.h | 16 +---- storage/innobase/include/trx0undo.ic | 17 ++--- storage/innobase/include/ut0stage.h | 1 + storage/innobase/row/row0purge.cc | 8 +-- storage/innobase/srv/srv0start.cc | 3 +- storage/innobase/trx/trx0purge.cc | 128 +++++++++++++---------------------- storage/innobase/trx/trx0rec.cc | 26 +++---- storage/innobase/trx/trx0roll.cc | 3 +- storage/innobase/trx/trx0rseg.cc | 128 +++++------------------------------ storage/innobase/trx/trx0sys.cc | 24 +------ storage/innobase/trx/trx0trx.cc | 5 +- storage/innobase/trx/trx0undo.cc | 94 ++++++++----------------- 18 files changed, 137 insertions(+), 457 deletions(-) diff --git a/storage/innobase/include/trx0purge.h b/storage/innobase/include/trx0purge.h index 1627da5e04c..ab979d0c5bd 100644 --- a/storage/innobase/include/trx0purge.h +++ b/storage/innobase/include/trx0purge.h @@ -470,23 +470,17 @@ Chooses the rollback segment with the smallest trx_no. */ struct TrxUndoRsegsIterator { /** Constructor */ - TrxUndoRsegsIterator(trx_purge_t* purge_sys); + TrxUndoRsegsIterator(); - /** Sets the next rseg to purge in m_purge_sys. - @return page size of the table for which the log is. - NOTE: if rseg is NULL when this function returns this means that - there are no rollback segments to purge and then the returned page - size object should not be used. */ - const page_size_t set_next(); + /** Sets the next rseg to purge in purge_sys. + @return whether anything is to be purged */ + bool set_next(); private: // Disable copying TrxUndoRsegsIterator(const TrxUndoRsegsIterator&); TrxUndoRsegsIterator& operator=(const TrxUndoRsegsIterator&); - /** The purge system pointer */ - trx_purge_t* m_purge_sys; - /** The current element to process */ TrxUndoRsegs m_trx_undo_rsegs; diff --git a/storage/innobase/include/trx0rec.h b/storage/innobase/include/trx0rec.h index 23135a44bd3..355b6a84d02 100644 --- a/storage/innobase/include/trx0rec.h +++ b/storage/innobase/include/trx0rec.h @@ -220,17 +220,6 @@ trx_undo_report_row_operation( 0 if BTR_NO_UNDO_LOG flag was specified */ MY_ATTRIBUTE((warn_unused_result)); -/******************************************************************//** -Copies an undo record to heap. This function can be called if we know that -the undo log record exists. -@return own: copy of the record */ -trx_undo_rec_t* -trx_undo_get_undo_rec_low( -/*======================*/ - roll_ptr_t roll_ptr, /*!< in: roll pointer to record */ - mem_heap_t* heap, /*!< in: memory heap where copied */ - bool is_redo_rseg) /*!< in: true if redo rseg. */ - MY_ATTRIBUTE((warn_unused_result)); /** status bit used for trx_undo_prev_version_build() */ diff --git a/storage/innobase/include/trx0rseg.h b/storage/innobase/include/trx0rseg.h index a1c02bba735..1de9eeacae4 100644 --- a/storage/innobase/include/trx0rseg.h +++ b/storage/innobase/include/trx0rseg.h @@ -1,6 +1,7 @@ /***************************************************************************** Copyright (c) 1996, 2015, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2017, MariaDB Corporation. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software @@ -26,7 +27,6 @@ Created 3/26/1996 Heikki Tuuri #ifndef trx0rseg_h #define trx0rseg_h -#include "univ.i" #include "trx0types.h" #include "trx0sys.h" #include "fut0lst.h" @@ -35,7 +35,6 @@ Created 3/26/1996 Heikki Tuuri /** Gets a rollback segment header. @param[in] space space where placed @param[in] page_no page number of the header -@param[in] page_size page size @param[in,out] mtr mini-transaction @return rollback segment header, page x-latched */ UNIV_INLINE @@ -43,13 +42,11 @@ trx_rsegf_t* trx_rsegf_get( ulint space, ulint page_no, - const page_size_t& page_size, mtr_t* mtr); /** Gets a newly created rollback segment header. @param[in] space space where placed @param[in] page_no page number of the header -@param[in] page_size page size @param[in,out] mtr mini-transaction @return rollback segment header, page x-latched */ UNIV_INLINE @@ -57,7 +54,6 @@ trx_rsegf_t* trx_rsegf_get_new( ulint space, ulint page_no, - const page_size_t& page_size, mtr_t* mtr); /***************************************************************//** @@ -89,21 +85,21 @@ trx_rsegf_undo_find_free( /*=====================*/ trx_rsegf_t* rsegf, /*!< in: rollback segment header */ mtr_t* mtr); /*!< in: mtr */ -/******************************************************************//** -Looks for a rollback segment, based on the rollback segment id. +/** Get a rollback segment. +@param[in] id rollback segment id @return rollback segment */ UNIV_INLINE trx_rseg_t* -trx_rseg_get_on_id( -/*===============*/ - ulint id, /*!< in: rollback segment id */ - bool is_redo_rseg); /*!< in: true if redo rseg else false. */ +trx_rseg_get_on_id(ulint id) +{ + ut_a(id < TRX_SYS_N_RSEGS); + return(trx_sys->rseg_array[id]); +} /** Creates a rollback segment header. This function is called only when a new rollback segment is created in the database. @param[in] space space id -@param[in] page_size page size @param[in] max_size max size in pages @param[in] rseg_slot_no rseg id == slot number in trx sys @param[in,out] mtr mini-transaction @@ -111,7 +107,6 @@ the database. ulint trx_rseg_header_create( ulint space, - const page_size_t& page_size, ulint max_size, ulint rseg_slot_no, mtr_t* mtr); @@ -124,14 +119,10 @@ trx_rseg_array_init( /*================*/ purge_pq_t* purge_queue); /*!< in: rseg queue */ -/*************************************************************************** -Free's an instance of the rollback segment in memory. */ +/** Free a rollback segment in memory. */ void -trx_rseg_mem_free( -/*==============*/ - trx_rseg_t* rseg, /*!< in, own: instance to free */ - trx_rseg_t** rseg_array); /*!< out: add rseg reference to this - central array. */ +trx_rseg_mem_free(trx_rseg_t* rseg); + /********************************************************************* Creates a rollback segment. */ trx_rseg_t* @@ -175,9 +166,6 @@ struct trx_rseg_t { /** page number of the rollback segment header */ ulint page_no; - /** page size of the relevant tablespace */ - page_size_t page_size; - /** maximum allowed size in pages */ ulint max_size; diff --git a/storage/innobase/include/trx0rseg.ic b/storage/innobase/include/trx0rseg.ic index 9574be67ff8..0a33c747668 100644 --- a/storage/innobase/include/trx0rseg.ic +++ b/storage/innobase/include/trx0rseg.ic @@ -1,6 +1,7 @@ /***************************************************************************** Copyright (c) 1996, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2017, MariaDB Corporation. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software @@ -25,12 +26,10 @@ Created 3/26/1996 Heikki Tuuri #include "srv0srv.h" #include "mtr0log.h" -#include "trx0sys.h" /** Gets a rollback segment header. @param[in] space space where placed @param[in] page_no page number of the header -@param[in] page_size page size @param[in,out] mtr mini-transaction @return rollback segment header, page x-latched */ UNIV_INLINE @@ -38,14 +37,15 @@ trx_rsegf_t* trx_rsegf_get( ulint space, ulint page_no, - const page_size_t& page_size, mtr_t* mtr) { buf_block_t* block; trx_rsegf_t* header; + ut_ad(space <= srv_undo_tablespaces || space == SRV_TMP_SPACE_ID); + block = buf_page_get( - page_id_t(space, page_no), page_size, RW_X_LATCH, mtr); + page_id_t(space, page_no), univ_page_size, RW_X_LATCH, mtr); buf_block_dbg_add_level(block, SYNC_RSEG_HEADER); @@ -57,7 +57,6 @@ trx_rsegf_get( /** Gets a newly created rollback segment header. @param[in] space space where placed @param[in] page_no page number of the header -@param[in] page_size page size @param[in,out] mtr mini-transaction @return rollback segment header, page x-latched */ UNIV_INLINE @@ -65,14 +64,15 @@ trx_rsegf_t* trx_rsegf_get_new( ulint space, ulint page_no, - const page_size_t& page_size, mtr_t* mtr) { buf_block_t* block; trx_rsegf_t* header; + ut_ad(space <= srv_undo_tablespaces || space == SRV_TMP_SPACE_ID); + block = buf_page_get( - page_id_t(space, page_no), page_size, RW_X_LATCH, mtr); + page_id_t(space, page_no), univ_page_size, RW_X_LATCH, mtr); buf_block_dbg_add_level(block, SYNC_RSEG_HEADER_NEW); @@ -146,28 +146,3 @@ trx_rsegf_undo_find_free( return(ULINT_UNDEFINED); } - -/******************************************************************//** -Looks for a rollback segment, based on the rollback segment id. -@return rollback segment */ -UNIV_INLINE -trx_rseg_t* -trx_rseg_get_on_id( -/*===============*/ - ulint id, /*!< in: rollback segment id */ - bool is_redo_rseg) /*!< in: true if redo rseg else false. */ -{ - ut_a(id < TRX_SYS_N_RSEGS); - - /* If redo rseg is being requested and id falls in range of - non-redo rseg that is from slot-1....slot-srv_tmp_undo_logs then - server is being upgraded from pre-5.7.2. In such case return - rseg from pending_purge_rseg_array array. */ - if (is_redo_rseg && trx_sys_is_noredo_rseg_slot(id)) { - ut_ad(trx_sys->pending_purge_rseg_array[id] != NULL); - return(trx_sys->pending_purge_rseg_array[id]); - } - - return(trx_sys->rseg_array[id]); -} - diff --git a/storage/innobase/include/trx0sys.h b/storage/innobase/include/trx0sys.h index 205670ae512..6d8909fba5d 100644 --- a/storage/innobase/include/trx0sys.h +++ b/storage/innobase/include/trx0sys.h @@ -87,16 +87,6 @@ trx_sysf_rseg_find_free( for temp-tablespace as free slots. */ ulint nth_free_slots); /*!< in: allocate nth free slot. 0 means next free slot. */ -/***************************************************************//** -Gets the pointer in the nth slot of the rseg array. -@return pointer to rseg object, NULL if slot not in use */ -UNIV_INLINE -trx_rseg_t* -trx_sys_get_nth_rseg( -/*=================*/ - trx_sys_t* sys, /*!< in: trx system */ - ulint n, /*!< in: index of slot */ - bool is_redo_rseg); /*!< in: true if redo rseg. */ /**********************************************************************//** Gets a pointer to the transaction system file copy and x-locks its page. @return pointer to system file copy, page x-locked */ @@ -619,14 +609,6 @@ struct trx_sys_t { transactions), protected by rseg->mutex */ - trx_rseg_t* const pending_purge_rseg_array[TRX_SYS_N_RSEGS]; - /*!< Pointer array to rollback segments - between slot-1..slot-srv_tmp_undo_logs - that are now replaced by non-redo - rollback segments. We need them for - scheduling purge if any of the rollback - segment has pending records to purge. */ - TrxIdSet rw_trx_set; /*!< Mapping from transaction id to transaction instance */ diff --git a/storage/innobase/include/trx0sys.ic b/storage/innobase/include/trx0sys.ic index fb67022a7f2..309353ac08e 100644 --- a/storage/innobase/include/trx0sys.ic +++ b/storage/innobase/include/trx0sys.ic @@ -63,31 +63,6 @@ trx_sys_hdr_page( && page_id.page_no() == TRX_SYS_PAGE_NO); } -/***************************************************************//** -Gets the pointer in the nth slot of the rseg array. -@return pointer to rseg object, NULL if slot not in use */ -UNIV_INLINE -trx_rseg_t* -trx_sys_get_nth_rseg( -/*=================*/ - trx_sys_t* sys, /*!< in: trx system */ - ulint n, /*!< in: index of slot */ - bool is_redo_rseg) /*!< in: true if redo rseg. */ -{ - ut_ad(n < TRX_SYS_N_RSEGS); - - /* If redo rseg is being requested and id falls in range of - non-redo rseg that is from slot-1....slot-srv_tmp_undo_logs then - server is being upgraded from pre-5.7.2. In such case return - rseg from pending_purge_rseg_array array. */ - if (is_redo_rseg && trx_sys_is_noredo_rseg_slot(n)) { - ut_ad(trx_sys->pending_purge_rseg_array[n] != NULL); - return(trx_sys->pending_purge_rseg_array[n]); - } - - return(sys->rseg_array[n]); -} - /**********************************************************************//** Gets a pointer to the transaction system header and x-latches its page. @return pointer to system header, page x-latched. */ diff --git a/storage/innobase/include/trx0undo.h b/storage/innobase/include/trx0undo.h index ffe2927a2ff..82bf68d363d 100644 --- a/storage/innobase/include/trx0undo.h +++ b/storage/innobase/include/trx0undo.h @@ -1,6 +1,7 @@ /***************************************************************************** Copyright (c) 1996, 2016, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2017, MariaDB Corporation. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software @@ -101,27 +102,19 @@ trx_read_roll_ptr( /** Gets an undo log page and x-latches it. @param[in] page_id page id -@param[in] page_size page size @param[in,out] mtr mini-transaction @return pointer to page x-latched */ UNIV_INLINE page_t* -trx_undo_page_get( - const page_id_t& page_id, - const page_size_t& page_size, - mtr_t* mtr); +trx_undo_page_get(const page_id_t& page_id, mtr_t* mtr); /** Gets an undo log page and s-latches it. @param[in] page_id page id -@param[in] page_size page size @param[in,out] mtr mini-transaction @return pointer to page s-latched */ UNIV_INLINE page_t* -trx_undo_page_get_s_latched( - const page_id_t& page_id, - const page_size_t& page_size, - mtr_t* mtr); +trx_undo_page_get_s_latched(const page_id_t& page_id, mtr_t* mtr); /******************************************************************//** Returns the previous undo record on the page in the specified log, or @@ -191,7 +184,6 @@ trx_undo_get_next_rec( /** Gets the first record in an undo log. @param[in] space undo log header space -@param[in] page_size page size @param[in] page_no undo log header page number @param[in] offset undo log header offset on page @param[in] mode latching mode: RW_S_LATCH or RW_X_LATCH @@ -200,7 +192,6 @@ trx_undo_get_next_rec( trx_undo_rec_t* trx_undo_get_first_rec( ulint space, - const page_size_t& page_size, ulint page_no, ulint offset, ulint mode, @@ -410,7 +401,6 @@ struct trx_undo_t { /*-----------------------------*/ ulint space; /*!< space id where the undo log placed */ - page_size_t page_size; ulint hdr_page_no; /*!< page number of the header page in the undo log */ ulint hdr_offset; /*!< header offset of the undo log on diff --git a/storage/innobase/include/trx0undo.ic b/storage/innobase/include/trx0undo.ic index 6f60d4b53c6..bdb4db22857 100644 --- a/storage/innobase/include/trx0undo.ic +++ b/storage/innobase/include/trx0undo.ic @@ -1,6 +1,7 @@ /***************************************************************************** Copyright (c) 1996, 2013, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2017, MariaDB Corporation. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software @@ -157,17 +158,13 @@ trx_read_roll_ptr( /** Gets an undo log page and x-latches it. @param[in] page_id page id -@param[in] page_size page size @param[in,out] mtr mini-transaction @return pointer to page x-latched */ UNIV_INLINE page_t* -trx_undo_page_get( - const page_id_t& page_id, - const page_size_t& page_size, - mtr_t* mtr) +trx_undo_page_get(const page_id_t& page_id, mtr_t* mtr) { - buf_block_t* block = buf_page_get(page_id, page_size, + buf_block_t* block = buf_page_get(page_id, univ_page_size, RW_X_LATCH, mtr); buf_block_dbg_add_level(block, SYNC_TRX_UNDO_PAGE); @@ -176,17 +173,13 @@ trx_undo_page_get( /** Gets an undo log page and s-latches it. @param[in] page_id page id -@param[in] page_size page size @param[in,out] mtr mini-transaction @return pointer to page s-latched */ UNIV_INLINE page_t* -trx_undo_page_get_s_latched( - const page_id_t& page_id, - const page_size_t& page_size, - mtr_t* mtr) +trx_undo_page_get_s_latched(const page_id_t& page_id, mtr_t* mtr) { - buf_block_t* block = buf_page_get(page_id, page_size, + buf_block_t* block = buf_page_get(page_id, univ_page_size, RW_S_LATCH, mtr); buf_block_dbg_add_level(block, SYNC_TRX_UNDO_PAGE); diff --git a/storage/innobase/include/ut0stage.h b/storage/innobase/include/ut0stage.h index 072ec10c6be..24fd42eea67 100644 --- a/storage/innobase/include/ut0stage.h +++ b/storage/innobase/include/ut0stage.h @@ -1,6 +1,7 @@ /***************************************************************************** Copyright (c) 2014, 2015, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2017, MariaDB Corporation. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software diff --git a/storage/innobase/row/row0purge.cc b/storage/innobase/row/row0purge.cc index c7bdd279a0e..b1a040aa7c4 100644 --- a/storage/innobase/row/row0purge.cc +++ b/storage/innobase/row/row0purge.cc @@ -817,13 +817,7 @@ skip_secondaries: &is_insert, &rseg_id, &page_no, &offset); - /* If table is temp then it can't have its undo log - residing in rollback segment with REDO log enabled. */ - bool is_redo_rseg = - dict_table_is_temporary(node->table) - ? false : true; - rseg = trx_sys_get_nth_rseg( - trx_sys, rseg_id, is_redo_rseg); + rseg = trx_rseg_get_on_id(rseg_id); ut_a(rseg != NULL); ut_a(rseg->id == rseg_id); diff --git a/storage/innobase/srv/srv0start.cc b/storage/innobase/srv/srv0start.cc index 5f73da2d41e..87aa2f23cd1 100644 --- a/storage/innobase/srv/srv0start.cc +++ b/storage/innobase/srv/srv0start.cc @@ -1025,8 +1025,7 @@ srv_undo_tablespaces_init( if (space_id == *it) { trx_rseg_header_create( - *it, univ_page_size, ULINT_MAX, - i, &mtr); + *it, ULINT_MAX, i, &mtr); } } diff --git a/storage/innobase/trx/trx0purge.cc b/storage/innobase/trx/trx0purge.cc index 49748070bf3..b16672f2972 100644 --- a/storage/innobase/trx/trx0purge.cc +++ b/storage/innobase/trx/trx0purge.cc @@ -72,23 +72,20 @@ bool trx_commit_disallowed = false; const TrxUndoRsegs TrxUndoRsegsIterator::NullElement(UINT64_UNDEFINED); /** Constructor */ -TrxUndoRsegsIterator::TrxUndoRsegsIterator(trx_purge_t* purge_sys) +TrxUndoRsegsIterator::TrxUndoRsegsIterator() : - m_purge_sys(purge_sys), m_trx_undo_rsegs(NullElement), m_iter(m_trx_undo_rsegs.end()) { } -/** Sets the next rseg to purge in m_purge_sys. -@return page size of the table for which the log is. -NOTE: if rseg is NULL when this function returns this means that -there are no rollback segments to purge and then the returned page -size object should not be used. */ -const page_size_t +/** Sets the next rseg to purge in purge_sys. +@return whether anything is to be purged */ +inline +bool TrxUndoRsegsIterator::set_next() { - mutex_enter(&m_purge_sys->pq_mutex); + mutex_enter(&purge_sys->pq_mutex); /* Only purge consumes events from the priority queue, user threads only produce the events. */ @@ -102,9 +99,9 @@ TrxUndoRsegsIterator::set_next() number shouldn't increase. Undo increment of expected trx_no done by caller assuming rollback segments from given transaction are done. */ - m_purge_sys->iter.trx_no = (*m_iter)->last_trx_no; + purge_sys->iter.trx_no = (*m_iter)->last_trx_no; - } else if (!m_purge_sys->purge_queue->empty()) { + } else if (!purge_sys->purge_queue->empty()) { /* Read the next element from the queue. Combine elements if they have same transaction number. @@ -114,20 +111,21 @@ TrxUndoRsegsIterator::set_next() rollback segment for purge. */ m_trx_undo_rsegs = NullElement; - while (!m_purge_sys->purge_queue->empty()) { + purge_pq_t& purge_queue = *purge_sys->purge_queue; + + while (!purge_queue.empty()) { if (m_trx_undo_rsegs.get_trx_no() == UINT64_UNDEFINED) { - m_trx_undo_rsegs = - purge_sys->purge_queue->top(); - } else if (purge_sys->purge_queue->top().get_trx_no() == + m_trx_undo_rsegs = purge_queue.top(); + } else if (purge_queue.top().get_trx_no() == m_trx_undo_rsegs.get_trx_no()) { m_trx_undo_rsegs.append( - purge_sys->purge_queue->top()); + purge_queue.top()); } else { break; } - m_purge_sys->purge_queue->pop(); + purge_queue.pop(); } m_iter = m_trx_undo_rsegs.begin(); @@ -137,43 +135,32 @@ TrxUndoRsegsIterator::set_next() m_trx_undo_rsegs = NullElement; m_iter = m_trx_undo_rsegs.end(); - mutex_exit(&m_purge_sys->pq_mutex); - - m_purge_sys->rseg = NULL; + mutex_exit(&purge_sys->pq_mutex); - /* return a dummy object, not going to be used by the caller */ - return(univ_page_size); + purge_sys->rseg = NULL; + return false; } - m_purge_sys->rseg = *m_iter++; - - mutex_exit(&m_purge_sys->pq_mutex); + purge_sys->rseg = *m_iter++; - ut_a(m_purge_sys->rseg != NULL); - - mutex_enter(&m_purge_sys->rseg->mutex); + mutex_exit(&purge_sys->pq_mutex); - ut_a(m_purge_sys->rseg->last_page_no != FIL_NULL); - ut_ad(m_purge_sys->rseg->last_trx_no == m_trx_undo_rsegs.get_trx_no()); + mutex_enter(&purge_sys->rseg->mutex); - /* We assume in purge of externally stored fields that - space id is in the range of UNDO tablespace space ids - unless space is system tablespace */ - ut_a(m_purge_sys->rseg->space <= srv_undo_tablespaces_open - || is_system_tablespace( - m_purge_sys->rseg->space)); + ut_ad(purge_sys->rseg->last_page_no != FIL_NULL); + ut_ad(purge_sys->rseg->last_trx_no == m_trx_undo_rsegs.get_trx_no()); - const page_size_t page_size(m_purge_sys->rseg->page_size); + ut_ad(purge_sys->rseg->space <= srv_undo_tablespaces_open); - ut_a(purge_sys->iter.trx_no <= purge_sys->rseg->last_trx_no); + ut_ad(purge_sys->iter.trx_no <= purge_sys->rseg->last_trx_no); - m_purge_sys->iter.trx_no = m_purge_sys->rseg->last_trx_no; - m_purge_sys->hdr_offset = m_purge_sys->rseg->last_offset; - m_purge_sys->hdr_page_no = m_purge_sys->rseg->last_page_no; + purge_sys->iter.trx_no = purge_sys->rseg->last_trx_no; + purge_sys->hdr_offset = purge_sys->rseg->last_offset; + purge_sys->hdr_page_no = purge_sys->rseg->last_page_no; - mutex_exit(&m_purge_sys->rseg->mutex); + mutex_exit(&purge_sys->rseg->mutex); - return(page_size); + return(true); } /****************************************************************//** @@ -264,7 +251,7 @@ trx_purge_sys_create( purge_sys->view_active = true; - purge_sys->rseg_iter = UT_NEW_NOKEY(TrxUndoRsegsIterator(purge_sys)); + purge_sys->rseg_iter = UT_NEW_NOKEY(TrxUndoRsegsIterator()); } /************************************************************************ @@ -322,7 +309,7 @@ trx_purge_add_update_undo_to_history( trx_undo_t* undo = trx->rsegs.m_redo.undo; trx_rseg_t* rseg = undo->rseg; trx_rsegf_t* rseg_header = trx_rsegf_get( - rseg->space, rseg->page_no, rseg->page_size, mtr); + rseg->space, rseg->page_no, mtr); trx_ulogf_t* undo_header = undo_page + undo->hdr_offset; if (undo->state != TRX_UNDO_CACHED) { @@ -427,12 +414,10 @@ trx_purge_free_segment( mutex_enter(&rseg->mutex); - rseg_hdr = trx_rsegf_get( - rseg->space, rseg->page_no, rseg->page_size, &mtr); + rseg_hdr = trx_rsegf_get(rseg->space, rseg->page_no, &mtr); undo_page = trx_undo_page_get( - page_id_t(rseg->space, hdr_addr.page), rseg->page_size, - &mtr); + page_id_t(rseg->space, hdr_addr.page), &mtr); seg_hdr = undo_page + TRX_UNDO_SEG_HDR; log_hdr = undo_page + hdr_addr.boffset; @@ -525,8 +510,7 @@ trx_purge_truncate_rseg_history( } mutex_enter(&(rseg->mutex)); - rseg_hdr = trx_rsegf_get(rseg->space, rseg->page_no, - rseg->page_size, &mtr); + rseg_hdr = trx_rsegf_get(rseg->space, rseg->page_no, &mtr); hdr_addr = trx_purge_get_log_from_hist( flst_get_last(rseg_hdr + TRX_RSEG_HISTORY, &mtr)); @@ -541,7 +525,7 @@ loop: } undo_page = trx_undo_page_get(page_id_t(rseg->space, hdr_addr.page), - rseg->page_size, &mtr); + &mtr); log_hdr = undo_page + hdr_addr.boffset; @@ -597,8 +581,7 @@ loop: } mutex_enter(&(rseg->mutex)); - rseg_hdr = trx_rsegf_get(rseg->space, rseg->page_no, - rseg->page_size, &mtr); + rseg_hdr = trx_rsegf_get(rseg->space, rseg->page_no, &mtr); hdr_addr = prev_hdr_addr; @@ -1188,15 +1171,6 @@ trx_purge_truncate_history( } } - for (i = 0; i < TRX_SYS_N_RSEGS; ++i) { - trx_rseg_t* rseg = trx_sys->pending_purge_rseg_array[i]; - - if (rseg != NULL) { - ut_a(rseg->id == i); - trx_purge_truncate_rseg_history(rseg, limit); - } - } - /* UNDO tablespace truncate. We will try to truncate as much as we can (greedy approach). This will ensure when the server is idle we try and truncate all the UNDO tablespaces. */ @@ -1237,8 +1211,7 @@ trx_purge_rseg_get_next_history_log( mtr_start(&mtr); undo_page = trx_undo_page_get_s_latched( - page_id_t(rseg->space, rseg->last_page_no), - rseg->page_size, &mtr); + page_id_t(rseg->space, rseg->last_page_no), &mtr); log_hdr = undo_page + rseg->last_offset; @@ -1290,7 +1263,7 @@ trx_purge_rseg_get_next_history_log( log_hdr = trx_undo_page_get_s_latched(page_id_t(rseg->space, prev_log_addr.page), - rseg->page_size, &mtr) + &mtr) + prev_log_addr.boffset; trx_no = mach_read_from_8(log_hdr + TRX_UNDO_TRX_NO); @@ -1323,14 +1296,10 @@ trx_purge_rseg_get_next_history_log( mutex_exit(&rseg->mutex); } -/** Position the purge sys "iterator" on the undo record to use for purging. -@param[in,out] purge_sys purge instance -@param[in] page_size page size */ +/** Position the purge sys "iterator" on the undo record to use for purging. */ static void -trx_purge_read_undo_rec( - trx_purge_t* purge_sys, - const page_size_t& page_size) +trx_purge_read_undo_rec() { ulint offset; ulint page_no; @@ -1348,7 +1317,6 @@ trx_purge_read_undo_rec( undo_rec = trx_undo_get_first_rec( purge_sys->rseg->space, - page_size, purge_sys->hdr_page_no, purge_sys->hdr_offset, RW_S_LATCH, &mtr); @@ -1388,12 +1356,10 @@ void trx_purge_choose_next_log(void) /*===========================*/ { - ut_ad(purge_sys->next_stored == FALSE); + ut_ad(!purge_sys->next_stored); - const page_size_t& page_size = purge_sys->rseg_iter->set_next(); - - if (purge_sys->rseg != NULL) { - trx_purge_read_undo_rec(purge_sys, page_size); + if (purge_sys->rseg_iter->set_next()) { + trx_purge_read_undo_rec(); } else { /* There is nothing to do yet. */ os_thread_yield(); @@ -1428,8 +1394,6 @@ trx_purge_get_next_rec( page_no = purge_sys->page_no; offset = purge_sys->offset; - const page_size_t page_size(purge_sys->rseg->page_size); - if (offset == 0) { /* It is the dummy undo log record, which means that there is no need to purge this undo log */ @@ -1447,7 +1411,7 @@ trx_purge_get_next_rec( mtr_start(&mtr); undo_page = trx_undo_page_get_s_latched(page_id_t(space, page_no), - page_size, &mtr); + &mtr); rec = undo_page + offset; @@ -1505,7 +1469,7 @@ trx_purge_get_next_rec( mtr_start(&mtr); undo_page = trx_undo_page_get_s_latched( - page_id_t(space, page_no), page_size, &mtr); + page_id_t(space, page_no), &mtr); rec = undo_page + offset; } else { diff --git a/storage/innobase/trx/trx0rec.cc b/storage/innobase/trx/trx0rec.cc index f05037afe0b..2855be95f47 100644 --- a/storage/innobase/trx/trx0rec.cc +++ b/storage/innobase/trx/trx0rec.cc @@ -1917,7 +1917,7 @@ trx_undo_report_row_operation( page_no = undo->last_page_no; undo_block = buf_page_get_gen( - page_id_t(undo->space, page_no), undo->page_size, RW_X_LATCH, + page_id_t(undo->space, page_no), univ_page_size, RW_X_LATCH, buf_pool_is_obsolete(undo->withdraw_clock) ? NULL : undo->guess_block, BUF_GET, __FILE__, __LINE__, &mtr); @@ -2043,12 +2043,12 @@ err_exit: Copies an undo record to heap. This function can be called if we know that the undo log record exists. @return own: copy of the record */ +static trx_undo_rec_t* trx_undo_get_undo_rec_low( /*======================*/ roll_ptr_t roll_ptr, /*!< in: roll pointer to record */ - mem_heap_t* heap, /*!< in: memory heap where copied */ - bool is_redo_rseg) /*!< in: true if redo rseg. */ + mem_heap_t* heap) /*!< in: memory heap where copied */ { trx_undo_rec_t* undo_rec; ulint rseg_id; @@ -2061,13 +2061,12 @@ trx_undo_get_undo_rec_low( trx_undo_decode_roll_ptr(roll_ptr, &is_insert, &rseg_id, &page_no, &offset); - rseg = trx_rseg_get_on_id(rseg_id, is_redo_rseg); + rseg = trx_rseg_get_on_id(rseg_id); mtr_start(&mtr); undo_page = trx_undo_page_get_s_latched( - page_id_t(rseg->space, page_no), rseg->page_size, - &mtr); + page_id_t(rseg->space, page_no), &mtr); undo_rec = trx_undo_rec_copy(undo_page + offset, heap); @@ -2083,7 +2082,6 @@ Copies an undo record to heap. the roll pointer: it points to an undo log of this transaction @param[in] heap memory heap where copied -@param[in] is_redo_rseg true if redo rseg. @param[in] name table name @param[out] undo_rec own: copy of the record @retval true if the undo log has been @@ -2097,7 +2095,6 @@ trx_undo_get_undo_rec( roll_ptr_t roll_ptr, trx_id_t trx_id, mem_heap_t* heap, - bool is_redo_rseg, const table_name_t& name, trx_undo_rec_t** undo_rec) { @@ -2107,8 +2104,7 @@ trx_undo_get_undo_rec( missing_history = purge_sys->view.changes_visible(trx_id, name); if (!missing_history) { - *undo_rec = trx_undo_get_undo_rec_low( - roll_ptr, heap, is_redo_rseg); + *undo_rec = trx_undo_get_undo_rec_low(roll_ptr, heap); } rw_lock_s_unlock(&purge_sys->latch); @@ -2193,17 +2189,11 @@ trx_undo_prev_version_build( rec_trx_id = row_get_rec_trx_id(rec, index, offsets); - /* REDO rollback segment are used only for non-temporary objects. - For temporary objects NON-REDO rollback segments are used. */ - bool is_redo_rseg = - dict_table_is_temporary(index->table) ? false : true; if (trx_undo_get_undo_rec( - roll_ptr, rec_trx_id, heap, is_redo_rseg, - index->table->name, &undo_rec)) { + roll_ptr, rec_trx_id, heap, index->table->name, &undo_rec)) { if (v_status & TRX_UNDO_PREV_IN_PURGE) { /* We are fetching the record being purged */ - undo_rec = trx_undo_get_undo_rec_low( - roll_ptr, heap, is_redo_rseg); + undo_rec = trx_undo_get_undo_rec_low(roll_ptr, heap); } else { /* The undo record may already have been purged, during purge or semi-consistent read. */ diff --git a/storage/innobase/trx/trx0roll.cc b/storage/innobase/trx/trx0roll.cc index 1e1a35a2eb1..f06fc77d7b5 100644 --- a/storage/innobase/trx/trx0roll.cc +++ b/storage/innobase/trx/trx0roll.cc @@ -906,8 +906,7 @@ trx_roll_pop_top_rec( ut_ad(mutex_own(&trx->undo_mutex)); page_t* undo_page = trx_undo_page_get_s_latched( - page_id_t(undo->space, undo->top_page_no), - undo->page_size, mtr); + page_id_t(undo->space, undo->top_page_no), mtr); ulint offset = undo->top_offset; diff --git a/storage/innobase/trx/trx0rseg.cc b/storage/innobase/trx/trx0rseg.cc index 2337a80c232..f04a6d597f9 100644 --- a/storage/innobase/trx/trx0rseg.cc +++ b/storage/innobase/trx/trx0rseg.cc @@ -1,6 +1,7 @@ /***************************************************************************** Copyright (c) 1996, 2015, Oracle and/or its affiliates. All Rights Reserved. +Copyright (c) 2017, MariaDB Corporation. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software @@ -42,7 +43,6 @@ Created 3/26/1996 Heikki Tuuri This function is called only when a new rollback segment is created in the database. @param[in] space space id -@param[in] page_size page size @param[in] max_size max size in pages @param[in] rseg_slot_no rseg id == slot number in trx sys @param[in,out] mtr mini-transaction @@ -50,7 +50,6 @@ the database. ulint trx_rseg_header_create( ulint space, - const page_size_t& page_size, ulint max_size, ulint rseg_slot_no, mtr_t* mtr) @@ -79,7 +78,7 @@ trx_rseg_header_create( page_no = block->page.id.page_no(); /* Get the rollback segment file page */ - rsegf = trx_rsegf_get_new(space, page_no, page_size, mtr); + rsegf = trx_rsegf_get_new(space, page_no, mtr); /* Initialize max size field */ mlog_write_ulint(rsegf + TRX_RSEG_MAX_SIZE, max_size, @@ -116,14 +115,9 @@ trx_rseg_header_create( return(page_no); } -/***********************************************************************//** -Free's an instance of the rollback segment in memory. */ +/** Free a rollback segment in memory. */ void -trx_rseg_mem_free( -/*==============*/ - trx_rseg_t* rseg, /* in, own: instance to free */ - trx_rseg_t** rseg_array) /*!< out: add rseg reference to this - central array. */ +trx_rseg_mem_free(trx_rseg_t* rseg) { trx_undo_t* undo; trx_undo_t* next_undo; @@ -146,9 +140,6 @@ trx_rseg_mem_free( trx_undo_mem_free(undo); } - ut_a(*((trx_rseg_t**) rseg_array + rseg->id) == rseg); - *((trx_rseg_t**) rseg_array + rseg->id) = NULL; - ut_free(rseg); } @@ -159,20 +150,13 @@ array in the trx system object. @param[in] id rollback segment id @param[in] space space where the segment is placed @param[in] page_no page number of the segment header -@param[in] page_size page size -@param[in,out] purge_queue rseg queue -@param[out] rseg_array add rseg reference to this central array -@param[in,out] mtr mini-transaction -@return own: rollback segment object */ +@param[in,out] mtr mini-transaction */ static -trx_rseg_t* +void trx_rseg_mem_create( ulint id, ulint space, ulint page_no, - const page_size_t& page_size, - purge_pq_t* purge_queue, - trx_rseg_t** rseg_array, mtr_t* mtr) { ulint len; @@ -186,7 +170,6 @@ trx_rseg_mem_create( rseg->id = id; rseg->space = space; - rseg->page_size.copy_from(page_size); rseg->page_no = page_no; rseg->trx_ref_count = 0; rseg->skip_allocation = false; @@ -200,9 +183,9 @@ trx_rseg_mem_create( UT_LIST_INIT(rseg->undo_list, &trx_undo_t::undo_list); UT_LIST_INIT(rseg->undo_cached, &trx_undo_t::undo_list); - *((trx_rseg_t**) rseg_array + rseg->id) = rseg; + trx_sys->rseg_array[id] = rseg; - rseg_header = trx_rsegf_get_new(space, page_no, page_size, mtr); + rseg_header = trx_rsegf_get_new(space, page_no, mtr); rseg->max_size = mtr_read_ulint( rseg_header + TRX_RSEG_MAX_SIZE, MLOG_4BYTES, mtr); @@ -227,8 +210,8 @@ trx_rseg_mem_create( rseg->last_offset = node_addr.boffset; undo_log_hdr = trx_undo_page_get( - page_id_t(rseg->space, node_addr.page), - rseg->page_size, mtr) + node_addr.boffset; + page_id_t(rseg->space, node_addr.page), mtr) + + node_addr.boffset; rseg->last_trx_no = mach_read_from_8( undo_log_hdr + TRX_UNDO_TRX_NO); @@ -244,56 +227,11 @@ trx_rseg_mem_create( /* There is no need to cover this operation by the purge mutex because we are still bootstrapping. */ - purge_queue->push(elem); + purge_sys->purge_queue->push(elem); } } else { rseg->last_page_no = FIL_NULL; } - - return(rseg); -} - -/******************************************************************** -Check if rseg in given slot needs to be scheduled for purge. */ -static -void -trx_rseg_schedule_pending_purge( -/*============================*/ - trx_sysf_t* sys_header, /*!< in: trx system header */ - purge_pq_t* purge_queue, /*!< in/out: rseg queue */ - ulint slot, /*!< in: check rseg from given slot. */ - mtr_t* mtr) /*!< in: mtr */ -{ - ulint page_no; - ulint space; - - page_no = trx_sysf_rseg_get_page_no(sys_header, slot, mtr); - space = trx_sysf_rseg_get_space(sys_header, slot, mtr); - - if (page_no != FIL_NULL - && is_system_or_undo_tablespace(space)) { - - /* rseg resides in system or undo tablespace and so - this is an upgrade scenario. trx_rseg_mem_create - will add rseg to purge queue if needed. */ - - trx_rseg_t* rseg = NULL; - bool found = true; - const page_size_t& page_size - = is_system_tablespace(space) - ? univ_page_size - : fil_space_get_page_size(space, &found); - - ut_ad(found); - - trx_rseg_t** rseg_array = - ((trx_rseg_t**) trx_sys->pending_purge_rseg_array); - rseg = trx_rseg_mem_create( - slot, space, page_no, page_size, - purge_queue, rseg_array, mtr); - - ut_a(rseg->id == slot); - } } /******************************************************************** @@ -316,41 +254,14 @@ trx_rseg_create_instance( page_no = trx_sysf_rseg_get_page_no(sys_header, i, &mtr); - /* Slot-1....Slot-n are reserved for non-redo rsegs. - Non-redo rsegs are recreated on server re-start so - avoid initializing the existing non-redo rsegs. */ - if (trx_sys_is_noredo_rseg_slot(i)) { - - /* If this is an upgrade scenario then existing rsegs - in range from slot-1....slot-n needs to be scheduled - for purge if there are pending purge operation. */ - trx_rseg_schedule_pending_purge( - sys_header, purge_queue, i, &mtr); - - } else if (page_no != FIL_NULL) { + if (page_no != FIL_NULL) { ulint space; - trx_rseg_t* rseg = NULL; - ut_a(!trx_rseg_get_on_id(i, true)); + ut_a(!trx_rseg_get_on_id(i)); space = trx_sysf_rseg_get_space(sys_header, i, &mtr); - bool found = true; - const page_size_t& page_size - = is_system_tablespace(space) - ? univ_page_size - : fil_space_get_page_size(space, &found); - - ut_ad(found); - - trx_rseg_t** rseg_array = - static_cast(trx_sys->rseg_array); - - rseg = trx_rseg_mem_create( - i, space, page_no, page_size, - purge_queue, rseg_array, &mtr); - - ut_a(rseg->id == i); + trx_rseg_mem_create(i, space, page_no, &mtr); } else { ut_a(trx_sys->rseg_array[i] == NULL); } @@ -396,10 +307,9 @@ trx_rseg_create( ulint id; ulint page_no; trx_sysf_t* sys_header; - page_size_t page_size(space->flags); page_no = trx_rseg_header_create( - space_id, page_size, ULINT_MAX, slot_no, &mtr); + space_id, ULINT_MAX, slot_no, &mtr); if (page_no == FIL_NULL) { mtr_commit(&mtr); @@ -412,12 +322,8 @@ trx_rseg_create( id = trx_sysf_rseg_get_space(sys_header, slot_no, &mtr); ut_a(id == space_id || trx_sys_is_noredo_rseg_slot(slot_no)); - trx_rseg_t** rseg_array = - ((trx_rseg_t**) trx_sys->rseg_array); - - rseg = trx_rseg_mem_create( - slot_no, space_id, page_no, page_size, - purge_sys->purge_queue, rseg_array, &mtr); + trx_rseg_mem_create(slot_no, space_id, page_no, &mtr); + rseg = trx_sys->rseg_array[slot_no]; } mtr_commit(&mtr); diff --git a/storage/innobase/trx/trx0sys.cc b/storage/innobase/trx/trx0sys.cc index 0cc3844cec3..c1fe9329c14 100644 --- a/storage/innobase/trx/trx0sys.cc +++ b/storage/innobase/trx/trx0sys.cc @@ -438,7 +438,7 @@ trx_sysf_create( /* Create the first rollback segment in the SYSTEM tablespace */ slot_no = trx_sysf_rseg_find_free(mtr, false, 0); - page_no = trx_rseg_header_create(TRX_SYS_SPACE, univ_page_size, + page_no = trx_rseg_header_create(TRX_SYS_SPACE, ULINT_MAX, slot_no, mtr); ut_a(slot_no == TRX_SYS_SYSTEM_RSEG_ID); @@ -1188,28 +1188,10 @@ trx_sys_close(void) } /* There can't be any active transactions. */ - trx_rseg_t** rseg_array = static_cast( - trx_sys->rseg_array); for (ulint i = 0; i < TRX_SYS_N_RSEGS; ++i) { - trx_rseg_t* rseg; - - rseg = trx_sys->rseg_array[i]; - - if (rseg != NULL) { - trx_rseg_mem_free(rseg, rseg_array); - } - } - - rseg_array = ((trx_rseg_t**) trx_sys->pending_purge_rseg_array); - - for (ulint i = 0; i < TRX_SYS_N_RSEGS; ++i) { - trx_rseg_t* rseg; - - rseg = trx_sys->pending_purge_rseg_array[i]; - - if (rseg != NULL) { - trx_rseg_mem_free(rseg, rseg_array); + if (trx_rseg_t* rseg = trx_sys->rseg_array[i]) { + trx_rseg_mem_free(rseg); } } diff --git a/storage/innobase/trx/trx0trx.cc b/storage/innobase/trx/trx0trx.cc index c0fb7606887..0ddbd74f072 100644 --- a/storage/innobase/trx/trx0trx.cc +++ b/storage/innobase/trx/trx0trx.cc @@ -730,8 +730,7 @@ trx_resurrect_table_locks( /* trx_rseg_mem_create() may have acquired an X-latch on this page, so we cannot acquire an S-latch. */ undo_page = trx_undo_page_get( - page_id_t(undo->space, undo->top_page_no), undo->page_size, - &mtr); + page_id_t(undo->space, undo->top_page_no), &mtr); undo_rec = undo_page + undo->top_offset; @@ -870,8 +869,6 @@ trx_lists_init_at_db_start(void) ut_a(srv_is_being_started); /* Look from the rollback segments if there exist undo logs for - transactions. Upgrade demands clean shutdown and so there is - not need to look at pending_purge_rseg_array for rollbacking transactions. */ ib_time_t start_time = ut_time(); diff --git a/storage/innobase/trx/trx0undo.cc b/storage/innobase/trx/trx0undo.cc index 12c8010e43e..e1c84582243 100644 --- a/storage/innobase/trx/trx0undo.cc +++ b/storage/innobase/trx/trx0undo.cc @@ -166,14 +166,8 @@ trx_undo_get_prev_rec_from_prev_page( space = page_get_space_id(undo_page); - bool found; - const page_size_t& page_size = fil_space_get_page_size(space, - &found); - - ut_ad(found); - buf_block_t* block = buf_page_get( - page_id_t(space, prev_page_no), page_size, + page_id_t(space, prev_page_no), univ_page_size, shared ? RW_S_LATCH : RW_X_LATCH, mtr); buf_block_dbg_add_level(block, SYNC_TRX_UNDO_PAGE); @@ -213,7 +207,6 @@ trx_undo_get_prev_rec( /** Gets the next record in an undo log from the next page. @param[in] space undo log header space -@param[in] page_size page size @param[in] undo_page undo log page @param[in] page_no undo log header page number @param[in] offset undo log header offset on page @@ -224,7 +217,6 @@ static trx_undo_rec_t* trx_undo_get_next_rec_from_next_page( ulint space, - const page_size_t& page_size, const page_t* undo_page, ulint page_no, ulint offset, @@ -259,10 +251,10 @@ trx_undo_get_next_rec_from_next_page( if (mode == RW_S_LATCH) { next_page = trx_undo_page_get_s_latched( - next_page_id, page_size, mtr); + next_page_id, mtr); } else { ut_ad(mode == RW_X_LATCH); - next_page = trx_undo_page_get(next_page_id, page_size, mtr); + next_page = trx_undo_page_get(next_page_id, mtr); } return(trx_undo_page_get_first_rec(next_page, page_no, offset)); @@ -290,13 +282,7 @@ trx_undo_get_next_rec( space = page_get_space_id(page_align(rec)); - bool found; - const page_size_t& page_size = fil_space_get_page_size(space, - &found); - - ut_ad(found); - - return(trx_undo_get_next_rec_from_next_page(space, page_size, + return(trx_undo_get_next_rec_from_next_page(space, page_align(rec), page_no, offset, RW_S_LATCH, mtr)); @@ -304,7 +290,6 @@ trx_undo_get_next_rec( /** Gets the first record in an undo log. @param[in] space undo log header space -@param[in] page_size page size @param[in] page_no undo log header page number @param[in] offset undo log header offset on page @param[in] mode latching mode: RW_S_LATCH or RW_X_LATCH @@ -313,7 +298,6 @@ trx_undo_get_next_rec( trx_undo_rec_t* trx_undo_get_first_rec( ulint space, - const page_size_t& page_size, ulint page_no, ulint offset, ulint mode, @@ -325,10 +309,9 @@ trx_undo_get_first_rec( const page_id_t page_id(space, page_no); if (mode == RW_S_LATCH) { - undo_page = trx_undo_page_get_s_latched( - page_id, page_size, mtr); + undo_page = trx_undo_page_get_s_latched(page_id, mtr); } else { - undo_page = trx_undo_page_get(page_id, page_size, mtr); + undo_page = trx_undo_page_get(page_id, mtr); } rec = trx_undo_page_get_first_rec(undo_page, page_no, offset); @@ -337,7 +320,7 @@ trx_undo_get_first_rec( return(rec); } - return(trx_undo_get_next_rec_from_next_page(space, page_size, + return(trx_undo_get_next_rec_from_next_page(space, undo_page, page_no, offset, mode, mtr)); } @@ -813,8 +796,7 @@ trx_undo_add_page(trx_t* trx, trx_undo_t* undo, mtr_t* mtr) } header_page = trx_undo_page_get( - page_id_t(undo->space, undo->hdr_page_no), - undo->page_size, mtr); + page_id_t(undo->space, undo->hdr_page_no), mtr); if (!fsp_reserve_free_extents(&n_reserved, undo->space, 1, FSP_UNDO, mtr)) { @@ -878,11 +860,9 @@ trx_undo_free_page( ut_a(hdr_page_no != page_no); ut_ad(mutex_own(&(rseg->mutex))); - undo_page = trx_undo_page_get( - page_id_t(space, page_no), rseg->page_size, mtr); + undo_page = trx_undo_page_get(page_id_t(space, page_no), mtr); - header_page = trx_undo_page_get( - page_id_t(space, hdr_page_no), rseg->page_size, mtr); + header_page = trx_undo_page_get(page_id_t(space, hdr_page_no), mtr); flst_remove(header_page + TRX_UNDO_SEG_HDR + TRX_UNDO_PAGE_LIST, undo_page + TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_NODE, mtr); @@ -895,8 +875,7 @@ trx_undo_free_page( rseg->curr_size--; if (in_history) { - rseg_header = trx_rsegf_get(space, rseg->page_no, - rseg->page_size, mtr); + rseg_header = trx_rsegf_get(space, rseg->page_no, mtr); hist_size = mtr_read_ulint(rseg_header + TRX_RSEG_HISTORY_SIZE, MLOG_4BYTES, mtr); @@ -929,7 +908,6 @@ trx_undo_free_last_page(trx_undo_t* undo, mtr_t* mtr) Other undo logs may still have records on that page, if it is an update undo log. @param[in] space space -@param[in] page_size page size @param[in] hdr_page_no header page number @param[in] hdr_offset header offset @param[in,out] mtr mini-transaction */ @@ -937,7 +915,6 @@ static void trx_undo_empty_header_page( ulint space, - const page_size_t& page_size, ulint hdr_page_no, ulint hdr_offset, mtr_t* mtr) @@ -946,8 +923,7 @@ trx_undo_empty_header_page( trx_ulogf_t* log_hdr; ulint end; - header_page = trx_undo_page_get( - page_id_t(space, hdr_page_no), page_size, mtr); + header_page = trx_undo_page_get(page_id_t(space, hdr_page_no), mtr); log_hdr = header_page + hdr_offset; @@ -975,8 +951,7 @@ trx_undo_truncate_end(trx_undo_t* undo, undo_no_t limit, bool is_temp) trx_undo_rec_t* trunc_here = NULL; page_t* undo_page = trx_undo_page_get( - page_id_t(undo->space, undo->last_page_no), - undo->rseg->page_size, &mtr); + page_id_t(undo->space, undo->last_page_no), &mtr); trx_undo_rec_t* rec = trx_undo_page_get_last_rec( undo_page, undo->hdr_page_no, undo->hdr_offset); while (rec) { @@ -1044,8 +1019,7 @@ loop: mtr.set_log_mode(MTR_LOG_NO_REDO); } - rec = trx_undo_get_first_rec(rseg->space, rseg->page_size, - hdr_page_no, hdr_offset, + rec = trx_undo_get_first_rec(rseg->space, hdr_page_no, hdr_offset, RW_X_LATCH, &mtr); if (rec == NULL) { /* Already empty */ @@ -1069,7 +1043,7 @@ loop: page_no = page_get_page_no(undo_page); if (page_no == hdr_page_no) { - trx_undo_empty_header_page(rseg->space, rseg->page_size, + trx_undo_empty_header_page(rseg->space, hdr_page_no, hdr_offset, &mtr); } else { @@ -1112,7 +1086,7 @@ trx_undo_seg_free( seg_header = trx_undo_page_get(page_id_t(undo->space, undo->hdr_page_no), - undo->page_size, &mtr) + &mtr) + TRX_UNDO_SEG_HDR; file_seg = seg_header + TRX_UNDO_FSEG_HEADER; @@ -1122,8 +1096,7 @@ trx_undo_seg_free( if (finished) { /* Update the rseg header */ rseg_header = trx_rsegf_get( - rseg->space, rseg->page_no, rseg->page_size, - &mtr); + rseg->space, rseg->page_no, &mtr); trx_rsegf_set_nth_undo(rseg_header, undo->id, FIL_NULL, &mtr); @@ -1166,8 +1139,7 @@ trx_undo_mem_create_at_db_start( ut_a(id < TRX_RSEG_N_SLOTS); - undo_page = trx_undo_page_get( - page_id_t(rseg->space, page_no), rseg->page_size, mtr); + undo_page = trx_undo_page_get(page_id_t(rseg->space, page_no), mtr); ut_ad(*reinterpret_cast(TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_TYPE + undo_page) == 0); @@ -1210,8 +1182,7 @@ trx_undo_mem_create_at_db_start( undo->top_page_no = last_addr.page; last_page = trx_undo_page_get( - page_id_t(rseg->space, undo->last_page_no), - rseg->page_size, mtr); + page_id_t(rseg->space, undo->last_page_no), mtr); rec = trx_undo_page_get_last_rec(last_page, page_no, offset); @@ -1250,8 +1221,7 @@ trx_undo_lists_init( mtr_start(&mtr); - rseg_header = trx_rsegf_get_new( - rseg->space, rseg->page_no, rseg->page_size, &mtr); + rseg_header = trx_rsegf_get_new(rseg->space, rseg->page_no, &mtr); for (i = 0; i < TRX_RSEG_N_SLOTS; i++) { ulint page_no; @@ -1278,8 +1248,7 @@ trx_undo_lists_init( mtr_start(&mtr); rseg_header = trx_rsegf_get( - rseg->space, rseg->page_no, rseg->page_size, - &mtr); + rseg->space, rseg->page_no, &mtr); /* Found a used slot */ MONITOR_INC(MONITOR_NUM_UNDO_SLOT_USED); @@ -1330,7 +1299,6 @@ trx_undo_mem_create( undo->rseg = rseg; undo->space = rseg->space; - undo->page_size.copy_from(rseg->page_size); undo->hdr_page_no = page_no; undo->hdr_offset = offset; undo->last_page_no = page_no; @@ -1417,8 +1385,7 @@ trx_undo_create( rseg->curr_size++; - rseg_header = trx_rsegf_get(rseg->space, rseg->page_no, - rseg->page_size, mtr); + rseg_header = trx_rsegf_get(rseg->space, rseg->page_no, mtr); err = trx_undo_seg_create(rseg, rseg_header, &id, &undo_page, mtr); @@ -1478,8 +1445,7 @@ trx_undo_reuse_cached( ut_a(undo->id < TRX_RSEG_N_SLOTS); undo_page = trx_undo_page_get( - page_id_t(undo->space, undo->hdr_page_no), - undo->page_size, mtr); + page_id_t(undo->space, undo->hdr_page_no), mtr); offset = trx_undo_header_create(undo_page, trx_id, mtr); @@ -1503,8 +1469,7 @@ trx_undo_mark_as_dict_operation( page_t* hdr_page; hdr_page = trx_undo_page_get( - page_id_t(undo->space, undo->hdr_page_no), - undo->page_size, mtr); + page_id_t(undo->space, undo->hdr_page_no), mtr); switch (trx_get_dict_operation(trx)) { case TRX_DICT_OP_NONE: @@ -1599,8 +1564,7 @@ trx_undo_set_state_at_finish( ut_a(undo->id < TRX_RSEG_N_SLOTS); undo_page = trx_undo_page_get( - page_id_t(undo->space, undo->hdr_page_no), - undo->page_size, mtr); + page_id_t(undo->space, undo->hdr_page_no), mtr); seg_hdr = undo_page + TRX_UNDO_SEG_HDR; page_hdr = undo_page + TRX_UNDO_PAGE_HDR; @@ -1644,8 +1608,7 @@ trx_undo_set_state_at_prepare( ut_a(undo->id < TRX_RSEG_N_SLOTS); undo_page = trx_undo_page_get( - page_id_t(undo->space, undo->hdr_page_no), - undo->page_size, mtr); + page_id_t(undo->space, undo->hdr_page_no), mtr); seg_hdr = undo_page + TRX_UNDO_SEG_HDR; @@ -1824,10 +1787,9 @@ trx_undo_truncate_tablespace( trx_rseg_t* rseg = undo_trunc->get_ith_rseg(i); rseg->page_no = trx_rseg_header_create( - space_id, univ_page_size, ULINT_MAX, rseg->id, &mtr); + space_id, ULINT_MAX, rseg->id, &mtr); - rseg_header = trx_rsegf_get_new( - space_id, rseg->page_no, rseg->page_size, &mtr); + rseg_header = trx_rsegf_get_new(space_id, rseg->page_no, &mtr); /* Before re-initialization ensure that we free the existing structure. There can't be any active transactions. */ -- 2.11.0