← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/trx0undo.ic

  • Committer: Brian Aker
  • Date: 2009-02-21 00:18:15 UTC
  • Revision ID: brian@tangent.org-20090221001815-x20e8h71e984lvs1
Completion (?) of uint conversion.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/trx0undo.ic
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., 51 Franklin
15
 
St, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
*****************************************************************************/
18
 
 
19
 
/**************************************************//**
20
 
@file include/trx0undo.ic
 
1
/******************************************************
21
2
Transaction undo log
22
3
 
 
4
(c) 1996 Innobase Oy
 
5
 
23
6
Created 3/26/1996 Heikki Tuuri
24
7
*******************************************************/
25
8
 
26
9
#include "data0type.h"
27
10
#include "page0page.h"
28
11
 
29
 
#ifndef UNIV_HOTBACKUP
30
 
/***********************************************************************//**
31
 
Builds a roll pointer.
32
 
@return roll pointer */
 
12
/***************************************************************************
 
13
Builds a roll pointer dulint. */
33
14
UNIV_INLINE
34
 
roll_ptr_t
 
15
dulint
35
16
trx_undo_build_roll_ptr(
36
17
/*====================*/
37
 
        ibool   is_insert,      /*!< in: TRUE if insert undo log */
38
 
        ulint   rseg_id,        /*!< in: rollback segment id */
39
 
        ulint   page_no,        /*!< in: page number */
40
 
        ulint   offset)         /*!< in: offset of the undo entry within page */
 
18
                                /* out: roll pointer */
 
19
        ibool   is_insert,      /* in: TRUE if insert undo log */
 
20
        ulint   rseg_id,        /* in: rollback segment id */
 
21
        ulint   page_no,        /* in: page number */
 
22
        ulint   offset)         /* in: offset of the undo entry within page */
41
23
{
42
 
        roll_ptr_t      roll_ptr;
43
24
#if DATA_ROLL_PTR_LEN != 7
44
25
# error "DATA_ROLL_PTR_LEN != 7"
45
26
#endif
46
 
        ut_ad(is_insert == 0 || is_insert == 1);
47
 
        ut_ad(rseg_id < TRX_SYS_N_RSEGS);
48
 
        ut_ad(offset < 65536);
 
27
        ut_ad(rseg_id < 128);
49
28
 
50
 
        roll_ptr = (roll_ptr_t) is_insert << 55
51
 
                | (roll_ptr_t) rseg_id << 48
52
 
                | (roll_ptr_t) page_no << 16
53
 
                | offset;
54
 
        return(roll_ptr);
 
29
        return(ut_dulint_create(is_insert * 128 * 256 * 256
 
30
                                + rseg_id * 256 * 256
 
31
                                + (page_no / 256) / 256,
 
32
                                (page_no % (256 * 256)) * 256 * 256
 
33
                                + offset));
55
34
}
56
35
 
57
 
/***********************************************************************//**
58
 
Decodes a roll pointer. */
 
36
/***************************************************************************
 
37
Decodes a roll pointer dulint. */
59
38
UNIV_INLINE
60
39
void
61
40
trx_undo_decode_roll_ptr(
62
41
/*=====================*/
63
 
        roll_ptr_t      roll_ptr,       /*!< in: roll pointer */
64
 
        ibool*          is_insert,      /*!< out: TRUE if insert undo log */
65
 
        ulint*          rseg_id,        /*!< out: rollback segment id */
66
 
        ulint*          page_no,        /*!< out: page number */
67
 
        ulint*          offset)         /*!< out: offset of the undo
68
 
                                        entry within page */
 
42
        dulint  roll_ptr,       /* in: roll pointer */
 
43
        ibool*  is_insert,      /* out: TRUE if insert undo log */
 
44
        ulint*  rseg_id,        /* out: rollback segment id */
 
45
        ulint*  page_no,        /* out: page number */
 
46
        ulint*  offset)         /* out: offset of the undo entry within page */
69
47
{
 
48
        ulint   low;
 
49
        ulint   high;
70
50
#if DATA_ROLL_PTR_LEN != 7
71
51
# error "DATA_ROLL_PTR_LEN != 7"
72
52
#endif
73
53
#if TRUE != 1
74
54
# error "TRUE != 1"
75
55
#endif
76
 
        ut_ad(roll_ptr < (1ULL << 56));
77
 
        *offset = (ulint) roll_ptr & 0xFFFF;
78
 
        roll_ptr >>= 16;
79
 
        *page_no = (ulint) roll_ptr & 0xFFFFFFFF;
80
 
        roll_ptr >>= 32;
81
 
        *rseg_id = (ulint) roll_ptr & 0x7F;
82
 
        roll_ptr >>= 7;
83
 
        *is_insert = (ibool) roll_ptr; /* TRUE==1 */
 
56
        high = ut_dulint_get_high(roll_ptr);
 
57
        low = ut_dulint_get_low(roll_ptr);
 
58
 
 
59
        *offset = low % (256 * 256);
 
60
 
 
61
        *is_insert = high / (256 * 256 * 128);  /* TRUE == 1 */
 
62
        *rseg_id = (high / (256 * 256)) % 128;
 
63
 
 
64
        *page_no = (high % (256 * 256)) * 256 * 256
 
65
                + (low / 256) / 256;
84
66
}
85
67
 
86
 
/***********************************************************************//**
87
 
Returns TRUE if the roll pointer is of the insert type.
88
 
@return TRUE if insert undo log */
 
68
/***************************************************************************
 
69
Returns TRUE if the roll pointer is of the insert type. */
89
70
UNIV_INLINE
90
71
ibool
91
72
trx_undo_roll_ptr_is_insert(
92
73
/*========================*/
93
 
        roll_ptr_t      roll_ptr)       /*!< in: roll pointer */
 
74
                                /* out: TRUE if insert undo log */
 
75
        dulint  roll_ptr)       /* in: roll pointer */
94
76
{
 
77
        ulint   high;
95
78
#if DATA_ROLL_PTR_LEN != 7
96
79
# error "DATA_ROLL_PTR_LEN != 7"
97
80
#endif
98
81
#if TRUE != 1
99
82
# error "TRUE != 1"
100
83
#endif
101
 
        ut_ad(roll_ptr < (1ULL << 56));
102
 
        return((ibool) (roll_ptr >> 55));
 
84
        high = ut_dulint_get_high(roll_ptr);
 
85
 
 
86
        return(high / (256 * 256 * 128));
103
87
}
104
 
#endif /* !UNIV_HOTBACKUP */
105
88
 
106
 
/*****************************************************************//**
 
89
/*********************************************************************
107
90
Writes a roll ptr to an index page. In case that the size changes in
108
91
some future version, this function should be used instead of
109
92
mach_write_... */
111
94
void
112
95
trx_write_roll_ptr(
113
96
/*===============*/
114
 
        byte*           ptr,            /*!< in: pointer to memory where
115
 
                                        written */
116
 
        roll_ptr_t      roll_ptr)       /*!< in: roll ptr */
 
97
        byte*   ptr,            /* in: pointer to memory where written */
 
98
        dulint  roll_ptr)       /* in: roll ptr */
117
99
{
118
100
#if DATA_ROLL_PTR_LEN != 7
119
101
# error "DATA_ROLL_PTR_LEN != 7"
121
103
        mach_write_to_7(ptr, roll_ptr);
122
104
}
123
105
 
124
 
/*****************************************************************//**
 
106
/*********************************************************************
125
107
Reads a roll ptr from an index page. In case that the roll ptr size
126
108
changes in some future version, this function should be used instead of
127
 
mach_read_...
128
 
@return roll ptr */
 
109
mach_read_... */
129
110
UNIV_INLINE
130
 
roll_ptr_t
 
111
dulint
131
112
trx_read_roll_ptr(
132
113
/*==============*/
133
 
        const byte*     ptr)    /*!< in: pointer to memory from where to read */
 
114
                                /* out: roll ptr */
 
115
        const byte*     ptr)    /* in: pointer to memory from where to read */
134
116
{
135
117
#if DATA_ROLL_PTR_LEN != 7
136
118
# error "DATA_ROLL_PTR_LEN != 7"
138
120
        return(mach_read_from_7(ptr));
139
121
}
140
122
 
141
 
#ifndef UNIV_HOTBACKUP
142
 
/******************************************************************//**
143
 
Gets an undo log page and x-latches it.
144
 
@return pointer to page x-latched */
 
123
/**********************************************************************
 
124
Gets an undo log page and x-latches it. */
145
125
UNIV_INLINE
146
126
page_t*
147
127
trx_undo_page_get(
148
128
/*==============*/
149
 
        ulint   space,          /*!< in: space where placed */
150
 
        ulint   zip_size,       /*!< in: compressed page size in bytes
 
129
                                /* out: pointer to page x-latched */
 
130
        ulint   space,          /* in: space where placed */
 
131
        ulint   zip_size,       /* in: compressed page size in bytes
151
132
                                or 0 for uncompressed pages */
152
 
        ulint   page_no,        /*!< in: page number */
153
 
        mtr_t*  mtr)            /*!< in: mtr */
 
133
        ulint   page_no,        /* in: page number */
 
134
        mtr_t*  mtr)            /* in: mtr */
154
135
{
155
136
        buf_block_t*    block = buf_page_get(space, zip_size, page_no,
156
137
                                             RW_X_LATCH, mtr);
159
140
        return(buf_block_get_frame(block));
160
141
}
161
142
 
162
 
/******************************************************************//**
163
 
Gets an undo log page and s-latches it.
164
 
@return pointer to page s-latched */
 
143
/**********************************************************************
 
144
Gets an undo log page and s-latches it. */
165
145
UNIV_INLINE
166
146
page_t*
167
147
trx_undo_page_get_s_latched(
168
148
/*========================*/
169
 
        ulint   space,          /*!< in: space where placed */
170
 
        ulint   zip_size,       /*!< in: compressed page size in bytes
 
149
                                /* out: pointer to page s-latched */
 
150
        ulint   space,          /* in: space where placed */
 
151
        ulint   zip_size,       /* in: compressed page size in bytes
171
152
                                or 0 for uncompressed pages */
172
 
        ulint   page_no,        /*!< in: page number */
173
 
        mtr_t*  mtr)            /*!< in: mtr */
 
153
        ulint   page_no,        /* in: page number */
 
154
        mtr_t*  mtr)            /* in: mtr */
174
155
{
175
156
        buf_block_t*    block = buf_page_get(space, zip_size, page_no,
176
157
                                             RW_S_LATCH, mtr);
179
160
        return(buf_block_get_frame(block));
180
161
}
181
162
 
182
 
/******************************************************************//**
 
163
/**********************************************************************
183
164
Returns the start offset of the undo log records of the specified undo
184
 
log on the page.
185
 
@return start offset */
 
165
log on the page. */
186
166
UNIV_INLINE
187
167
ulint
188
168
trx_undo_page_get_start(
189
169
/*====================*/
190
 
        page_t* undo_page,/*!< in: undo log page */
191
 
        ulint   page_no,/*!< in: undo log header page number */
192
 
        ulint   offset) /*!< in: undo log header offset on page */
 
170
                        /* out: start offset */
 
171
        page_t* undo_page,/* in: undo log page */
 
172
        ulint   page_no,/* in: undo log header page number */
 
173
        ulint   offset) /* in: undo log header offset on page */
193
174
{
194
175
        ulint   start;
195
176
 
204
185
        return(start);
205
186
}
206
187
 
207
 
/******************************************************************//**
 
188
/**********************************************************************
208
189
Returns the end offset of the undo log records of the specified undo
209
 
log on the page.
210
 
@return end offset */
 
190
log on the page. */
211
191
UNIV_INLINE
212
192
ulint
213
193
trx_undo_page_get_end(
214
194
/*==================*/
215
 
        page_t* undo_page,/*!< in: undo log page */
216
 
        ulint   page_no,/*!< in: undo log header page number */
217
 
        ulint   offset) /*!< in: undo log header offset on page */
 
195
                        /* out: end offset */
 
196
        page_t* undo_page,/* in: undo log page */
 
197
        ulint   page_no,/* in: undo log header page number */
 
198
        ulint   offset) /* in: undo log header offset on page */
218
199
{
219
200
        trx_ulogf_t*    log_hdr;
220
201
        ulint           end;
237
218
        return(end);
238
219
}
239
220
 
240
 
/******************************************************************//**
 
221
/**********************************************************************
241
222
Returns the previous undo record on the page in the specified log, or
242
 
NULL if none exists.
243
 
@return pointer to record, NULL if none */
 
223
NULL if none exists. */
244
224
UNIV_INLINE
245
225
trx_undo_rec_t*
246
226
trx_undo_page_get_prev_rec(
247
227
/*=======================*/
248
 
        trx_undo_rec_t* rec,    /*!< in: undo log record */
249
 
        ulint           page_no,/*!< in: undo log header page number */
250
 
        ulint           offset) /*!< in: undo log header offset on page */
 
228
                                /* out: pointer to record, NULL if none */
 
229
        trx_undo_rec_t* rec,    /* in: undo log record */
 
230
        ulint           page_no,/* in: undo log header page number */
 
231
        ulint           offset) /* in: undo log header offset on page */
251
232
{
252
233
        page_t* undo_page;
253
234
        ulint   start;
264
245
        return(undo_page + mach_read_from_2(rec - 2));
265
246
}
266
247
 
267
 
/******************************************************************//**
 
248
/**********************************************************************
268
249
Returns the next undo log record on the page in the specified log, or
269
 
NULL if none exists.
270
 
@return pointer to record, NULL if none */
 
250
NULL if none exists. */
271
251
UNIV_INLINE
272
252
trx_undo_rec_t*
273
253
trx_undo_page_get_next_rec(
274
254
/*=======================*/
275
 
        trx_undo_rec_t* rec,    /*!< in: undo log record */
276
 
        ulint           page_no,/*!< in: undo log header page number */
277
 
        ulint           offset) /*!< in: undo log header offset on page */
 
255
                                /* out: pointer to record, NULL if none */
 
256
        trx_undo_rec_t* rec,    /* in: undo log record */
 
257
        ulint           page_no,/* in: undo log header page number */
 
258
        ulint           offset) /* in: undo log header offset on page */
278
259
{
279
260
        page_t* undo_page;
280
261
        ulint   end;
294
275
        return(undo_page + next);
295
276
}
296
277
 
297
 
/******************************************************************//**
 
278
/**********************************************************************
298
279
Returns the last undo record on the page in the specified undo log, or
299
 
NULL if none exists.
300
 
@return pointer to record, NULL if none */
 
280
NULL if none exists. */
301
281
UNIV_INLINE
302
282
trx_undo_rec_t*
303
283
trx_undo_page_get_last_rec(
304
284
/*=======================*/
305
 
        page_t* undo_page,/*!< in: undo log page */
306
 
        ulint   page_no,/*!< in: undo log header page number */
307
 
        ulint   offset) /*!< in: undo log header offset on page */
 
285
                        /* out: pointer to record, NULL if none */
 
286
        page_t* undo_page,/* in: undo log page */
 
287
        ulint   page_no,/* in: undo log header page number */
 
288
        ulint   offset) /* in: undo log header offset on page */
308
289
{
309
290
        ulint   start;
310
291
        ulint   end;
320
301
        return(undo_page + mach_read_from_2(undo_page + end - 2));
321
302
}
322
303
 
323
 
/******************************************************************//**
 
304
/**********************************************************************
324
305
Returns the first undo record on the page in the specified undo log, or
325
 
NULL if none exists.
326
 
@return pointer to record, NULL if none */
 
306
NULL if none exists. */
327
307
UNIV_INLINE
328
308
trx_undo_rec_t*
329
309
trx_undo_page_get_first_rec(
330
310
/*========================*/
331
 
        page_t* undo_page,/*!< in: undo log page */
332
 
        ulint   page_no,/*!< in: undo log header page number */
333
 
        ulint   offset) /*!< in: undo log header offset on page */
 
311
                        /* out: pointer to record, NULL if none */
 
312
        page_t* undo_page,/* in: undo log page */
 
313
        ulint   page_no,/* in: undo log header page number */
 
314
        ulint   offset) /* in: undo log header offset on page */
334
315
{
335
316
        ulint   start;
336
317
        ulint   end;
345
326
 
346
327
        return(undo_page + start);
347
328
}
348
 
#endif /* !UNIV_HOTBACKUP */