← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/trx/trx0rseg.c

  • Committer: Brian Aker
  • Date: 2008-09-04 19:31:00 UTC
  • Revision ID: brian@tangent.org-20080904193100-l849hgghfy4urj43
Changing default character set from this point on.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/trx/trx0rseg.c
19
19
 
20
20
/**********************************************************************
21
21
Looks for a rollback segment, based on the rollback segment id. */
22
 
UNIV_INTERN
 
22
 
23
23
trx_rseg_t*
24
24
trx_rseg_get_on_id(
25
25
/*===============*/
42
42
/********************************************************************
43
43
Creates a rollback segment header. This function is called only when
44
44
a new rollback segment is created in the database. */
45
 
UNIV_INTERN
 
45
 
46
46
ulint
47
47
trx_rseg_header_create(
48
48
/*===================*/
49
49
                                /* out: page number of the created segment,
50
50
                                FIL_NULL if fail */
51
51
        ulint   space,          /* in: space id */
52
 
        ulint   zip_size,       /* in: compressed page size in bytes
53
 
                                or 0 for uncompressed pages */
54
52
        ulint   max_size,       /* in: max size in pages */
55
53
        ulint*  slot_no,        /* out: rseg id == slot number in trx sys */
56
54
        mtr_t*  mtr)            /* in: mtr */
59
57
        trx_rsegf_t*    rsegf;
60
58
        trx_sysf_t*     sys_header;
61
59
        ulint           i;
62
 
        buf_block_t*    block;
 
60
        page_t*         page;
63
61
 
64
62
        ut_ad(mtr);
65
63
        ut_ad(mutex_own(&kernel_mutex));
66
 
        ut_ad(mtr_memo_contains(mtr, fil_space_get_latch(space, NULL),
 
64
        ut_ad(mtr_memo_contains(mtr, fil_space_get_latch(space),
67
65
                                MTR_MEMO_X_LOCK));
68
66
        sys_header = trx_sysf_get(mtr);
69
67
 
75
73
        }
76
74
 
77
75
        /* Allocate a new file segment for the rollback segment */
78
 
        block = fseg_create(space, 0,
79
 
                            TRX_RSEG + TRX_RSEG_FSEG_HEADER, mtr);
 
76
        page = fseg_create(space, 0, TRX_RSEG + TRX_RSEG_FSEG_HEADER, mtr);
80
77
 
81
 
        if (block == NULL) {
 
78
        if (page == NULL) {
82
79
                /* No space left */
83
80
 
84
81
                return(FIL_NULL);
85
82
        }
86
83
 
87
84
#ifdef UNIV_SYNC_DEBUG
88
 
        buf_block_dbg_add_level(block, SYNC_RSEG_HEADER_NEW);
 
85
        buf_page_dbg_add_level(page, SYNC_RSEG_HEADER_NEW);
89
86
#endif /* UNIV_SYNC_DEBUG */
90
87
 
91
 
        page_no = buf_block_get_page_no(block);
 
88
        page_no = buf_frame_get_page_no(page);
92
89
 
93
90
        /* Get the rollback segment file page */
94
 
        rsegf = trx_rsegf_get_new(space, zip_size, page_no, mtr);
 
91
        rsegf = trx_rsegf_get_new(space, page_no, mtr);
95
92
 
96
93
        /* Initialize max size field */
97
94
        mlog_write_ulint(rsegf + TRX_RSEG_MAX_SIZE, max_size,
129
126
                                /* out, own: rollback segment object */
130
127
        ulint   id,             /* in: rollback segment id */
131
128
        ulint   space,          /* in: space where the segment placed */
132
 
        ulint   zip_size,       /* in: compressed page size in bytes
133
 
                                or 0 for uncompressed pages */
134
129
        ulint   page_no,        /* in: page number of the segment header */
135
130
        mtr_t*  mtr)            /* in: mtr */
136
131
{
147
142
 
148
143
        rseg->id = id;
149
144
        rseg->space = space;
150
 
        rseg->zip_size = zip_size;
151
145
        rseg->page_no = page_no;
152
146
 
153
147
        mutex_create(&rseg->mutex, SYNC_RSEG);
156
150
 
157
151
        trx_sys_set_nth_rseg(trx_sys, id, rseg);
158
152
 
159
 
        rseg_header = trx_rsegf_get_new(space, zip_size, page_no, mtr);
 
153
        rseg_header = trx_rsegf_get_new(space, page_no, mtr);
160
154
 
161
155
        rseg->max_size = mtr_read_ulint(rseg_header + TRX_RSEG_MAX_SIZE,
162
156
                                        MLOG_4BYTES, mtr);
178
172
                rseg->last_page_no = node_addr.page;
179
173
                rseg->last_offset = node_addr.boffset;
180
174
 
181
 
                undo_log_hdr = trx_undo_page_get(rseg->space, rseg->zip_size,
182
 
                                                 node_addr.page,
 
175
                undo_log_hdr = trx_undo_page_get(rseg->space, node_addr.page,
183
176
                                                 mtr) + node_addr.boffset;
184
177
 
185
178
                rseg->last_trx_no = mtr_read_dulint(
196
189
/*************************************************************************
197
190
Creates the memory copies for rollback segments and initializes the
198
191
rseg list and array in trx_sys at a database startup. */
199
 
UNIV_INTERN
 
192
 
200
193
void
201
194
trx_rseg_list_and_array_init(
202
195
/*=========================*/
219
212
 
220
213
                        trx_sys_set_nth_rseg(trx_sys, i, NULL);
221
214
                } else {
222
 
                        ulint   zip_size;
223
 
 
224
215
                        space = trx_sysf_rseg_get_space(sys_header, i, mtr);
225
216
 
226
 
                        zip_size = space ? fil_space_get_zip_size(space) : 0;
227
 
 
228
 
                        trx_rseg_mem_create(i, space, zip_size, page_no, mtr);
 
217
                        trx_rseg_mem_create(i, space, page_no, mtr);
229
218
                }
230
219
        }
231
220
}
232
221
 
233
222
/********************************************************************
234
223
Creates a new rollback segment to the database. */
235
 
UNIV_INTERN
 
224
 
236
225
trx_rseg_t*
237
226
trx_rseg_create(
238
227
/*============*/
243
232
        ulint*  id,             /* out: rseg id */
244
233
        mtr_t*  mtr)            /* in: mtr */
245
234
{
246
 
        ulint           flags;
247
 
        ulint           zip_size;
248
235
        ulint           page_no;
249
236
        trx_rseg_t*     rseg;
250
237
 
251
 
        mtr_x_lock(fil_space_get_latch(space, &flags), mtr);
252
 
        zip_size = dict_table_flags_to_zip_size(flags);
 
238
        mtr_x_lock(fil_space_get_latch(space), mtr);
253
239
        mutex_enter(&kernel_mutex);
254
240
 
255
 
        page_no = trx_rseg_header_create(space, zip_size, max_size, id, mtr);
 
241
        page_no = trx_rseg_header_create(space, max_size, id, mtr);
256
242
 
257
243
        if (page_no == FIL_NULL) {
258
244
 
260
246
                return(NULL);
261
247
        }
262
248
 
263
 
        rseg = trx_rseg_mem_create(*id, space, zip_size, page_no, mtr);
 
249
        rseg = trx_rseg_mem_create(*id, space, page_no, mtr);
264
250
 
265
251
        mutex_exit(&kernel_mutex);
266
252