release/src/router/mysql/storage/innodb_plugin/include/trx0purge.h

   1 /*****************************************************************************
   2
   3 Copyright (c) 1996, 2009, Innobase Oy. All Rights Reserved.
   4
   5 This program is free software; you can redistribute it and/or modify it under
   6 the terms of the GNU General Public License as published by the Free Software
   7 Foundation; version 2 of the License.
   8
   9 This program is distributed in the hope that it will be useful, but WITHOUT
  10 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  11 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  12
  13 You should have received a copy of the GNU General Public License along with
  14 this program; if not, write to the Free Software Foundation, Inc.,
  15 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  16
  17 *****************************************************************************/
  18
  19 /**************************************************//**
  20 @file include/trx0purge.h
  21 Purge old versions
  22
  23 Created 3/26/1996 Heikki Tuuri
  24 *******************************************************/
  25
  26 #ifndef trx0purge_h
  27 #define trx0purge_h
  28
  29 #include "univ.i"
  30 #include "trx0types.h"
  31 #include "mtr0mtr.h"
  32 #include "trx0sys.h"
  33 #include "que0types.h"
  34 #include "page0page.h"
  35 #include "usr0sess.h"
  36 #include "fil0fil.h"
  37
  38 /** The global data structure coordinating a purge */
  39 extern trx_purge_t*     purge_sys;
  40
  41 /** A dummy undo record used as a return value when we have a whole undo log
  42 which needs no purge */
  43 extern trx_undo_rec_t   trx_purge_dummy_rec;
  44
  45 /********************************************************************//**
  46 Calculates the file address of an undo log header when we have the file
  47 address of its history list node.
  48 @return file address of the log */
  49 UNIV_INLINE
  50 fil_addr_t
  51 trx_purge_get_log_from_hist(
  52 /*========================*/
  53         fil_addr_t      node_addr);     /*!< in: file address of the history
  54                                         list node of the log */
  55 /*****************************************************************//**
  56 Checks if trx_id is >= purge_view: then it is guaranteed that its update
  57 undo log still exists in the system.
  58 @return TRUE if is sure that it is preserved, also if the function
  59 returns FALSE, it is possible that the undo log still exists in the
  60 system */
  61 UNIV_INTERN
  62 ibool
  63 trx_purge_update_undo_must_exist(
  64 /*=============================*/
  65         trx_id_t        trx_id);/*!< in: transaction id */
  66 /********************************************************************//**
  67 Creates the global purge system control structure and inits the history
  68 mutex. */
  69 UNIV_INTERN
  70 void
  71 trx_purge_sys_create(void);
  72 /*======================*/
  73 /********************************************************************//**
  74 Frees the global purge system control structure. */
  75 UNIV_INTERN
  76 void
  77 trx_purge_sys_close(void);
  78 /*======================*/
  79 /************************************************************************
  80 Adds the update undo log as the first log in the history list. Removes the
  81 update undo log segment from the rseg slot if it is too big for reuse. */
  82 UNIV_INTERN
  83 void
  84 trx_purge_add_update_undo_to_history(
  85 /*=================================*/
  86         trx_t*  trx,            /*!< in: transaction */
  87         page_t* undo_page,      /*!< in: update undo log header page,
  88                                 x-latched */
  89         mtr_t*  mtr);           /*!< in: mtr */
  90 /********************************************************************//**
  91 Fetches the next undo log record from the history list to purge. It must be
  92 released with the corresponding release function.
  93 @return copy of an undo log record or pointer to trx_purge_dummy_rec,
  94 if the whole undo log can skipped in purge; NULL if none left */
  95 UNIV_INTERN
  96 trx_undo_rec_t*
  97 trx_purge_fetch_next_rec(
  98 /*=====================*/
  99         roll_ptr_t*     roll_ptr,/*!< out: roll pointer to undo record */
 100         trx_undo_inf_t** cell,  /*!< out: storage cell for the record in the
 101                                 purge array */
 102         mem_heap_t*     heap);  /*!< in: memory heap where copied */
 103 /*******************************************************************//**
 104 Releases a reserved purge undo record. */
 105 UNIV_INTERN
 106 void
 107 trx_purge_rec_release(
 108 /*==================*/
 109         trx_undo_inf_t* cell);  /*!< in: storage cell */
 110 /*******************************************************************//**
 111 This function runs a purge batch.
 112 @return number of undo log pages handled in the batch */
 113 UNIV_INTERN
 114 ulint
 115 trx_purge(void);
 116 /*===========*/
 117 /******************************************************************//**
 118 Prints information of the purge system to stderr. */
 119 UNIV_INTERN
 120 void
 121 trx_purge_sys_print(void);
 122 /*======================*/
 123
 124 /** The control structure used in the purge operation */
 125 struct trx_purge_struct{
 126         ulint           state;          /*!< Purge system state */
 127         sess_t*         sess;           /*!< System session running the purge
 128                                         query */
 129         trx_t*          trx;            /*!< System transaction running the purge
 130                                         query: this trx is not in the trx list
 131                                         of the trx system and it never ends */
 132         que_t*          query;          /*!< The query graph which will do the
 133                                         parallelized purge operation */
 134         rw_lock_t       latch;          /*!< The latch protecting the purge view.
 135                                         A purge operation must acquire an
 136                                         x-latch here for the instant at which
 137                                         it changes the purge view: an undo
 138                                         log operation can prevent this by
 139                                         obtaining an s-latch here. */
 140         read_view_t*    view;           /*!< The purge will not remove undo logs
 141                                         which are >= this view (purge view) */
 142         mutex_t         mutex;          /*!< Mutex protecting the fields below */
 143         ulonglong       n_pages_handled;/*!< Approximate number of undo log
 144                                         pages processed in purge */
 145         ulonglong       handle_limit;   /*!< Target of how many pages to get
 146                                         processed in the current purge */
 147         /*------------------------------*/
 148         /* The following two fields form the 'purge pointer' which advances
 149         during a purge, and which is used in history list truncation */
 150
 151         trx_id_t        purge_trx_no;   /*!< Purge has advanced past all
 152                                         transactions whose number is less
 153                                         than this */
 154         undo_no_t       purge_undo_no;  /*!< Purge has advanced past all records
 155                                         whose undo number is less than this */
 156 #ifdef UNIV_DEBUG
 157         trx_id_t        done_trx_no;    /* Indicate 'purge pointer' which have
 158                                         purged already accurately. */
 159 #endif /* UNIV_DEBUG */
 160         /*-----------------------------*/
 161         ibool           next_stored;    /*!< TRUE if the info of the next record
 162                                         to purge is stored below: if yes, then
 163                                         the transaction number and the undo
 164                                         number of the record are stored in
 165                                         purge_trx_no and purge_undo_no above */
 166         trx_rseg_t*     rseg;           /*!< Rollback segment for the next undo
 167                                         record to purge */
 168         ulint           page_no;        /*!< Page number for the next undo
 169                                         record to purge, page number of the
 170                                         log header, if dummy record */
 171         ulint           offset;         /*!< Page offset for the next undo
 172                                         record to purge, 0 if the dummy
 173                                         record */
 174         ulint           hdr_page_no;    /*!< Header page of the undo log where
 175                                         the next record to purge belongs */
 176         ulint           hdr_offset;     /*!< Header byte offset on the page */
 177         /*-----------------------------*/
 178         trx_undo_arr_t* arr;            /*!< Array of transaction numbers and
 179                                         undo numbers of the undo records
 180                                         currently under processing in purge */
 181         mem_heap_t*     heap;           /*!< Temporary storage used during a
 182                                         purge: can be emptied after purge
 183                                         completes */
 184 };
 185
 186 #define TRX_PURGE_ON            1       /* purge operation is running */
 187 #define TRX_STOP_PURGE          2       /* purge operation is stopped, or
 188                                         it should be stopped */
 189 #ifndef UNIV_NONINL
 190 #include "trx0purge.ic"
 191 #endif
 192
 193 #endif