← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Elan Ruusamäe
  • Date: 2008-12-04 19:38:26 UTC
  • mfrom: (644 drizzle)
  • mto: (641.3.10 devel)
  • mto: This revision was merged to the branch mainline in revision 649.
  • Revision ID: glen@haarber.alkohol.ee-20081204193826-xxyhd45ag121pf3z
- pull from trunk

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
 
}