MySQL 8.0.31
Source Code Documentation
trx0purge.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 1996, 2022, Oracle and/or its affiliates.
4
5This program is free software; you can redistribute it and/or modify it under
6the terms of the GNU General Public License, version 2.0, as published by the
7Free Software Foundation.
8
9This program is also distributed with certain software (including but not
10limited to OpenSSL) that is licensed under separate terms, as designated in a
11particular file or component or in included license documentation. The authors
12of MySQL hereby grant you an additional permission to link the program and
13your derivative works with the separately licensed software that they have
14included with MySQL.
15
16This program is distributed in the hope that it will be useful, but WITHOUT
17ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
19for more details.
20
21You should have received a copy of the GNU General Public License along with
22this program; if not, write to the Free Software Foundation, Inc.,
2351 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24
25*****************************************************************************/
26
27/** @file include/trx0purge.h
28 Purge old versions
29
30 Created 3/26/1996 Heikki Tuuri
31 *******************************************************/
32
33#ifndef trx0purge_h
34#define trx0purge_h
35
36#include <unordered_set>
37#include "fil0fil.h"
38#include "mtr0mtr.h"
39#include "page0page.h"
40#include "que0types.h"
41#include "read0types.h"
42#include "trx0sys.h"
43#include "trx0types.h"
44#include "univ.i"
45#include "usr0sess.h"
46#ifdef UNIV_HOTBACKUP
47#include "trx0sys.h"
48#endif /* UNIV_HOTBACKUP */
49
50/** The global data structure coordinating a purge */
52
53/** Calculates the file address of an undo log header when we have the file
54 address of its history list node.
55 @return file address of the log */
57 fil_addr_t node_addr); /*!< in: file address of the history
58 list node of the log */
59
60/** Initialize in-memory purge structures */
62
63/** Creates the global purge system control structure and inits the history
64mutex.
65@param[in] n_purge_threads number of purge threads
66@param[in,out] purge_queue UNDO log min binary heap */
67void trx_purge_sys_initialize(uint32_t n_purge_threads,
68 purge_pq_t *purge_queue);
69
70/** Frees the global purge system control structure. */
71void trx_purge_sys_close(void);
72
73/************************************************************************
74Adds the update undo log as the first log in the history list. Removes the
75update undo log segment from the rseg slot if it is too big for reuse. */
77 trx_t *trx, /*!< in: transaction */
78 trx_undo_ptr_t *undo_ptr, /*!< in: update undo log. */
79 page_t *undo_page, /*!< in: update undo log header page,
80 x-latched */
81 bool update_rseg_history_len,
82 /*!< in: if true: update rseg history
83 len else skip updating it. */
84 ulint n_added_logs, /*!< in: number of logs added */
85 mtr_t *mtr); /*!< in: mtr */
86
87/** This function runs a purge batch.
88 @return number of undo log pages handled in the batch */
89ulint trx_purge(ulint n_purge_threads, /*!< in: number of purge tasks to
90 submit to task queue. */
91 ulint limit, /*!< in: the maximum number of
92 records to purge in one batch */
93 bool truncate); /*!< in: truncate history if true */
94
95/** Stop purge and wait for it to stop, move to PURGE_STATE_STOP. */
96void trx_purge_stop(void);
97/** Resume purge, move to PURGE_STATE_RUN. */
98void trx_purge_run(void);
99
100/** Purge states */
102 PURGE_STATE_INIT, /*!< Purge instance created */
103 PURGE_STATE_RUN, /*!< Purge should be running */
104 PURGE_STATE_STOP, /*!< Purge should be stopped */
105 PURGE_STATE_EXIT, /*!< Purge has been shutdown */
106 PURGE_STATE_DISABLED /*!< Purge was never started */
108
109/** Get the purge state.
110 @return purge state. */
112
113// Forward declaration
115
116/** This is the purge pointer/iterator. We need both the undo no and the
117transaction no up to which purge has parsed and applied the records. */
120 // Do nothing
121 }
122
123 /** Purge has advanced past all transactions whose number
124 is less than this */
126
127 /** Purge has advanced past all records whose undo number
128 is less than this. */
130
131 /** The last undo record resided in this space id */
133
134 /** The transaction that created the undo log record,
135 the Modifier trx id */
137};
138
139/* Namespace to hold all the related functions and variables needed
140to truncate an undo tablespace. */
141namespace undo {
142
143/** Magic Number to indicate truncate action is complete. */
144const uint32_t s_magic = 76845412;
145
146/** Truncate Log file Prefix. */
147const char *const s_log_prefix = "undo_";
148
149/** Truncate Log file Extension. */
150const char *const s_log_ext = "trunc.log";
151
152/** The currently used undo space IDs for an undo space number
153along with a boolean showing whether the undo space number is in use. */
156 bool in_use;
157};
158
159/** List of currently used undo space IDs for each undo space number
160along with a boolean showing whether the undo space number is in use. */
161extern struct space_id_account *space_id_bank;
162
163/** Check if the space_id is an undo space ID in the reserved range.
164@param[in] space_id undo tablespace ID
165@return true if it is in the reserved undo space ID range. */
166inline bool is_reserved(space_id_t space_id) {
167 return (space_id >= dict_sys_t::s_min_undo_space_id &&
169}
170
171/** Convert an undo space number (from 1 to 127) into the undo space_id,
172given an index indicating which space_id from the pool assigned to that
173undo number.
174@param[in] space_num undo tablespace number
175@param[in] ndx index of the space_id within that undo number
176@return space_id of the undo tablespace */
177inline space_id_t num2id(space_id_t space_num, size_t ndx) {
178 ut_ad(space_num > 0);
179 ut_ad(space_num <= FSP_MAX_UNDO_TABLESPACES);
181
182 space_id_t space_id = dict_sys_t::s_max_undo_space_id + 1 - space_num -
183 static_cast<space_id_t>(ndx * FSP_MAX_UNDO_TABLESPACES);
184
185 return (space_id);
186}
187
188/** Convert an undo space number (from 1 to 127) into an undo space_id.
189Use the undo::space_id_bank to return the current space_id assigned to
190that undo number.
191@param[in] space_num undo tablespace number
192@return space_id of the undo tablespace */
193inline space_id_t num2id(space_id_t space_num) {
194 ut_ad(space_num > 0);
195 ut_ad(space_num <= FSP_MAX_UNDO_TABLESPACES);
196
197 size_t slot = space_num - 1;
198
199 /* The space_id_back is normally protected by undo::spaces::m_latch.
200 But this can only be called on a specific slot when truncation is not
201 happening on that slot, i.e. the undo tablespace is in use. */
202 ut_ad(undo::space_id_bank[slot].in_use);
203
204 return (undo::space_id_bank[slot].space_id);
205}
206
207/* clang-format off */
208/** Convert an undo space ID into an undo space number.
209NOTE: This may be an undo space_id from a pre-exisiting 5.7
210database which used space_ids from 1 to 127. If so, the
211space_id is the space_num.
212The space_ids are assigned to number ranges in reverse from high to low.
213In addition, the first space IDs for each undo number occur sequentially
214and descending before the second space_id.
215
216Since s_max_undo_space_id = 0xFFFFFFEF, FSP_MAX_UNDO_TABLESPACES = 127
217and s_undo_space_id_range = 400,000:
218 Space ID Space Num Space ID Space Num ... Space ID Space Num
219 0xFFFFFFEF 1 0xFFFFFFEe 2 ... 0xFFFFFF71 127
220 0xFFFFFF70 1 0xFFFFFF6F 2 ... 0xFFFFFEF2 127
221 0xFFFFFEF1 1 0xFFFFFEF0 2 ... 0xFFFFFE73 127
222...
223
224This is done to maintain backward compatibility to when there was only one
225space_id per undo space number.
226@param[in] space_id undo tablespace ID
227@return space number of the undo tablespace */
228/* clang-format on */
229inline space_id_t id2num(space_id_t space_id) {
230 if (!is_reserved(space_id)) {
231 return (space_id);
232 }
233
234 return (((dict_sys_t::s_max_undo_space_id - space_id) %
236 1);
237}
238
239/* Given a reserved undo space_id, return the next space_id for the associated
240undo space number. */
242 ut_ad(is_reserved(space_id));
243
244 space_id_t space_num = id2num(space_id);
245 space_id_t first_id = dict_sys_t::s_max_undo_space_id + 1 - space_num;
246 space_id_t last_id = first_id - (FSP_MAX_UNDO_TABLESPACES *
248
249 return (space_id == SPACE_UNKNOWN || space_id == last_id
250 ? first_id
251 : space_id - FSP_MAX_UNDO_TABLESPACES);
252}
253
254/** Initialize the undo tablespace space_id bank which is a lock free
255repository for information about the space IDs used for undo tablespaces.
256It is used during creation in order to assign an unused space number and
257during truncation in order to assign the next space_id within that
258space_number range. */
259void init_space_id_bank();
260
261/** Note that the undo space number for a space ID is being used.
262Put that space_id into the space_id_bank.
263@param[in] space_id undo tablespace number */
264void use_space_id(space_id_t space_id);
265
266/** Mark that the given undo space number is being used and
267return the next available space_id for that space number.
268@param[in] space_num undo tablespace number
269@return the next tablespace ID to use */
271
272/** Mark an undo number associated with a given space_id as unused and
273available to be reused. This happens when the fil_space_t is closed
274associated with a drop undo tablespace.
275@param[in] space_id Undo Tablespace ID */
276void unuse_space_id(space_id_t space_id);
277
278/** Given a valid undo space_id or SPACE_UNKNOWN, return the next space_id
279for the given space number.
280@param[in] space_id undo tablespace ID
281@param[in] space_num undo tablespace number
282@return the next tablespace ID to use */
283space_id_t next_space_id(space_id_t space_id, space_id_t space_num);
284
285/** Given a valid undo space_id, return the next space_id for that
286space number.
287@param[in] space_id undo tablespace ID
288@return the next tablespace ID to use */
290
291/** Return the next available undo space ID to be used for a new explicit
292undo tablespaces. The slot will be marked as in-use.
293@return next available undo space number if successful.
294@return SPACE_UNKNOWN if failed */
296
297/** Build a standard undo tablespace name from a space_id.
298@param[in] space_id id of the undo tablespace.
299@return tablespace name of the undo tablespace file */
300char *make_space_name(space_id_t space_id);
301
302/** Build a standard undo tablespace file name from a space_id.
303This will create a name like 'undo_001' if the space_id is in the
304reserved range, else it will be like 'undo001'.
305@param[in] space_id id of the undo tablespace.
306@return file_name of the undo tablespace file */
307char *make_file_name(space_id_t space_id);
308
309/** An undo::Tablespace object is used to easily convert between
310undo_space_id and undo_space_num and to create the automatic file_name
311and space name. In addition, it is used in undo::Tablespaces to track
312the trx_rseg_t objects in an Rsegs vector. So we do not allocate the
313Rsegs vector for each object, only when requested by the constructor. */
315 /** Constructor
316 @param[in] id tablespace id */
318 : m_id(id),
319 m_num(undo::id2num(id)),
320 m_implicit(true),
321 m_new(false),
322 m_space_name(),
323 m_file_name(),
326 m_rsegs() {}
327
328 /** Copy Constructor
329 @param[in] other undo tablespace to copy */
331 : m_id(other.id()),
332 m_num(undo::id2num(other.id())),
333 m_implicit(other.is_implicit()),
334 m_new(other.is_new()),
335 m_space_name(),
336 m_file_name(),
339 m_rsegs() {
340 ut_ad(m_id == 0 || is_reserved(m_id));
341
342 set_space_name(other.space_name());
343 set_file_name(other.file_name());
344
345 /* When the copy constructor is used, add an Rsegs
346 vector. This constructor is only used in the global
347 undo::Tablespaces object where rollback segments are
348 tracked. */
349 m_rsegs = ut::new_withkey<Rsegs>(UT_NEW_THIS_FILE_PSI_KEY);
350 }
351
352 /** Destructor */
354 if (m_space_name != nullptr) {
356 m_space_name = nullptr;
357 }
358
359 if (m_file_name != nullptr) {
361 m_file_name = nullptr;
362 }
363
364 if (m_log_file_name != nullptr) {
366 m_log_file_name = nullptr;
367 }
368
369 if (m_log_file_name_old != nullptr) {
371 m_log_file_name_old = nullptr;
372 }
373
374 /* Clear the cached rollback segments. */
375 if (m_rsegs != nullptr) {
377 m_rsegs = nullptr;
378 }
379 }
380
381 /* Determine if this undo space needs to be truncated.
382 @return true if it should be truncated, false if not. */
383 bool needs_truncation();
384
385 /** Change the space_id from its current value.
386 @param[in] space_id The new undo tablespace ID */
387 void set_space_id(space_id_t space_id);
388
389 /** Replace the standard undo space name if it exists with a copy
390 of the undo tablespace name provided.
391 @param[in] new_space_name non-standard undo space name */
392 void set_space_name(const char *new_space_name);
393
394 /** Get the undo tablespace name. Make it if not yet made.
395 NOTE: This is only called from stack objects so there is no
396 race condition. If it is ever called from a shared object
397 like undo::spaces, then it must be protected by the caller.
398 @return tablespace name created from the space_id */
399 char *space_name() {
400 if (m_space_name == nullptr) {
401#ifndef UNIV_HOTBACKUP
403#endif /* !UNIV_HOTBACKUP */
404 }
405
406 return (m_space_name);
407 }
408
409 /** Replace the standard undo file name if it exists with a copy
410 of the file name provided. This name can come in three forms:
411 absolute path, relative path, and basename. Undo ADD DATAFILE
412 does not accept a relative path. So if that comes in here, it
413 was the scanned name and is relative to the datadir.
414 If this is just a basename, add it to srv_undo_dir.
415 @param[in] file_name explicit undo file name */
416 void set_file_name(const char *file_name);
417
418 /** Get the undo space filename. Make it if not yet made.
419 NOTE: This is only called from stack objects so there is no
420 race condition. If it is ever called from a shared object
421 like undo::spaces, then it must be protected by the caller.
422 @return tablespace filename created from the space_id */
423 char *file_name() {
424 if (m_file_name == nullptr) {
426 }
427
428 return (m_file_name);
429 }
430
431 /** Build a log file name based on space_id
432 @param[in] space_id id of the undo tablespace.
433 @param[in] location directory location of the file.
434 @return DB_SUCCESS or error code */
435 char *make_log_file_name(space_id_t space_id, const char *location);
436
437 /** Get the undo log filename. Make it if not yet made.
438 NOTE: This is only called from stack objects so there is no
439 race condition. If it is ever called from a shared object
440 like undo::spaces, then it must be protected by the caller.
441 @return tablespace filename created from the space_id */
443 if (m_log_file_name == nullptr) {
445 }
446
447 return (m_log_file_name);
448 }
449
450 /** Get the old undo log filename from the srv_log_group_home_dir.
451 Make it if not yet made. */
453 if (m_log_file_name_old == nullptr) {
455 }
456
457 return (m_log_file_name_old);
458 }
459
460 /** Get the undo tablespace ID.
461 @return tablespace ID */
462 space_id_t id() { return (m_id); }
463
464 /** Get the undo tablespace number. This is the same as m_id
465 if m_id is 0 or this is a v5.6-5.7 undo tablespace. v8+ undo
466 tablespaces use a space_id from the reserved range.
467 @return undo tablespace number */
470
471 return (m_num);
472 }
473
474 /** Get a reference to the List of rollback segments within
475 this undo tablespace.
476 @return a reference to the Rsegs vector. */
477 Rsegs *rsegs() { return (m_rsegs); }
478
479 /** Report whether this undo tablespace was explicitly created
480 by an SQL statement.
481 @return true if the tablespace was created explicitly. */
482 bool is_explicit() { return (!m_implicit); }
483
484 /** Report whether this undo tablespace was implicitly created.
485 @return true if the tablespace was created implicitly. */
486 bool is_implicit() { return (m_implicit); }
487
488 /** Report whether this undo tablespace was created at startup.
489 @retval true if created at startup.
490 @retval false if pre-existed at startup. */
491 bool is_new() { return (m_new); }
492
493 /** Note that this undo tablespace is being created. */
494 void set_new() { m_new = true; }
495
496 /** Return whether the undo tablespace is active.
497 @return true if active */
498 bool is_active() {
499 if (m_rsegs == nullptr) {
500 return (false);
501 }
502 m_rsegs->s_lock();
503 bool ret = m_rsegs->is_active();
504 m_rsegs->s_unlock();
505 return (ret);
506 }
507
508 /** Return whether the undo tablespace is active. For optimization purposes,
509 do not take a latch.
510 @return true if active */
512 if (m_rsegs == nullptr) {
513 return (false);
514 }
515 return (m_rsegs->is_active());
516 }
517
518 /** Return the rseg at the requested rseg slot if the undo space is active.
519 @param[in] slot The slot of the rseg. 1 to 127
520 @return Rseg pointer of nullptr if the space is not active. */
522 m_rsegs->s_lock();
523 if (!m_rsegs->is_active()) {
524 m_rsegs->s_unlock();
525 return (nullptr);
526 }
527
528 /* Mark the chosen rseg so that it will not be selected
529 for UNDO truncation. */
530 trx_rseg_t *rseg = m_rsegs->at(slot);
531 rseg->trx_ref_count++;
532
533 m_rsegs->s_unlock();
534
535 return (rseg);
536 }
537
538 /** Return whether the undo tablespace is inactive due to
539 implicit selection by the purge thread.
540 @return true if marked for truncation by the purge thread */
542 if (m_rsegs == nullptr) {
543 return (false);
544 }
545 m_rsegs->s_lock();
546 bool ret = m_rsegs->is_inactive_implicit();
547 m_rsegs->s_unlock();
548 return (ret);
549 }
550
551 /** Return whether the undo tablespace was made inactive by
552 ALTER TABLESPACE.
553 @return true if altered inactive */
555 if (m_rsegs == nullptr) {
556 return (false);
557 }
558 m_rsegs->s_lock();
559 bool ret = m_rsegs->is_inactive_explicit();
560 m_rsegs->s_unlock();
561 return (ret);
562 }
563
564 /** Return whether the undo tablespace is empty and ready
565 to be dropped.
566 @return true if empty */
567 bool is_empty() {
568 if (m_rsegs == nullptr) {
569 return (true);
570 }
571 m_rsegs->s_lock();
572 bool ret = m_rsegs->is_empty();
573 m_rsegs->s_unlock();
574 return (ret);
575 }
576
577 /** Set the undo tablespace active for use by transactions. */
578 void set_active() {
579 m_rsegs->x_lock();
581 m_rsegs->x_unlock();
582 }
583
584 /** Set the state of the rollback segments in this undo tablespace to
585 inactive_implicit if currently active. If the state is inactive_explicit,
586 leave as is. Then put the space_id into the callers marked_space_id.
587 This is done when marking a space for truncate. It will not be used
588 for new transactions until it becomes active again. */
589 void set_inactive_implicit(space_id_t *marked_space_id) {
590 m_rsegs->x_lock();
591 if (m_rsegs->is_active()) {
593 }
594 *marked_space_id = m_id;
595
596 m_rsegs->x_unlock();
597 }
598
599 /** Make the undo tablespace inactive so that it will not be
600 used for new transactions. The purge thread will clear out
601 all the undo logs, truncate it, and then mark it empty. */
603 m_rsegs->x_lock();
605 m_rsegs->x_unlock();
606 }
607
608 /** Make the undo tablespace active again so that it will
609 be used for new transactions.
610 If current State is ___ then do:
611 empty: Set active.
612 active_implicit: Ignore. It was not altered inactive. When it is done
613 being truncated it will go back to active.
614 active_explicit: Depends if it is marked for truncation.
615 marked: Set to inactive_implicit. the next state will be active.
616 not yet: Set to active so that it does not get truncated. */
617 void alter_active();
618
619 /** Set the state of the undo tablespace to empty so that it
620 can be dropped. */
621 void set_empty() {
622 m_rsegs->x_lock();
624 m_rsegs->x_unlock();
625 }
626
627 private:
628 /** Undo Tablespace ID. */
630
631 /** Undo Tablespace number, from 1 to 127. This is the
632 7-bit number that is used in a rollback pointer.
633 Use id2num() to get this number from a space_id. */
635
636 /** True if this is an implicit undo tablespace */
638
639 /** True if this undo tablespace was implicitly created when
640 this instance started up. False if it pre-existed. */
641 bool m_new;
642
643 /** The tablespace name, auto-generated when needed from
644 the space number. */
646
647 /** The tablespace file name, auto-generated when needed
648 from the space number. */
650
651 /** The truncation log file name, auto-generated when needed
652 from the space number and the srv_undo_dir. */
654
655 /** The old truncation log file name, auto-generated when needed
656 from the space number and the srv_log_group_home_dir. */
658
659 /** List of rollback segments within this tablespace.
660 This is not always used. Must call init_rsegs to use it. */
662};
663
664/** List of undo tablespaces, each containing a list of
665rollback segments. */
668 std::vector<Tablespace *, ut::allocator<Tablespace *>>;
669
670 public:
672
674
675 /** Initialize */
676 void init();
677
678 /** De-initialize */
679 void deinit();
680
681 /** Clear the contents of the list of Tablespace objects.
682 This does not deallocate any memory. */
683 void clear() {
684 for (auto undo_space : m_spaces) {
685 ut::delete_(undo_space);
686 }
687 m_spaces.clear();
688 }
689
690 /** Get the number of tablespaces tracked by this object. */
691 ulint size() { return (m_spaces.size()); }
692
693 /** See if the list of tablespaces is empty. */
694 bool empty() { return (m_spaces.empty()); }
695
696 /** Get the Tablespace tracked at a position. */
697 Tablespace *at(size_t pos) { return (m_spaces.at(pos)); }
698
699 /** Add a new undo::Tablespace to the back of the vector.
700 The vector has been pre-allocated to 128 so read threads will
701 not loose what is pointed to. If tablespace_name and file_name
702 are standard names, they are optional.
703 @param[in] ref_undo_space undo tablespace */
704 void add(Tablespace &ref_undo_space);
705
706 /** Drop an existing explicit undo::Tablespace.
707 @param[in] undo_space pointer to undo space */
708 void drop(Tablespace *undo_space);
709
710 /** Drop an existing explicit undo::Tablespace.
711 @param[in] ref_undo_space reference to undo space */
712 void drop(Tablespace &ref_undo_space);
713
714 /** Check if the given space_id is in the vector.
715 @param[in] num undo tablespace number
716 @return true if space_id is found, else false */
717 bool contains(space_id_t num) { return (find(num) != nullptr); }
718
719 /** Find the given space_num in the vector.
720 @param[in] num undo tablespace number
721 @return pointer to an undo::Tablespace struct */
723 if (m_spaces.empty()) {
724 return (nullptr);
725 }
726
727 /* The sort method above puts this vector in order by
728 Tablespace::num. If there are no gaps, then we should
729 be able to find it quickly. */
730 space_id_t slot = num - 1;
731 if (slot < m_spaces.size()) {
732 auto undo_space = m_spaces.at(slot);
733 if (undo_space->num() == num) {
734 return (undo_space);
735 }
736 }
737
738 /* If there are gaps in the numbering, do a search. */
739 for (auto undo_space : m_spaces) {
740 if (undo_space->num() == num) {
741 return (undo_space);
742 }
743 }
744
745 return (nullptr);
746 }
747
748 /** Find the first undo space that is marked inactive explicitly.
749 @param[in,out] num_active If there are no inactive_explicit spaces
750 found, this will contain the number of
751 active spaces found.
752 @return pointer to an undo::Tablespace struct */
754 ut_ad(own_latch());
755
756 if (m_spaces.empty()) {
757 return (nullptr);
758 }
759
760 for (auto undo_space : m_spaces) {
761 if (undo_space->is_inactive_explicit()) {
762 return (undo_space);
763 }
764
765 if (num_active != nullptr && undo_space->is_active()) {
766 (*num_active)++;
767 }
768 }
769
770 return (nullptr);
771 }
772
773#ifdef UNIV_DEBUG
774 /** Determine if this thread owns a lock on m_latch. */
775 bool own_latch() {
777 }
778#endif /* UNIV_DEBUG */
779
780 /** Get a shared lock on m_spaces. */
782
783 /** Release a shared lock on m_spaces. */
785
786 /** Get an exclusive lock on m_spaces. */
788
789 /** Release an exclusive lock on m_spaces. */
791
793
794 private:
795 /** RW lock to protect m_spaces.
796 x for adding elements, s for scanning, size() etc. */
798};
799
800/** Mutex for serializing undo tablespace related DDL. These have to do with
801creating and dropping undo tablespaces. */
802extern ib_mutex_t ddl_mutex;
803
804/** A global object that contains a vector of undo::Tablespace structs. */
805extern Tablespaces *spaces;
806
807#ifdef UNIV_DEBUG
808/** Inject a crash if a certain SET GLOBAL DEBUG has been set.
809Before DBUG_SUICIDE(), write an entry about this crash to the error log
810and flush the redo log. */
811void inject_crash(const char *injection_point_name);
812
813/** Inject a failure in the undo truncation debug compiled code at various
814places so that it fails the first time it hits and succeeds after that. */
817 const char *m_inject_name;
818
819 public:
820 Inject_failure_once(const char *inject_name)
821 : m_already_failed{false}, m_inject_name{inject_name} {}
822
823 /** If a certain SET GLOBAL DEBUG has been set and this is the first time
824 this has been called for that injection point, write an entry to the
825 error log and return true so that the caller can cause the failure.
826 @return true iff compiled with debug and the debug point has been set
827 and this it the first call for this debug point. */
828 bool should_fail();
829};
830
831#endif /* UNIV_DEBUG */
832
833/** Create the truncate log file. Needed to track the state of truncate during
834a crash. An auxiliary redo log file undo_<space_id>_trunc.log will be created
835while the truncate of the UNDO is in progress. This file is required during
836recovery to complete the truncate.
837@param[in] undo_space undo tablespace to truncate.
838@return DB_SUCCESS or error code.*/
839dberr_t start_logging(Tablespace *undo_space);
840
841/** Mark completion of undo truncate action by writing magic number
842to the log file and then removing it from the disk.
843If we are going to remove it from disk then why write magic number?
844This is to safeguard from unlink (file-system) anomalies that will
845keep the link to the file even after unlink action is successful
846and ref-count = 0.
847@param[in] space_num number of the undo tablespace to truncate. */
848void done_logging(space_id_t space_num);
849
850/** Check if TRUNCATE_DDL_LOG file exist.
851@param[in] space_num undo tablespace number
852@return true if exist else false. */
854
855/** list of undo tablespaces that need header pages and rollback
856segments written to them at startup. This can be because they are
857newly initialized, were being truncated and the system crashed, or
858they were an old format at startup and were replaced when they were
859opened. Old format undo tablespaces do not have space_ids between
860dict_sys_t::s_min_undo_space_id and dict_sys_t::s_max_undo_space_id
861and they do not contain an RSEG_ARRAY page. */
863
864/** Add undo tablespace to s_under_construction vector.
865@param[in] space_id space id of tablespace to
866truncate */
868
869/** Clear the s_under_construction vector. */
871
872/** Is an undo tablespace under construction at the moment.
873@param[in] space_id space id to check
874@return true if marked for truncate, else false. */
875bool is_under_construction(space_id_t space_id);
876
877/** Set an undo tablespace active. */
878void set_active(space_id_t space_id);
879
880/* Return whether the undo tablespace is active. If this is a
881non-undo tablespace, then it will not be found in spaces and it
882will not be under construction, so this function will return true.
883@param[in] space_id Undo Tablespace ID
884@param[in] get_latch Specifies whether the rsegs->s_lock() is needed.
885@return true if active (non-undo spaces are always active) */
886bool is_active(space_id_t space_id, bool get_latch = true);
887
888constexpr ulint TRUNCATE_FREQUENCY = 128;
889
890/** Track an UNDO tablespace marked for truncate. */
891class Truncate {
892 public:
893 /** Constructor. */
895
896 /** Destructor. */
897 ~Truncate() = default;
898
899 /** Is tablespace selected for truncate.
900 @return true if undo tablespace is marked for truncate */
901 bool is_marked() const { return (m_space_id_marked != SPACE_UNKNOWN); }
902
903 /** Mark the undo tablespace selected for truncate as empty
904 so that it will be truncated next. */
906
907 /** Is the tablespace selected for truncate empty of undo logs yet?
908 @return true if the marked undo tablespace has no more undo logs */
910
911 /** Mark the tablespace for truncate.
912 @param[in] undo_space undo tablespace to truncate. */
913 void mark(Tablespace *undo_space);
914
915 /** Get the ID of the tablespace marked for truncate.
916 @return tablespace ID marked for truncate. */
918 return (id2num(m_space_id_marked));
919 }
920
921 /** Reset for next rseg truncate. */
922 void reset() {
923 reset_timer();
926 }
927
928 /** Get the undo tablespace number to start a scan.
929 Re-adjust in case the spaces::size() went down.
930 @return undo space_num to start scanning. */
933
934 Tablespace *undo_space = undo::spaces->at(s_scan_pos);
935
936 return (undo_space->num());
937 }
938
939 /** Increment the scanning position in a round-robin fashion.
940 @return undo space_num at incremented scanning position. */
942 /** Round-robin way of selecting an undo tablespace for the truncate
943 operation. Once we reach the end of the list of known undo tablespace
944 IDs, move back to the first undo tablespace ID. This will scan active
945 as well as inactive undo tablespaces. */
946 s_scan_pos = (s_scan_pos + 1) % undo::spaces->size();
947
948 return (get_scan_space_num());
949 }
950
951 /** Check if the given space id is equal to the space ID that is marked for
952 truncation.
953 @return true if they are equal, false otherwise. */
954 bool is_equal(space_id_t space_id) const {
955 return (m_space_id_marked == space_id);
956 }
957
958 /** @return the number of milliseconds since last reset. */
959 int64_t check_timer() const { return (m_timer.elapsed()); }
960
961 /** Reset the timer. */
963
964 private:
965 /** UNDO space ID that is marked for truncate. */
967
968 /** This is true if the marked space is empty of undo logs and ready
969 to truncate. We leave the rsegs object 'inactive' until after it is
970 truncated and rebuilt. This allow the code to do the check for undo
971 logs only once. */
973
974 /** Elapsed time since last truncate check. */
976
977 /** Start scanning for UNDO tablespace from this vector position. This is
978 to avoid bias selection of one tablespace always. */
979 static size_t s_scan_pos;
980
981}; /* class Truncate */
982
983} /* namespace undo */
984
985/** The control structure used in the purge operation */
987 /** System session running the purge query */
989
990 /** System transaction running the purge query: this trx is not in the trx
991 list of the trx system and it never ends */
993#ifndef UNIV_HOTBACKUP
994 /** The latch protecting the purge view. A purge operation must acquire an
995 x-latch here for the instant at which it changes the purge view: an undo
996 log operation can prevent this by obtaining an s-latch here. It also
997 protects state and running */
999#endif /* !UNIV_HOTBACKUP */
1000
1001 /** State signal event */
1003
1004 /** Counter to track number stops */
1006
1007 /** true, if purge is active, we check this without the latch too */
1008 volatile bool running;
1009
1010 /** Purge coordinator thread states, we check this in several places without
1011 holding the latch. */
1013
1014 /** The query graph which will do the parallelized purge operation */
1016
1017 /** The purge will not remove undo logs which are >= this view (purge view) */
1019
1020 /** true if view is active */
1022
1023 /** Count of total tasks submitted to the task queue */
1025
1026 /** Count of total tasks completed */
1027 std::atomic<ulint> n_completed;
1028
1029 /* The following two fields form the 'purge pointer' which advances
1030 during a purge, and which is used in history list truncation */
1031
1032 /** Limit up to which we have read and parsed the UNDO log records. Not
1033 necessarily purged from the indexes. Note that this can never be less than
1034 the limit below, we check for this invariant in trx0purge.cc */
1036
1037 /** The 'purge pointer' which advances during a purge, and which is used in
1038 history list truncation */
1040#ifdef UNIV_DEBUG
1041 /** Indicate 'purge pointer' which have purged already accurately. */
1043#endif /* UNIV_DEBUG */
1044
1045 /** true if the info of the next record to purge is stored below: if yes, then
1046 the transaction number and the undo number of the record are stored in
1047 purge_trx_no and purge_undo_no above */
1049
1050 /** Rollback segment for the next undo record to purge */
1052
1053 /** Page number for the next undo record to purge, page number of the log
1054 header, if dummy record */
1056
1057 /** Page offset for the next undo record to purge, 0 if the dummy record */
1059
1060 /** Header page of the undo log where the next record to purge belongs */
1062
1063 /** Header byte offset on the page */
1065
1066 /** Iterator to get the next rseg to process */
1068
1069 /** Binary min-heap, ordered on TrxUndoRsegs::trx_no. It is protected
1070 by the pq_mutex */
1072
1073 /** Mutex protecting purge_queue */
1075
1076 /** Track UNDO tablespace marked for truncate. */
1078
1079 /** Heap for reading the undo log records */
1081
1082 /** Set of all THDs allocated by the purge system. */
1084
1085 /** Set of all rseg queue. */
1086 std::vector<trx_rseg_t *> rsegs_queue;
1087};
1088
1089/** Choose the rollback segment with the smallest trx_no. */
1091 /** Constructor */
1093
1094 /** Sets the next rseg to purge in m_purge_sys.
1095 @return page size of the table for which the log is.
1096 NOTE: if rseg is NULL when this function returns this means that
1097 there are no rollback segments to purge and then the returned page
1098 size object should not be used. */
1099 const page_size_t set_next();
1100
1101 private:
1102 // Disable copying
1105
1106 /** The purge system pointer */
1108
1109 /** The current element to process */
1111
1112 /** Track the current element in m_trx_undo_rseg */
1114
1115 /** Sentinel value */
1117};
1118
1119#include "trx0purge.ic"
1120
1121#endif /* trx0purge_h */
uint32_t space_id_t
Tablespace identifier.
Definition: api0api.h:50
uint32_t page_no_t
Page number.
Definition: api0api.h:48
Read view lists the trx ids of those transactions for which a consistent read should not see the modi...
Definition: read0types.h:47
This is a wrapper for a std::vector of trx_rseg_t object pointers.
Definition: trx0types.h:293
void set_empty()
Set the state of the undo tablespace to empty so that it can be dropped.
Definition: trx0types.h:412
void set_inactive_implicit()
Set the state of the rollback segments in this undo tablespace to inactive_implicit.
Definition: trx0types.h:400
void set_active()
Set the state of the rollback segments in this undo tablespace to ACTIVE for use by new transactions.
Definition: trx0types.h:393
void s_lock()
Acquire the shared lock on m_rsegs.
Definition: trx0types.h:357
bool is_empty()
Return whether the undo tablespace is empty and ready to be dropped.
Definition: trx0types.h:385
bool is_inactive_implicit()
Return whether the undo tablespace is inactive due to implicit selection by the purge thread.
Definition: trx0types.h:375
bool is_inactive_explicit()
Return whether the undo tablespace was made inactive by ALTER TABLESPACE.
Definition: trx0types.h:380
void s_unlock()
Release the shared lock on m_rsegs.
Definition: trx0types.h:360
void set_inactive_explicit()
Make the undo tablespace inactive so that it will not be used for new transactions.
Definition: trx0types.h:408
bool is_active()
Return whether the undo tablespace is active.
Definition: trx0types.h:370
void x_unlock()
Release the exclusive lock on m_rsegs.
Definition: trx0types.h:366
void x_lock()
Acquire the exclusive lock on m_rsegs.
Definition: trx0types.h:363
trx_rseg_t * at(ulint slot)
Find the rseg at the given slot in this vector.
Definition: trx0types.h:337
List of undo tablespace IDs.
Definition: trx0sys.h:350
Data structure that contains the information about shared tablespaces.
Definition: fsp0space.h:46
Rollback segments from a given transaction with trx-no scheduled for purge.
Definition: trx0types.h:516
For measuring time elapsed.
Definition: ut0ut.h:299
void reset()
Reset the timer to the current time.
Definition: ut0ut.h:308
int64_t elapsed() const noexcept
Definition: ut0ut.h:312
Page size descriptor.
Definition: page0size.h:49
Inject a failure in the undo truncation debug compiled code at various places so that it fails the fi...
Definition: trx0purge.h:815
const char * m_inject_name
Definition: trx0purge.h:817
bool should_fail()
If a certain SET GLOBAL DEBUG has been set and this is the first time this has been called for that i...
Definition: trx0purge.cc:926
bool m_already_failed
Definition: trx0purge.h:816
Inject_failure_once(const char *inject_name)
Definition: trx0purge.h:820
List of undo tablespaces, each containing a list of rollback segments.
Definition: trx0purge.h:666
ulint size()
Get the number of tablespaces tracked by this object.
Definition: trx0purge.h:691
void s_unlock()
Release a shared lock on m_spaces.
Definition: trx0purge.h:784
Tablespace * find_first_inactive_explicit(size_t *num_active)
Find the first undo space that is marked inactive explicitly.
Definition: trx0purge.h:753
Tablespaces()
Definition: trx0purge.h:671
~Tablespaces()
Definition: trx0purge.h:673
std::vector< Tablespace *, ut::allocator< Tablespace * > > Tablespaces_Vector
Definition: trx0purge.h:668
void init()
Initialize.
Definition: trx0purge.cc:2617
void s_lock()
Get a shared lock on m_spaces.
Definition: trx0purge.h:781
Tablespaces_Vector m_spaces
Definition: trx0purge.h:792
void add(Tablespace &ref_undo_space)
Add a new undo::Tablespace to the back of the vector.
Definition: trx0purge.cc:2646
void x_unlock()
Release an exclusive lock on m_spaces.
Definition: trx0purge.h:790
bool contains(space_id_t num)
Check if the given space_id is in the vector.
Definition: trx0purge.h:717
void deinit()
De-initialize.
Definition: trx0purge.cc:2632
void x_lock()
Get an exclusive lock on m_spaces.
Definition: trx0purge.h:787
bool own_latch()
Determine if this thread owns a lock on m_latch.
Definition: trx0purge.h:775
void drop(Tablespace *undo_space)
Drop an existing explicit undo::Tablespace.
Definition: trx0purge.cc:2661
bool empty()
See if the list of tablespaces is empty.
Definition: trx0purge.h:694
void clear()
Clear the contents of the list of Tablespace objects.
Definition: trx0purge.h:683
rw_lock_t * m_latch
RW lock to protect m_spaces.
Definition: trx0purge.h:797
Tablespace * at(size_t pos)
Get the Tablespace tracked at a position.
Definition: trx0purge.h:697
Tablespace * find(space_id_t num)
Find the given space_num in the vector.
Definition: trx0purge.h:722
Track an UNDO tablespace marked for truncate.
Definition: trx0purge.h:891
Truncate()
Constructor.
Definition: trx0purge.h:894
void reset()
Reset for next rseg truncate.
Definition: trx0purge.h:922
void set_marked_space_empty()
Mark the undo tablespace selected for truncate as empty so that it will be truncated next.
Definition: trx0purge.h:905
bool is_equal(space_id_t space_id) const
Check if the given space id is equal to the space ID that is marked for truncation.
Definition: trx0purge.h:954
ib::Timer m_timer
Elapsed time since last truncate check.
Definition: trx0purge.h:975
void reset_timer()
Reset the timer.
Definition: trx0purge.h:962
space_id_t get_scan_space_num() const
Get the undo tablespace number to start a scan.
Definition: trx0purge.h:931
~Truncate()=default
Destructor.
bool m_marked_space_is_empty
This is true if the marked space is empty of undo logs and ready to truncate.
Definition: trx0purge.h:972
int64_t check_timer() const
Definition: trx0purge.h:959
bool is_marked_space_empty() const
Is the tablespace selected for truncate empty of undo logs yet?
Definition: trx0purge.h:909
bool is_marked() const
Is tablespace selected for truncate.
Definition: trx0purge.h:901
space_id_t m_space_id_marked
UNDO space ID that is marked for truncate.
Definition: trx0purge.h:966
space_id_t get_marked_space_num() const
Get the ID of the tablespace marked for truncate.
Definition: trx0purge.h:917
static size_t s_scan_pos
Start scanning for UNDO tablespace from this vector position.
Definition: trx0purge.h:979
void mark(Tablespace *undo_space)
Mark the tablespace for truncate.
Definition: trx0purge.cc:1316
space_id_t increment_scan() const
Increment the scanning position in a round-robin fashion.
Definition: trx0purge.h:941
dberr_t
Definition: db0err.h:38
char * pos
Definition: do_ctype.cc:76
The low-level file system.
constexpr space_id_t SPACE_UNKNOWN
Unknown space id.
Definition: fil0fil.h:1128
constexpr size_t FSP_MAX_UNDO_TABLESPACES
Definition: fsp0types.h:402
constexpr size_t FSP_MAX_ROLLBACK_SEGMENTS
Definition: fsp0types.h:404
Mini-transaction buffer.
Definition: trx0purge.h:141
bool is_active_truncate_log_present(space_id_t space_num)
Check if TRUNCATE_DDL_LOG file exist.
Definition: trx0purge.cc:1042
void done_logging(space_id_t space_num)
Mark completion of undo truncate action by writing magic number to the log file and then removing it ...
Definition: trx0purge.cc:990
char * make_space_name(space_id_t space_id)
Build a standard undo tablespace name from a space_id.
Definition: trx0purge.cc:778
char * make_file_name(space_id_t space_id)
Build a standard undo tablespace file name from a space_id.
Definition: trx0purge.cc:798
space_id_t use_next_space_id(space_id_t space_num)
Mark that the given undo space number is being used and return the next available space_id for that s...
Definition: trx0purge.cc:694
const char *const s_log_prefix
Truncate Log file Prefix.
Definition: trx0purge.h:147
ib_mutex_t ddl_mutex
Mutex for serializing undo tablespace related DDL.
Definition: trx0purge.cc:606
bool is_reserved(space_id_t space_id)
Check if the space_id is an undo space ID in the reserved range.
Definition: trx0purge.h:166
struct space_id_account * space_id_bank
List of currently used undo space IDs for each undo space number along with a boolean showing whether...
Definition: trx0purge.cc:613
space_id_t get_next_available_space_num()
Return the next available undo space ID to be used for a new explicit undo tablespaces.
Definition: trx0purge.cc:712
space_id_t id2next_id(space_id_t space_id)
Definition: trx0purge.h:241
void clear_construction_list()
Clear the s_under_construction vector.
Definition: trx0purge.cc:1124
dberr_t start_logging(Tablespace *undo_space)
Create the truncate log file.
Definition: trx0purge.cc:939
const uint32_t s_magic
Magic Number to indicate truncate action is complete.
Definition: trx0purge.h:144
constexpr ulint TRUNCATE_FREQUENCY
Definition: trx0purge.h:888
void set_active(space_id_t space_id)
Set an undo tablespace active.
Definition: trx0purge.cc:1140
space_id_t id2num(space_id_t space_id)
Convert an undo space ID into an undo space number.
Definition: trx0purge.h:229
void inject_crash(const char *injection_point_name)
Inject a crash if a certain SET GLOBAL DEBUG has been set.
Definition: trx0purge.cc:920
bool is_under_construction(space_id_t space_id)
Is an undo tablespace under construction at the moment.
Definition: trx0purge.cc:1129
Space_Ids s_under_construction
list of undo tablespaces that need header pages and rollback segments written to them at startup.
Definition: trx0purge.cc:1192
void add_space_to_construction_list(space_id_t space_id)
Add undo tablespace to s_under_construction vector.
Definition: trx0purge.cc:1119
Tablespaces * spaces
A global object that contains a vector of undo::Tablespace structs.
Definition: trx0purge.cc:609
space_id_t next_space_id(space_id_t space_id, space_id_t space_num)
Given a valid undo space_id or SPACE_UNKNOWN, return the next space_id for the given space number.
Definition: trx0purge.cc:664
void unuse_space_id(space_id_t space_id)
Mark an undo number associated with a given space_id as unused and available to be reused.
Definition: trx0purge.cc:650
space_id_t num2id(space_id_t space_num, size_t ndx)
Convert an undo space number (from 1 to 127) into the undo space_id, given an index indicating which ...
Definition: trx0purge.h:177
void use_space_id(space_id_t space_id)
Note that the undo space number for a space ID is being used.
Definition: trx0purge.cc:637
bool is_active(space_id_t space_id, bool get_latch=true)
Definition: trx0purge.cc:1159
void init_space_id_bank()
Initialize the undo tablespace space_id bank which is a lock free repository for information about th...
Definition: trx0purge.cc:623
const char *const s_log_ext
Truncate Log file Extension.
Definition: trx0purge.h:150
std::unordered_set< Key, std::hash< Key >, std::equal_to< Key >, ut::allocator< Key > > unordered_set
Definition: ut0new.h:2868
void delete_(T *ptr) noexcept
Releases storage which has been dynamically allocated through any of the ut::new*() variants.
Definition: ut0new.h:807
void free(void *ptr) noexcept
Releases storage which has been dynamically allocated through any of the ut::malloc*(),...
Definition: ut0new.h:715
Index page routines.
byte page_t
Type of the index page.
Definition: page0types.h:151
Query graph global types.
Cursor read.
char * srv_log_group_home_dir
Definition: srv0srv.cc:234
char * srv_undo_dir
Server undo tablespaces directory, can be absolute path.
Definition: srv0srv.cc:151
Choose the rollback segment with the smallest trx_no.
Definition: trx0purge.h:1090
const page_size_t set_next()
Sets the next rseg to purge in m_purge_sys.
Definition: trx0purge.cc:106
static const TrxUndoRsegs NullElement
Sentinel value.
Definition: trx0purge.h:1116
TrxUndoRsegsIterator(trx_purge_t *purge_sys)
Constructor.
Definition: trx0purge.cc:96
Rsegs_array< 2 >::iterator m_iter
Track the current element in m_trx_undo_rseg.
Definition: trx0purge.h:1113
TrxUndoRsegsIterator(const TrxUndoRsegsIterator &)
TrxUndoRsegs m_trx_undo_rsegs
The current element to process.
Definition: trx0purge.h:1110
TrxUndoRsegsIterator & operator=(const TrxUndoRsegsIterator &)
trx_purge_t * m_purge_sys
The purge system pointer.
Definition: trx0purge.h:1107
static constexpr space_id_t s_undo_space_id_range
The number of space IDs dedicated to each undo tablespace.
Definition: dict0dict.h:1102
static constexpr space_id_t s_max_undo_space_id
The highest undo tablespace ID.
Definition: dict0dict.h:1109
static constexpr space_id_t s_min_undo_space_id
The lowest undo tablespace ID.
Definition: dict0dict.h:1105
File space address.
Definition: fil0fil.h:1139
The info structure stored at the beginning of a heap block.
Definition: mem0mem.h:299
Mini-transaction handle and buffer.
Definition: mtr0mtr.h:181
InnoDB condition variable.
Definition: os0event.cc:62
This is the purge pointer/iterator.
Definition: trx0purge.h:118
purge_iter_t()
Definition: trx0purge.h:119
undo_no_t undo_no
Purge has advanced past all records whose undo number is less than this.
Definition: trx0purge.h:129
trx_id_t modifier_trx_id
The transaction that created the undo log record, the Modifier trx id.
Definition: trx0purge.h:136
space_id_t undo_rseg_space
The last undo record resided in this space id.
Definition: trx0purge.h:132
trx_id_t trx_no
Purge has advanced past all transactions whose number is less than this.
Definition: trx0purge.h:125
Definition: que0que.h:300
The structure used in the spin lock implementation of a read-write lock.
Definition: sync0rw.h:361
Definition: usr0sess.h:53
The control structure used in the purge operation.
Definition: trx0purge.h:986
purge_pq_t * purge_queue
Binary min-heap, ordered on TrxUndoRsegs::trx_no.
Definition: trx0purge.h:1071
bool next_stored
true if the info of the next record to purge is stored below: if yes, then the transaction number and...
Definition: trx0purge.h:1048
volatile purge_state_t state
Purge coordinator thread states, we check this in several places without holding the latch.
Definition: trx0purge.h:1012
ulint offset
Page offset for the next undo record to purge, 0 if the dummy record.
Definition: trx0purge.h:1058
purge_iter_t iter
Limit up to which we have read and parsed the UNDO log records.
Definition: trx0purge.h:1035
TrxUndoRsegsIterator * rseg_iter
Iterator to get the next rseg to process.
Definition: trx0purge.h:1067
std::vector< trx_rseg_t * > rsegs_queue
Set of all rseg queue.
Definition: trx0purge.h:1086
mem_heap_t * heap
Heap for reading the undo log records.
Definition: trx0purge.h:1080
purge_iter_t limit
The 'purge pointer' which advances during a purge, and which is used in history list truncation.
Definition: trx0purge.h:1039
volatile bool running
true, if purge is active, we check this without the latch too
Definition: trx0purge.h:1008
ut::unordered_set< THD * > thds
Set of all THDs allocated by the purge system.
Definition: trx0purge.h:1083
purge_iter_t done
Indicate 'purge pointer' which have purged already accurately.
Definition: trx0purge.h:1042
ReadView view
The purge will not remove undo logs which are >= this view (purge view)
Definition: trx0purge.h:1018
que_t * query
The query graph which will do the parallelized purge operation.
Definition: trx0purge.h:1015
trx_t * trx
System transaction running the purge query: this trx is not in the trx list of the trx system and it ...
Definition: trx0purge.h:992
volatile ulint n_submitted
Count of total tasks submitted to the task queue.
Definition: trx0purge.h:1024
ulint hdr_offset
Header byte offset on the page.
Definition: trx0purge.h:1064
page_no_t page_no
Page number for the next undo record to purge, page number of the log header, if dummy record.
Definition: trx0purge.h:1055
bool view_active
true if view is active
Definition: trx0purge.h:1021
undo::Truncate undo_trunc
Track UNDO tablespace marked for truncate.
Definition: trx0purge.h:1077
page_no_t hdr_page_no
Header page of the undo log where the next record to purge belongs.
Definition: trx0purge.h:1061
ulint n_stop
Counter to track number stops.
Definition: trx0purge.h:1005
PQMutex pq_mutex
Mutex protecting purge_queue.
Definition: trx0purge.h:1074
std::atomic< ulint > n_completed
Count of total tasks completed.
Definition: trx0purge.h:1027
sess_t * sess
System session running the purge query.
Definition: trx0purge.h:988
trx_rseg_t * rseg
Rollback segment for the next undo record to purge.
Definition: trx0purge.h:1051
rw_lock_t latch
The latch protecting the purge view.
Definition: trx0purge.h:998
os_event_t event
State signal event.
Definition: trx0purge.h:1002
The rollback segment memory object.
Definition: trx0types.h:176
std::atomic< size_t > trx_ref_count
Reference counter to track rseg allocated transactions.
Definition: trx0types.h:275
Definition: trx0trx.h:680
The transaction handle.
Definition: trx0trx.h:640
An undo::Tablespace object is used to easily convert between undo_space_id and undo_space_num and to ...
Definition: trx0purge.h:314
space_id_t num()
Get the undo tablespace number.
Definition: trx0purge.h:468
void set_inactive_explicit()
Make the undo tablespace inactive so that it will not be used for new transactions.
Definition: trx0purge.h:602
void set_file_name(const char *file_name)
Replace the standard undo file name if it exists with a copy of the file name provided.
Definition: trx0purge.cc:842
Rsegs * m_rsegs
List of rollback segments within this tablespace.
Definition: trx0purge.h:661
char * space_name()
Get the undo tablespace name.
Definition: trx0purge.h:399
char * m_file_name
The tablespace file name, auto-generated when needed from the space number.
Definition: trx0purge.h:649
void set_space_name(const char *new_space_name)
Replace the standard undo space name if it exists with a copy of the undo tablespace name provided.
Definition: trx0purge.cc:829
Rsegs * rsegs()
Get a reference to the List of rollback segments within this undo tablespace.
Definition: trx0purge.h:477
bool is_active()
Return whether the undo tablespace is active.
Definition: trx0purge.h:498
char * m_space_name
The tablespace name, auto-generated when needed from the space number.
Definition: trx0purge.h:645
trx_rseg_t * get_active(ulint slot)
Return the rseg at the requested rseg slot if the undo space is active.
Definition: trx0purge.h:521
char * make_log_file_name(space_id_t space_id, const char *location)
Build a log file name based on space_id.
Definition: trx0purge.cc:880
bool is_active_no_latch()
Return whether the undo tablespace is active.
Definition: trx0purge.h:511
void set_inactive_implicit(space_id_t *marked_space_id)
Set the state of the rollback segments in this undo tablespace to inactive_implicit if currently acti...
Definition: trx0purge.h:589
char * m_log_file_name_old
The old truncation log file name, auto-generated when needed from the space number and the srv_log_gr...
Definition: trx0purge.h:657
space_id_t id()
Get the undo tablespace ID.
Definition: trx0purge.h:462
bool m_implicit
True if this is an implicit undo tablespace.
Definition: trx0purge.h:637
void set_active()
Set the undo tablespace active for use by transactions.
Definition: trx0purge.h:578
void set_new()
Note that this undo tablespace is being created.
Definition: trx0purge.h:494
~Tablespace()
Destructor.
Definition: trx0purge.h:353
Tablespace(space_id_t id)
Constructor.
Definition: trx0purge.h:317
Tablespace(Tablespace &other)
Copy Constructor.
Definition: trx0purge.h:330
bool is_inactive_implicit()
Return whether the undo tablespace is inactive due to implicit selection by the purge thread.
Definition: trx0purge.h:541
bool needs_truncation()
Definition: trx0purge.cc:726
bool is_explicit()
Report whether this undo tablespace was explicitly created by an SQL statement.
Definition: trx0purge.h:482
char * log_file_name()
Get the undo log filename.
Definition: trx0purge.h:442
void set_space_id(space_id_t space_id)
Change the space_id from its current value.
Definition: trx0purge.cc:770
void alter_active()
Make the undo tablespace active again so that it will be used for new transactions.
Definition: trx0purge.cc:904
char * log_file_name_old()
Get the old undo log filename from the srv_log_group_home_dir.
Definition: trx0purge.h:452
bool is_inactive_explicit()
Return whether the undo tablespace was made inactive by ALTER TABLESPACE.
Definition: trx0purge.h:554
bool is_new()
Report whether this undo tablespace was created at startup.
Definition: trx0purge.h:491
space_id_t m_id
Undo Tablespace ID.
Definition: trx0purge.h:629
space_id_t m_num
Undo Tablespace number, from 1 to 127.
Definition: trx0purge.h:634
bool is_implicit()
Report whether this undo tablespace was implicitly created.
Definition: trx0purge.h:486
bool is_empty()
Return whether the undo tablespace is empty and ready to be dropped.
Definition: trx0purge.h:567
char * m_log_file_name
The truncation log file name, auto-generated when needed from the space number and the srv_undo_dir.
Definition: trx0purge.h:653
char * file_name()
Get the undo space filename.
Definition: trx0purge.h:423
bool m_new
True if this undo tablespace was implicitly created when this instance started up.
Definition: trx0purge.h:641
void set_empty()
Set the state of the undo tablespace to empty so that it can be dropped.
Definition: trx0purge.h:621
The currently used undo space IDs for an undo space number along with a boolean showing whether the u...
Definition: trx0purge.h:154
space_id_t space_id
Definition: trx0purge.h:155
bool in_use
Definition: trx0purge.h:156
bool rw_lock_own(const rw_lock_t *lock, ulint lock_type)
Checks if the thread has locked the rw-lock in the specified mode, with the pass value == 0.
Definition: sync0rw.cc:816
static void rw_lock_s_unlock(rw_lock_t *L)
Definition: sync0rw.h:797
static void rw_lock_x_lock(rw_lock_t *M, ut::Location L)
Definition: sync0rw.h:771
static void rw_lock_s_lock(rw_lock_t *M, ut::Location L)
Definition: sync0rw.h:720
static void rw_lock_x_unlock(rw_lock_t *L)
Definition: sync0rw.h:800
@ RW_LOCK_S
Definition: sync0types.h:207
@ RW_LOCK_X
Definition: sync0types.h:208
void trx_purge_add_update_undo_to_history(trx_t *trx, trx_undo_ptr_t *undo_ptr, page_t *undo_page, bool update_rseg_history_len, ulint n_added_logs, mtr_t *mtr)
in: mtr
Definition: trx0purge.cc:317
void trx_purge_sys_initialize(uint32_t n_purge_threads, purge_pq_t *purge_queue)
Creates the global purge system control structure and inits the history mutex.
Definition: trx0purge.cc:236
void trx_purge_sys_close(void)
Frees the global purge system control structure.
Definition: trx0purge.cc:271
purge_state_t
Purge states.
Definition: trx0purge.h:101
@ PURGE_STATE_DISABLED
Purge was never started.
Definition: trx0purge.h:106
@ PURGE_STATE_EXIT
Purge has been shutdown.
Definition: trx0purge.h:105
@ PURGE_STATE_RUN
Purge should be running.
Definition: trx0purge.h:103
@ PURGE_STATE_STOP
Purge should be stopped.
Definition: trx0purge.h:104
@ PURGE_STATE_INIT
Purge instance created.
Definition: trx0purge.h:102
trx_purge_t * purge_sys
The global data structure coordinating a purge.
Definition: trx0purge.cc:75
void trx_purge_sys_mem_create()
Initialize in-memory purge structures.
Definition: trx0purge.cc:213
ulint trx_purge(ulint n_purge_threads, ulint limit, bool truncate)
This function runs a purge batch.
Definition: trx0purge.cc:2393
void trx_purge_run(void)
Resume purge, move to PURGE_STATE_RUN.
Definition: trx0purge.cc:2577
purge_state_t trx_purge_state(void)
Get the purge state.
Definition: trx0purge.cc:2505
static fil_addr_t trx_purge_get_log_from_hist(fil_addr_t node_addr)
Calculates the file address of an undo log header when we have the file address of its history list n...
void trx_purge_stop(void)
Stop purge and wait for it to stop, move to PURGE_STATE_STOP.
Definition: trx0purge.cc:2518
Purge old versions.
Transaction system.
Transaction system global type definitions.
std::priority_queue< TrxUndoRsegs, std::vector< TrxUndoRsegs, ut::allocator< TrxUndoRsegs > >, TrxUndoRsegs > purge_pq_t
Definition: trx0types.h:593
ib_id_t undo_no_t
Undo number.
Definition: trx0types.h:141
std::array< trx_rseg_t *, N > Rsegs_array
Definition: trx0types.h:512
ib_mutex_t PQMutex
Definition: trx0types.h:172
ib_id_t trx_id_t
Transaction identifier (DB_TRX_ID, DATA_TRX_ID)
Definition: trx0types.h:137
Version control for database, common definitions, and include files.
unsigned long int ulint
Definition: univ.i:407
Sessions.
#define UT_LOCATION_HERE
Definition: ut0core.h:46
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:68
#define UT_NEW_THIS_FILE_PSI_KEY
Definition: ut0new.h:562