1
/******************************************************
6
Created 3/26/1996 Heikki Tuuri
7
*******************************************************/
13
#include "trx0types.h"
16
#include "page0types.h"
19
/***************************************************************************
20
Builds a roll pointer dulint. */
23
trx_undo_build_roll_ptr(
24
/*====================*/
25
/* out: roll pointer */
26
ibool is_insert, /* in: TRUE if insert undo log */
27
ulint rseg_id, /* in: rollback segment id */
28
ulint page_no, /* in: page number */
29
ulint offset); /* in: offset of the undo entry within page */
30
/***************************************************************************
31
Decodes a roll pointer dulint. */
34
trx_undo_decode_roll_ptr(
35
/*=====================*/
36
dulint roll_ptr, /* in: roll pointer */
37
ibool* is_insert, /* out: TRUE if insert undo log */
38
ulint* rseg_id, /* out: rollback segment id */
39
ulint* page_no, /* out: page number */
40
ulint* offset); /* out: offset of the undo entry within page */
41
/***************************************************************************
42
Returns TRUE if the roll pointer is of the insert type. */
45
trx_undo_roll_ptr_is_insert(
46
/*========================*/
47
/* out: TRUE if insert undo log */
48
dulint roll_ptr); /* in: roll pointer */
49
/*********************************************************************
50
Writes a roll ptr to an index page. In case that the size changes in
51
some future version, this function should be used instead of
57
byte* ptr, /* in: pointer to memory where written */
58
dulint roll_ptr); /* in: roll ptr */
59
/*********************************************************************
60
Reads a roll ptr from an index page. In case that the roll ptr size
61
changes in some future version, this function should be used instead of
68
byte* ptr); /* in: pointer to memory from where to read */
69
/**********************************************************************
70
Gets an undo log page and x-latches it. */
75
/* out: pointer to page x-latched */
76
ulint space, /* in: space where placed */
77
ulint page_no, /* in: page number */
78
mtr_t* mtr); /* in: mtr */
79
/**********************************************************************
80
Gets an undo log page and s-latches it. */
83
trx_undo_page_get_s_latched(
84
/*========================*/
85
/* out: pointer to page s-latched */
86
ulint space, /* in: space where placed */
87
ulint page_no, /* in: page number */
88
mtr_t* mtr); /* in: mtr */
89
/**********************************************************************
90
Returns the previous undo record on the page in the specified log, or
91
NULL if none exists. */
94
trx_undo_page_get_prev_rec(
95
/*=======================*/
96
/* out: pointer to record, NULL if none */
97
trx_undo_rec_t* rec, /* in: undo log record */
98
ulint page_no,/* in: undo log header page number */
99
ulint offset);/* in: undo log header offset on page */
100
/**********************************************************************
101
Returns the next undo log record on the page in the specified log, or
102
NULL if none exists. */
105
trx_undo_page_get_next_rec(
106
/*=======================*/
107
/* out: pointer to record, NULL if none */
108
trx_undo_rec_t* rec, /* in: undo log record */
109
ulint page_no,/* in: undo log header page number */
110
ulint offset);/* in: undo log header offset on page */
111
/**********************************************************************
112
Returns the last undo record on the page in the specified undo log, or
113
NULL if none exists. */
116
trx_undo_page_get_last_rec(
117
/*=======================*/
118
/* out: pointer to record, NULL if none */
119
page_t* undo_page,/* in: undo log page */
120
ulint page_no,/* in: undo log header page number */
121
ulint offset); /* in: undo log header offset on page */
122
/**********************************************************************
123
Returns the first undo record on the page in the specified undo log, or
124
NULL if none exists. */
127
trx_undo_page_get_first_rec(
128
/*========================*/
129
/* out: pointer to record, NULL if none */
130
page_t* undo_page,/* in: undo log page */
131
ulint page_no,/* in: undo log header page number */
132
ulint offset);/* in: undo log header offset on page */
133
/***************************************************************************
134
Gets the previous record in an undo log. */
137
trx_undo_get_prev_rec(
138
/*==================*/
139
/* out: undo log record, the page s-latched,
141
trx_undo_rec_t* rec, /* in: undo record */
142
ulint page_no,/* in: undo log header page number */
143
ulint offset, /* in: undo log header offset on page */
144
mtr_t* mtr); /* in: mtr */
145
/***************************************************************************
146
Gets the next record in an undo log. */
149
trx_undo_get_next_rec(
150
/*==================*/
151
/* out: undo log record, the page s-latched,
153
trx_undo_rec_t* rec, /* in: undo record */
154
ulint page_no,/* in: undo log header page number */
155
ulint offset, /* in: undo log header offset on page */
156
mtr_t* mtr); /* in: mtr */
157
/***************************************************************************
158
Gets the first record in an undo log. */
161
trx_undo_get_first_rec(
162
/*===================*/
163
/* out: undo log record, the page latched, NULL if
165
ulint space, /* in: undo log header space */
166
ulint page_no,/* in: undo log header page number */
167
ulint offset, /* in: undo log header offset on page */
168
ulint mode, /* in: latching mode: RW_S_LATCH or RW_X_LATCH */
169
mtr_t* mtr); /* in: mtr */
170
/************************************************************************
171
Tries to add a page to the undo log segment where the undo log is placed. */
176
/* out: page number if success, else
178
trx_t* trx, /* in: transaction */
179
trx_undo_t* undo, /* in: undo log memory object */
180
mtr_t* mtr); /* in: mtr which does not have a latch to any
181
undo log page; the caller must have reserved
182
the rollback segment mutex */
183
/***************************************************************************
184
Truncates an undo log from the end. This function is used during a rollback
185
to free space from an undo log. */
188
trx_undo_truncate_end(
189
/*==================*/
190
trx_t* trx, /* in: transaction whose undo log it is */
191
trx_undo_t* undo, /* in: undo log */
192
dulint limit); /* in: all undo records with undo number
193
>= this value should be truncated */
194
/***************************************************************************
195
Truncates an undo log from the start. This function is used during a purge
199
trx_undo_truncate_start(
200
/*====================*/
201
trx_rseg_t* rseg, /* in: rollback segment */
202
ulint space, /* in: space id of the log */
203
ulint hdr_page_no, /* in: header page number */
204
ulint hdr_offset, /* in: header offset on the page */
205
dulint limit); /* in: all undo pages with undo numbers <
206
this value should be truncated; NOTE that
207
the function only frees whole pages; the
208
header page is not freed, but emptied, if
209
all the records there are < limit */
210
/************************************************************************
211
Initializes the undo log lists for a rollback segment memory copy.
212
This function is only called when the database is started or a new
213
rollback segment created. */
218
/* out: the combined size of undo log segments
220
trx_rseg_t* rseg); /* in: rollback segment memory object */
221
/**************************************************************************
222
Assigns an undo log for a transaction. A new undo log is created or a cached
226
trx_undo_assign_undo(
227
/*=================*/
228
/* out: DB_SUCCESS if undo log assign
229
* successful, possible error codes are:
230
* ER_TOO_MANY_CONCURRENT_TRXS
231
* DB_OUT_OF_FILE_SPAC
232
* DB_OUT_OF_MEMORY */
233
trx_t* trx, /* in: transaction */
234
ulint type); /* in: TRX_UNDO_INSERT or TRX_UNDO_UPDATE */
235
/**********************************************************************
236
Sets the state of the undo log segment at a transaction finish. */
239
trx_undo_set_state_at_finish(
240
/*=========================*/
241
/* out: undo log segment header page,
243
trx_rseg_t* rseg, /* in: rollback segment memory object */
244
trx_t* trx, /* in: transaction */
245
trx_undo_t* undo, /* in: undo log memory copy */
246
mtr_t* mtr); /* in: mtr */
247
/**********************************************************************
248
Sets the state of the undo log segment at a transaction prepare. */
251
trx_undo_set_state_at_prepare(
252
/*==========================*/
253
/* out: undo log segment header page,
255
trx_t* trx, /* in: transaction */
256
trx_undo_t* undo, /* in: undo log memory copy */
257
mtr_t* mtr); /* in: mtr */
259
/**************************************************************************
260
Adds the update undo log header as the first in the history list, and
261
frees the memory object, or puts it to the list of cached update undo log
265
trx_undo_update_cleanup(
266
/*====================*/
267
trx_t* trx, /* in: trx owning the update undo log */
268
page_t* undo_page, /* in: update undo log header page,
270
mtr_t* mtr); /* in: mtr */
271
/**********************************************************************
272
Frees or caches an insert undo log after a transaction commit or rollback.
273
Knowledge of inserts is not needed after a commit or rollback, therefore
274
the data can be discarded. */
277
trx_undo_insert_cleanup(
278
/*====================*/
279
trx_t* trx); /* in: transaction handle */
280
/***************************************************************
281
Parses the redo log entry of an undo log page initialization. */
284
trx_undo_parse_page_init(
285
/*=====================*/
286
/* out: end of log record or NULL */
287
byte* ptr, /* in: buffer */
288
byte* end_ptr,/* in: buffer end */
289
page_t* page, /* in: page or NULL */
290
mtr_t* mtr); /* in: mtr or NULL */
291
/***************************************************************
292
Parses the redo log entry of an undo log page header create or reuse. */
295
trx_undo_parse_page_header(
296
/*=======================*/
297
/* out: end of log record or NULL */
298
ulint type, /* in: MLOG_UNDO_HDR_CREATE or MLOG_UNDO_HDR_REUSE */
299
byte* ptr, /* in: buffer */
300
byte* end_ptr,/* in: buffer end */
301
page_t* page, /* in: page or NULL */
302
mtr_t* mtr); /* in: mtr or NULL */
303
/***************************************************************
304
Parses the redo log entry of an undo log page header discard. */
307
trx_undo_parse_discard_latest(
308
/*==========================*/
309
/* out: end of log record or NULL */
310
byte* ptr, /* in: buffer */
311
byte* end_ptr,/* in: buffer end */
312
page_t* page, /* in: page or NULL */
313
mtr_t* mtr); /* in: mtr or NULL */
315
/* Types of an undo log segment */
316
#define TRX_UNDO_INSERT 1 /* contains undo entries for inserts */
317
#define TRX_UNDO_UPDATE 2 /* contains undo entries for updates
318
and delete markings: in short,
319
modifys (the name 'UPDATE' is a
321
/* States of an undo log segment */
322
#define TRX_UNDO_ACTIVE 1 /* contains an undo log of an active
324
#define TRX_UNDO_CACHED 2 /* cached for quick reuse */
325
#define TRX_UNDO_TO_FREE 3 /* insert undo segment can be freed */
326
#define TRX_UNDO_TO_PURGE 4 /* update undo segment will not be
327
reused: it can be freed in purge when
328
all undo data in it is removed */
329
#define TRX_UNDO_PREPARED 5 /* contains an undo log of an
330
prepared transaction */
332
/* Transaction undo log memory object; this is protected by the undo_mutex
333
in the corresponding transaction object */
335
struct trx_undo_struct{
336
/*-----------------------------*/
337
ulint id; /* undo log slot number within the
339
ulint type; /* TRX_UNDO_INSERT or
341
ulint state; /* state of the corresponding undo log
343
ibool del_marks; /* relevant only in an update undo log:
344
this is TRUE if the transaction may
345
have delete marked records, because of
346
a delete of a row or an update of an
347
indexed field; purge is then
348
necessary; also TRUE if the transaction
349
has updated an externally stored
351
dulint trx_id; /* id of the trx assigned to the undo
353
XID xid; /* X/Open XA transaction
355
ibool dict_operation; /* TRUE if a dict operation trx */
356
dulint table_id; /* if a dict operation, then the table
358
trx_rseg_t* rseg; /* rseg where the undo log belongs */
359
/*-----------------------------*/
360
ulint space; /* space id where the undo log
362
ulint hdr_page_no; /* page number of the header page in
364
ulint hdr_offset; /* header offset of the undo log on the
366
ulint last_page_no; /* page number of the last page in the
367
undo log; this may differ from
368
top_page_no during a rollback */
369
ulint size; /* current size in pages */
370
/*-----------------------------*/
371
ulint empty; /* TRUE if the stack of undo log
372
records is currently empty */
373
ulint top_page_no; /* page number where the latest undo
374
log record was catenated; during
375
rollback the page from which the latest
376
undo record was chosen */
377
ulint top_offset; /* offset of the latest undo record,
378
i.e., the topmost element in the undo
379
log if we think of it as a stack */
380
dulint top_undo_no; /* undo number of the latest record */
381
page_t* guess_page; /* guess for the buffer frame where
382
the top page might reside */
383
/*-----------------------------*/
384
UT_LIST_NODE_T(trx_undo_t) undo_list;
385
/* undo log objects in the rollback
386
segment are chained into lists */
389
/* The offset of the undo log page header on pages of the undo log */
390
#define TRX_UNDO_PAGE_HDR FSEG_PAGE_DATA
391
/*-------------------------------------------------------------*/
392
/* Transaction undo log page header offsets */
393
#define TRX_UNDO_PAGE_TYPE 0 /* TRX_UNDO_INSERT or
395
#define TRX_UNDO_PAGE_START 2 /* Byte offset where the undo log
396
records for the LATEST transaction
397
start on this page (remember that
398
in an update undo log, the first page
399
can contain several undo logs) */
400
#define TRX_UNDO_PAGE_FREE 4 /* On each page of the undo log this
401
field contains the byte offset of the
402
first free byte on the page */
403
#define TRX_UNDO_PAGE_NODE 6 /* The file list node in the chain
405
/*-------------------------------------------------------------*/
406
#define TRX_UNDO_PAGE_HDR_SIZE (6 + FLST_NODE_SIZE)
408
/* An update undo segment with just one page can be reused if it has
409
< this number bytes used; we must leave space at least for one new undo
410
log header on the page */
412
#define TRX_UNDO_PAGE_REUSE_LIMIT (3 * UNIV_PAGE_SIZE / 4)
414
/* An update undo log segment may contain several undo logs on its first page
415
if the undo logs took so little space that the segment could be cached and
416
reused. All the undo log headers are then on the first page, and the last one
417
owns the undo log records on subsequent pages if the segment is bigger than
418
one page. If an undo log is stored in a segment, then on the first page it is
419
allowed to have zero undo records, but if the segment extends to several
420
pages, then all the rest of the pages must contain at least one undo log
423
/* The offset of the undo log segment header on the first page of the undo
426
#define TRX_UNDO_SEG_HDR (TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_HDR_SIZE)
427
/*-------------------------------------------------------------*/
428
#define TRX_UNDO_STATE 0 /* TRX_UNDO_ACTIVE, ... */
429
#define TRX_UNDO_LAST_LOG 2 /* Offset of the last undo log header
430
on the segment header page, 0 if
432
#define TRX_UNDO_FSEG_HEADER 4 /* Header for the file segment which
433
the undo log segment occupies */
434
#define TRX_UNDO_PAGE_LIST (4 + FSEG_HEADER_SIZE)
435
/* Base node for the list of pages in
436
the undo log segment; defined only on
437
the undo log segment's first page */
438
/*-------------------------------------------------------------*/
439
/* Size of the undo log segment header */
440
#define TRX_UNDO_SEG_HDR_SIZE (4 + FSEG_HEADER_SIZE + FLST_BASE_NODE_SIZE)
443
/* The undo log header. There can be several undo log headers on the first
444
page of an update undo log segment. */
445
/*-------------------------------------------------------------*/
446
#define TRX_UNDO_TRX_ID 0 /* Transaction id */
447
#define TRX_UNDO_TRX_NO 8 /* Transaction number of the
448
transaction; defined only if the log
449
is in a history list */
450
#define TRX_UNDO_DEL_MARKS 16 /* Defined only in an update undo
451
log: TRUE if the transaction may have
452
done delete markings of records, and
453
thus purge is necessary */
454
#define TRX_UNDO_LOG_START 18 /* Offset of the first undo log record
455
of this log on the header page; purge
456
may remove undo log record from the
457
log start, and therefore this is not
458
necessarily the same as this log
460
#define TRX_UNDO_XID_EXISTS 20 /* TRUE if undo log header includes
461
X/Open XA transaction identification
463
#define TRX_UNDO_DICT_TRANS 21 /* TRUE if the transaction is a table
464
create, index create, or drop
465
transaction: in recovery
466
the transaction cannot be rolled back
467
in the usual way: a 'rollback' rather
468
means dropping the created or dropped
469
table, if it still exists */
470
#define TRX_UNDO_TABLE_ID 22 /* Id of the table if the preceding
472
#define TRX_UNDO_NEXT_LOG 30 /* Offset of the next undo log header
473
on this page, 0 if none */
474
#define TRX_UNDO_PREV_LOG 32 /* Offset of the previous undo log
475
header on this page, 0 if none */
476
#define TRX_UNDO_HISTORY_NODE 34 /* If the log is put to the history
477
list, the file list node is here */
478
/*-------------------------------------------------------------*/
479
#define TRX_UNDO_LOG_OLD_HDR_SIZE (34 + FLST_NODE_SIZE)
481
/* Note: the writing of the undo log old header is coded by a log record
482
MLOG_UNDO_HDR_CREATE or MLOG_UNDO_HDR_REUSE. The appending of an XID to the
483
header is logged separately. In this sense, the XID is not really a member
484
of the undo log header. TODO: do not append the XID to the log header if XA
485
is not needed by the user. The XID wastes about 150 bytes of space in every
486
undo log. In the history list we may have millions of undo logs, which means
487
quite a large overhead. */
489
/* X/Open XA Transaction Identification (XID) */
491
#define TRX_UNDO_XA_FORMAT (TRX_UNDO_LOG_OLD_HDR_SIZE)
492
#define TRX_UNDO_XA_TRID_LEN (TRX_UNDO_XA_FORMAT + 4)
493
#define TRX_UNDO_XA_BQUAL_LEN (TRX_UNDO_XA_TRID_LEN + 4)
494
#define TRX_UNDO_XA_XID (TRX_UNDO_XA_BQUAL_LEN + 4)
495
/*--------------------------------------------------------------*/
496
#define TRX_UNDO_LOG_XA_HDR_SIZE (TRX_UNDO_XA_XID + XIDDATASIZE)
497
/* Total size of the header with the XA XID */
500
#include "trx0undo.ic"
added
removed
storage/innobase/include/trx0undo.h
