← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: tdavies
  • Date: 2010-10-13 01:29:12 UTC
  • mto: (1842.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 1843.
  • Revision ID: tdavies@molly-20101013012912-vl72hg1y99qgqz5m
File: /drizzled/xid.h. Changed struct name of 'st_drizzle_xid' to 'drizzle_xid', changed it to a C++ class and added constructor initialization list 

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/trx/trx0rseg.c
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (c) 1996, 2010, Innobase Oy. All Rights Reserved.
 
3
Copyright (c) 1996, 2009, Innobase Oy. All Rights Reserved.
4
4
 
5
5
This program is free software; you can redistribute it and/or modify it under
6
6
the terms of the GNU General Public License as published by the Free Software
34
34
#include "srv0srv.h"
35
35
#include "trx0purge.h"
36
36
 
37
 
#ifdef UNIV_PFS_MUTEX
38
 
/* Key to register rseg_mutex_key with performance schema */
39
 
UNIV_INTERN mysql_pfs_key_t     rseg_mutex_key;
40
 
#endif /* UNIV_PFS_MUTEX */
41
 
 
42
37
/******************************************************************//**
43
38
Looks for a rollback segment, based on the rollback segment id.
44
39
@return rollback segment */
51
46
        trx_rseg_t*     rseg;
52
47
 
53
48
        rseg = UT_LIST_GET_FIRST(trx_sys->rseg_list);
 
49
        ut_ad(rseg);
54
50
 
55
 
        while (rseg && rseg->id != id) {
 
51
        while (rseg->id != id) {
56
52
                rseg = UT_LIST_GET_NEXT(rseg_list, rseg);
 
53
                ut_ad(rseg);
57
54
        }
58
55
 
59
56
        return(rseg);
71
68
        ulint   zip_size,       /*!< in: compressed page size in bytes
72
69
                                or 0 for uncompressed pages */
73
70
        ulint   max_size,       /*!< in: max size in pages */
74
 
        ulint   rseg_slot_no,   /*!< in: rseg id == slot number in trx sys */
 
71
        ulint*  slot_no,        /*!< out: rseg id == slot number in trx sys */
75
72
        mtr_t*  mtr)            /*!< in: mtr */
76
73
{
77
74
        ulint           page_no;
84
81
        ut_ad(mutex_own(&kernel_mutex));
85
82
        ut_ad(mtr_memo_contains(mtr, fil_space_get_latch(space, NULL),
86
83
                                MTR_MEMO_X_LOCK));
 
84
        sys_header = trx_sysf_get(mtr);
 
85
 
 
86
        *slot_no = trx_sysf_rseg_find_free(mtr);
 
87
 
 
88
        if (*slot_no == ULINT_UNDEFINED) {
 
89
 
 
90
                return(FIL_NULL);
 
91
        }
87
92
 
88
93
        /* Allocate a new file segment for the rollback segment */
89
94
        block = fseg_create(space, 0,
117
122
                trx_rsegf_set_nth_undo(rsegf, i, FIL_NULL, mtr);
118
123
        }
119
124
 
120
 
        /* Add the rollback segment info to the free slot in
121
 
        the trx system header */
122
 
 
123
 
        sys_header = trx_sysf_get(mtr);
124
 
 
125
 
        trx_sysf_rseg_set_space(sys_header, rseg_slot_no, space, mtr);
126
 
        trx_sysf_rseg_set_page_no(sys_header, rseg_slot_no, page_no, mtr);
 
125
        /* Add the rollback segment info to the free slot in the trx system
 
126
        header */
 
127
 
 
128
        trx_sysf_rseg_set_space(sys_header, *slot_no, space, mtr);
 
129
        trx_sysf_rseg_set_page_no(sys_header, *slot_no, page_no, mtr);
127
130
 
128
131
        return(page_no);
129
132
}
130
133
 
131
134
/***********************************************************************//**
132
 
Free's an instance of the rollback segment in memory. */
133
 
UNIV_INTERN
134
 
void
135
 
trx_rseg_mem_free(
136
 
/*==============*/
137
 
        trx_rseg_t*     rseg)   /* in, own: instance to free */
138
 
{
139
 
        trx_undo_t*     undo;
140
 
 
141
 
        mutex_free(&rseg->mutex);
142
 
 
143
 
        /* There can't be any active transactions. */
144
 
        ut_a(UT_LIST_GET_LEN(rseg->update_undo_list) == 0);
145
 
        ut_a(UT_LIST_GET_LEN(rseg->insert_undo_list) == 0);
146
 
 
147
 
        undo = UT_LIST_GET_FIRST(rseg->update_undo_cached);
148
 
 
149
 
        while (undo != NULL) {
150
 
                trx_undo_t*     prev_undo = undo;
151
 
 
152
 
                undo = UT_LIST_GET_NEXT(undo_list, undo);
153
 
                UT_LIST_REMOVE(undo_list, rseg->update_undo_cached, prev_undo);
154
 
 
155
 
                trx_undo_mem_free(prev_undo);
156
 
        }
157
 
 
158
 
        undo = UT_LIST_GET_FIRST(rseg->insert_undo_cached);
159
 
 
160
 
        while (undo != NULL) {
161
 
                trx_undo_t*     prev_undo = undo;
162
 
 
163
 
                undo = UT_LIST_GET_NEXT(undo_list, undo);
164
 
                UT_LIST_REMOVE(undo_list, rseg->insert_undo_cached, prev_undo);
165
 
 
166
 
                trx_undo_mem_free(prev_undo);
167
 
        }
168
 
 
169
 
        trx_sys_set_nth_rseg(trx_sys, rseg->id, NULL);
170
 
 
171
 
        mem_free(rseg);
172
 
}
173
 
 
174
 
/***************************************************************************
175
135
Creates and initializes a rollback segment object. The values for the
176
136
fields are read from the header. The object is inserted to the rseg
177
137
list of the trx system object and a pointer is inserted in the rseg
188
148
        ulint   page_no,        /*!< in: page number of the segment header */
189
149
        mtr_t*  mtr)            /*!< in: mtr */
190
150
{
191
 
        ulint           len;
192
 
        trx_rseg_t*     rseg;
193
 
        fil_addr_t      node_addr;
194
151
        trx_rsegf_t*    rseg_header;
 
152
        trx_rseg_t*     rseg;
195
153
        trx_ulogf_t*    undo_log_hdr;
 
154
        fil_addr_t      node_addr;
196
155
        ulint           sum_of_undo_sizes;
 
156
        ulint           len;
197
157
 
198
158
        ut_ad(mutex_own(&kernel_mutex));
199
159
 
200
 
        rseg = mem_zalloc(sizeof(trx_rseg_t));
 
160
        rseg = mem_alloc(sizeof(trx_rseg_t));
201
161
 
202
162
        rseg->id = id;
203
163
        rseg->space = space;
204
164
        rseg->zip_size = zip_size;
205
165
        rseg->page_no = page_no;
206
166
 
207
 
        mutex_create(rseg_mutex_key, &rseg->mutex, SYNC_RSEG);
 
167
        mutex_create(&rseg->mutex, SYNC_RSEG);
208
168
 
209
169
        UT_LIST_ADD_LAST(rseg_list, trx_sys->rseg_list, rseg);
210
170
 
236
196
                                                 node_addr.page,
237
197
                                                 mtr) + node_addr.boffset;
238
198
 
239
 
                rseg->last_trx_no = mach_read_from_8(
240
 
                        undo_log_hdr + TRX_UNDO_TRX_NO);
 
199
                rseg->last_trx_no = mtr_read_dulint(
 
200
                        undo_log_hdr + TRX_UNDO_TRX_NO, mtr);
241
201
                rseg->last_del_marks = mtr_read_ulint(
242
202
                        undo_log_hdr + TRX_UNDO_DEL_MARKS, MLOG_2BYTES, mtr);
243
203
        } else {
247
207
        return(rseg);
248
208
}
249
209
 
250
 
/********************************************************************
251
 
Creates the memory copies for the rollback segments and initializes the
 
210
/*********************************************************************//**
 
211
Creates the memory copies for rollback segments and initializes the
252
212
rseg list and array in trx_sys at a database startup. */
253
 
static
 
213
UNIV_INTERN
254
214
void
255
 
trx_rseg_create_instance(
256
 
/*=====================*/
 
215
trx_rseg_list_and_array_init(
 
216
/*=========================*/
257
217
        trx_sysf_t*     sys_header,     /*!< in: trx system header */
258
218
        mtr_t*          mtr)            /*!< in: mtr */
259
219
{
260
 
        ulint           i;
 
220
        ulint   i;
 
221
        ulint   page_no;
 
222
        ulint   space;
 
223
 
 
224
        UT_LIST_INIT(trx_sys->rseg_list);
 
225
 
 
226
        trx_sys->rseg_history_len = 0;
261
227
 
262
228
        for (i = 0; i < TRX_SYS_N_RSEGS; i++) {
263
 
                ulint   page_no;
264
229
 
265
230
                page_no = trx_sysf_rseg_get_page_no(sys_header, i, mtr);
266
231
 
267
232
                if (page_no == FIL_NULL) {
 
233
 
268
234
                        trx_sys_set_nth_rseg(trx_sys, i, NULL);
269
235
                } else {
270
 
                        ulint           space;
271
 
                        ulint           zip_size;
272
 
                        trx_rseg_t*     rseg = NULL;
273
 
 
274
 
                        ut_a(!trx_rseg_get_on_id(i));
 
236
                        ulint   zip_size;
275
237
 
276
238
                        space = trx_sysf_rseg_get_space(sys_header, i, mtr);
277
239
 
278
240
                        zip_size = space ? fil_space_get_zip_size(space) : 0;
279
241
 
280
 
                        rseg = trx_rseg_mem_create(
281
 
                                i, space, zip_size, page_no, mtr);
282
 
 
283
 
                        ut_a(rseg->id == i);
 
242
                        trx_rseg_mem_create(i, space, zip_size, page_no, mtr);
284
243
                }
285
244
        }
286
245
}
287
246
 
288
 
/*********************************************************************
289
 
Creates a rollback segment.
290
 
@return pointer to new rollback segment if create successful */
 
247
/****************************************************************//**
 
248
Creates a new rollback segment to the database.
 
249
@return the created segment object, NULL if fail */
291
250
UNIV_INTERN
292
251
trx_rseg_t*
293
 
trx_rseg_create(void)
294
 
/*=================*/
 
252
trx_rseg_create(
 
253
/*============*/
 
254
        ulint   space,          /*!< in: space id */
 
255
        ulint   max_size,       /*!< in: max size in pages */
 
256
        ulint*  id,             /*!< out: rseg id */
 
257
        mtr_t*  mtr)            /*!< in: mtr */
295
258
{
296
 
        mtr_t           mtr;
297
 
        ulint           slot_no;
298
 
        trx_rseg_t*     rseg = NULL;
299
 
 
300
 
        mtr_start(&mtr);
301
 
 
302
 
        /* To obey the latching order, acquire the file space
303
 
        x-latch before the kernel mutex. */
304
 
        mtr_x_lock(fil_space_get_latch(TRX_SYS_SPACE, NULL), &mtr);
305
 
 
 
259
        ulint           flags;
 
260
        ulint           zip_size;
 
261
        ulint           page_no;
 
262
        trx_rseg_t*     rseg;
 
263
 
 
264
        mtr_x_lock(fil_space_get_latch(space, &flags), mtr);
 
265
        zip_size = dict_table_flags_to_zip_size(flags);
306
266
        mutex_enter(&kernel_mutex);
307
267
 
308
 
        slot_no = trx_sysf_rseg_find_free(&mtr);
309
 
 
310
 
        if (slot_no != ULINT_UNDEFINED) {
311
 
                ulint           space;
312
 
                ulint           page_no;
313
 
                ulint           zip_size;
314
 
                trx_sysf_t*     sys_header;
315
 
 
316
 
                page_no = trx_rseg_header_create(
317
 
                        TRX_SYS_SPACE, 0, ULINT_MAX, slot_no, &mtr);
318
 
 
319
 
                ut_a(page_no != FIL_NULL);
320
 
 
321
 
                ut_ad(!trx_rseg_get_on_id(slot_no));
322
 
 
323
 
                sys_header = trx_sysf_get(&mtr);
324
 
 
325
 
                space = trx_sysf_rseg_get_space(sys_header, slot_no, &mtr);
326
 
 
327
 
                zip_size = space ? fil_space_get_zip_size(space) : 0;
328
 
 
329
 
                rseg = trx_rseg_mem_create(
330
 
                        slot_no, space, zip_size, page_no, &mtr);
 
268
        page_no = trx_rseg_header_create(space, zip_size, max_size, id, mtr);
 
269
 
 
270
        if (page_no == FIL_NULL) {
 
271
 
 
272
                mutex_exit(&kernel_mutex);
 
273
                return(NULL);
331
274
        }
332
275
 
 
276
        rseg = trx_rseg_mem_create(*id, space, zip_size, page_no, mtr);
 
277
 
333
278
        mutex_exit(&kernel_mutex);
334
 
        mtr_commit(&mtr);
335
279
 
336
280
        return(rseg);
337
281
}
338
 
 
339
 
/********************************************************************
340
 
Initialize the rollback instance list. */
341
 
UNIV_INTERN
342
 
void
343
 
trx_rseg_list_and_array_init(
344
 
/*=========================*/
345
 
        trx_sysf_t*     sys_header,     /* in: trx system header */
346
 
        mtr_t*          mtr)            /* in: mtr */
347
 
{
348
 
        UT_LIST_INIT(trx_sys->rseg_list);
349
 
 
350
 
        trx_sys->rseg_history_len = 0;
351
 
 
352
 
        trx_rseg_create_instance(sys_header, mtr);
353
 
}
354