← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Monty Taylor
  • Date: 2008-11-16 05:36:13 UTC
  • mto: (584.1.9 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116053613-bld4rqxhlkb49c02
Split out cache_row and type_holder.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/mtr0log.ic
 
1
/******************************************************
 
2
Mini-transaction logging routines
 
3
 
 
4
(c) 1995 Innobase Oy
 
5
 
 
6
Created 12/7/1995 Heikki Tuuri
 
7
*******************************************************/
 
8
 
 
9
#include "mach0data.h"
 
10
#include "ut0lst.h"
 
11
#include "buf0buf.h"
 
12
 
 
13
/************************************************************
 
14
Opens a buffer to mlog. It must be closed with mlog_close. */
 
15
UNIV_INLINE
 
16
byte*
 
17
mlog_open(
 
18
/*======*/
 
19
                        /* out: buffer, NULL if log mode MTR_LOG_NONE */
 
20
        mtr_t*  mtr,    /* in: mtr */
 
21
        ulint   size)   /* in: buffer size in bytes; MUST be
 
22
                        smaller than DYN_ARRAY_DATA_SIZE! */
 
23
{
 
24
        dyn_array_t*    mlog;
 
25
 
 
26
        mtr->modifications = TRUE;
 
27
 
 
28
        if (mtr_get_log_mode(mtr) == MTR_LOG_NONE) {
 
29
 
 
30
                return(NULL);
 
31
        }
 
32
 
 
33
        mlog = &(mtr->log);
 
34
 
 
35
        return(dyn_array_open(mlog, size));
 
36
}
 
37
 
 
38
/************************************************************
 
39
Closes a buffer opened to mlog. */
 
40
UNIV_INLINE
 
41
void
 
42
mlog_close(
 
43
/*=======*/
 
44
        mtr_t*  mtr,    /* in: mtr */
 
45
        byte*   ptr)    /* in: buffer space from ptr up was not used */
 
46
{
 
47
        dyn_array_t*    mlog;
 
48
 
 
49
        ut_ad(mtr_get_log_mode(mtr) != MTR_LOG_NONE);
 
50
 
 
51
        mlog = &(mtr->log);
 
52
 
 
53
        dyn_array_close(mlog, ptr);
 
54
}
 
55
 
 
56
/************************************************************
 
57
Catenates 1 - 4 bytes to the mtr log. The value is not compressed. */
 
58
UNIV_INLINE
 
59
void
 
60
mlog_catenate_ulint(
 
61
/*================*/
 
62
        mtr_t*  mtr,    /* in: mtr */
 
63
        ulint   val,    /* in: value to write */
 
64
        ulint   type)   /* in: MLOG_1BYTE, MLOG_2BYTES, MLOG_4BYTES */
 
65
{
 
66
        dyn_array_t*    mlog;
 
67
        byte*           ptr;
 
68
 
 
69
        if (mtr_get_log_mode(mtr) == MTR_LOG_NONE) {
 
70
 
 
71
                return;
 
72
        }
 
73
 
 
74
        mlog = &(mtr->log);
 
75
 
 
76
#if MLOG_1BYTE != 1
 
77
# error "MLOG_1BYTE != 1"
 
78
#endif
 
79
#if MLOG_2BYTES != 2
 
80
# error "MLOG_2BYTES != 2"
 
81
#endif
 
82
#if MLOG_4BYTES != 4
 
83
# error "MLOG_4BYTES != 4"
 
84
#endif
 
85
#if MLOG_8BYTES != 8
 
86
# error "MLOG_8BYTES != 8"
 
87
#endif
 
88
        ptr = (byte*) dyn_array_push(mlog, type);
 
89
 
 
90
        if (type == MLOG_4BYTES) {
 
91
                mach_write_to_4(ptr, val);
 
92
        } else if (type == MLOG_2BYTES) {
 
93
                mach_write_to_2(ptr, val);
 
94
        } else {
 
95
                ut_ad(type == MLOG_1BYTE);
 
96
                mach_write_to_1(ptr, val);
 
97
        }
 
98
}
 
99
 
 
100
/************************************************************
 
101
Catenates a compressed ulint to mlog. */
 
102
UNIV_INLINE
 
103
void
 
104
mlog_catenate_ulint_compressed(
 
105
/*===========================*/
 
106
        mtr_t*  mtr,    /* in: mtr */
 
107
        ulint   val)    /* in: value to write */
 
108
{
 
109
        byte*   log_ptr;
 
110
 
 
111
        log_ptr = mlog_open(mtr, 10);
 
112
 
 
113
        /* If no logging is requested, we may return now */
 
114
        if (log_ptr == NULL) {
 
115
 
 
116
                return;
 
117
        }
 
118
 
 
119
        log_ptr += mach_write_compressed(log_ptr, val);
 
120
 
 
121
        mlog_close(mtr, log_ptr);
 
122
}
 
123
 
 
124
/************************************************************
 
125
Catenates a compressed dulint to mlog. */
 
126
UNIV_INLINE
 
127
void
 
128
mlog_catenate_dulint_compressed(
 
129
/*============================*/
 
130
        mtr_t*  mtr,    /* in: mtr */
 
131
        dulint  val)    /* in: value to write */
 
132
{
 
133
        byte*   log_ptr;
 
134
 
 
135
        log_ptr = mlog_open(mtr, 15);
 
136
 
 
137
        /* If no logging is requested, we may return now */
 
138
        if (log_ptr == NULL) {
 
139
 
 
140
                return;
 
141
        }
 
142
 
 
143
        log_ptr += mach_dulint_write_compressed(log_ptr, val);
 
144
 
 
145
        mlog_close(mtr, log_ptr);
 
146
}
 
147
 
 
148
/************************************************************
 
149
Writes the initial part of a log record (3..11 bytes).
 
150
If the implementation of this function is changed, all
 
151
size parameters to mlog_open() should be adjusted accordingly! */
 
152
UNIV_INLINE
 
153
byte*
 
154
mlog_write_initial_log_record_fast(
 
155
/*===============================*/
 
156
                                /* out: new value of log_ptr */
 
157
        const byte*     ptr,    /* in: pointer to (inside) a buffer
 
158
                                frame holding the file page where
 
159
                                modification is made */
 
160
        byte            type,   /* in: log item type: MLOG_1BYTE, ... */
 
161
        byte*           log_ptr,/* in: pointer to mtr log which has
 
162
                                been opened */
 
163
        mtr_t*          mtr)    /* in: mtr */
 
164
{
 
165
#ifdef UNIV_DEBUG
 
166
        buf_block_t*    block;
 
167
#endif
 
168
        const byte*     page;
 
169
        ulint           space;
 
170
        ulint           offset;
 
171
 
 
172
        ut_ad(mtr_memo_contains_page(mtr, ptr, MTR_MEMO_PAGE_X_FIX));
 
173
        ut_ad(type <= MLOG_BIGGEST_TYPE);
 
174
        ut_ad(ptr && log_ptr);
 
175
 
 
176
        page = (const byte*) ut_align_down(ptr, UNIV_PAGE_SIZE);
 
177
        space = mach_read_from_4(page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID);
 
178
        offset = mach_read_from_4(page + FIL_PAGE_OFFSET);
 
179
 
 
180
        mach_write_to_1(log_ptr, type);
 
181
        log_ptr++;
 
182
        log_ptr += mach_write_compressed(log_ptr, space);
 
183
        log_ptr += mach_write_compressed(log_ptr, offset);
 
184
 
 
185
        mtr->n_log_recs++;
 
186
 
 
187
#ifdef UNIV_LOG_DEBUG
 
188
        fprintf(stderr,
 
189
                "Adding to mtr log record type %lu space %lu page no %lu\n",
 
190
                (ulong) type, space, offset);
 
191
#endif
 
192
 
 
193
#ifdef UNIV_DEBUG
 
194
        buf_pool_mutex_enter();
 
195
        /* We now assume that all x-latched pages have been modified! */
 
196
        block = (buf_block_t*) buf_block_align(ptr);
 
197
        buf_pool_mutex_exit();
 
198
 
 
199
        if (!mtr_memo_contains(mtr, block, MTR_MEMO_MODIFY)) {
 
200
 
 
201
                mtr_memo_push(mtr, block, MTR_MEMO_MODIFY);
 
202
        }
 
203
#endif
 
204
        return(log_ptr);
 
205
}
 
206
 
 
207
/************************************************************
 
208
Writes a log record about an .ibd file create/delete/rename. */
 
209
UNIV_INLINE
 
210
byte*
 
211
mlog_write_initial_log_record_for_file_op(
 
212
/*======================================*/
 
213
                        /* out: new value of log_ptr */
 
214
        ulint   type,   /* in: MLOG_FILE_CREATE, MLOG_FILE_DELETE, or
 
215
                        MLOG_FILE_RENAME */
 
216
        ulint   space_id,/* in: space id, if applicable */
 
217
        ulint   page_no,/* in: page number (not relevant currently) */
 
218
        byte*   log_ptr,/* in: pointer to mtr log which has been opened */
 
219
        mtr_t*  mtr)    /* in: mtr */
 
220
{
 
221
        ut_ad(log_ptr);
 
222
 
 
223
        mach_write_to_1(log_ptr, type);
 
224
        log_ptr++;
 
225
 
 
226
        /* We write dummy space id and page number */
 
227
        log_ptr += mach_write_compressed(log_ptr, space_id);
 
228
        log_ptr += mach_write_compressed(log_ptr, page_no);
 
229
 
 
230
        mtr->n_log_recs++;
 
231
 
 
232
        return(log_ptr);
 
233
}