← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

Merge initial InnoDB+ import.

This was applied by generating a patch between MySQL 5.1.50 InnoDB plugin and
the just-merged innodb+ from mysql-trunk revision-id: vasil.dimov@oracle.com-20100422110752-1zowoqxel5xx3z2e

Then, some manual merge resolving and it worked. This should make it much
easier to merge the rest of InnoDB 1.1 and 1.2 from the mysql tree using
my bzr-reapply script.

This takes us to InnoDB 1.1.1(ish).

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/trx/trx0rseg.c
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
 
37
42
/******************************************************************//**
38
43
Looks for a rollback segment, based on the rollback segment id.
39
44
@return rollback segment */
46
51
        trx_rseg_t*     rseg;
47
52
 
48
53
        rseg = UT_LIST_GET_FIRST(trx_sys->rseg_list);
49
 
        ut_ad(rseg);
50
54
 
51
 
        while (rseg->id != id) {
 
55
        while (rseg && rseg->id != id) {
52
56
                rseg = UT_LIST_GET_NEXT(rseg_list, rseg);
53
 
                ut_ad(rseg);
54
57
        }
55
58
 
56
59
        return(rseg);
68
71
        ulint   zip_size,       /*!< in: compressed page size in bytes
69
72
                                or 0 for uncompressed pages */
70
73
        ulint   max_size,       /*!< in: max size in pages */
71
 
        ulint*  slot_no,        /*!< out: rseg id == slot number in trx sys */
 
74
        ulint   rseg_slot_no,   /*!< in: rseg id == slot number in trx sys */
72
75
        mtr_t*  mtr)            /*!< in: mtr */
73
76
{
74
77
        ulint           page_no;
81
84
        ut_ad(mutex_own(&kernel_mutex));
82
85
        ut_ad(mtr_memo_contains(mtr, fil_space_get_latch(space, NULL),
83
86
                                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
 
        }
92
87
 
93
88
        /* Allocate a new file segment for the rollback segment */
94
89
        block = fseg_create(space, 0,
122
117
                trx_rsegf_set_nth_undo(rsegf, i, FIL_NULL, mtr);
123
118
        }
124
119
 
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);
 
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);
130
127
 
131
128
        return(page_no);
132
129
}
191
188
        ulint   page_no,        /*!< in: page number of the segment header */
192
189
        mtr_t*  mtr)            /*!< in: mtr */
193
190
{
 
191
        ulint           len;
 
192
        trx_rseg_t*     rseg;
 
193
        fil_addr_t      node_addr;
194
194
        trx_rsegf_t*    rseg_header;
195
 
        trx_rseg_t*     rseg;
196
195
        trx_ulogf_t*    undo_log_hdr;
197
 
        fil_addr_t      node_addr;
198
196
        ulint           sum_of_undo_sizes;
199
 
        ulint           len;
200
197
 
201
198
        ut_ad(mutex_own(&kernel_mutex));
202
199
 
203
 
        rseg = mem_alloc(sizeof(trx_rseg_t));
 
200
        rseg = mem_zalloc(sizeof(trx_rseg_t));
204
201
 
205
202
        rseg->id = id;
206
203
        rseg->space = space;
207
204
        rseg->zip_size = zip_size;
208
205
        rseg->page_no = page_no;
209
206
 
210
 
        mutex_create(&rseg->mutex, SYNC_RSEG);
 
207
        mutex_create(rseg_mutex_key, &rseg->mutex, SYNC_RSEG);
211
208
 
212
209
        UT_LIST_ADD_LAST(rseg_list, trx_sys->rseg_list, rseg);
213
210
 
250
247
        return(rseg);
251
248
}
252
249
 
253
 
/*********************************************************************//**
254
 
Creates the memory copies for rollback segments and initializes the
 
250
/********************************************************************
 
251
Creates the memory copies for the rollback segments and initializes the
255
252
rseg list and array in trx_sys at a database startup. */
256
 
UNIV_INTERN
 
253
static
257
254
void
258
 
trx_rseg_list_and_array_init(
259
 
/*=========================*/
 
255
trx_rseg_create_instance(
 
256
/*=====================*/
260
257
        trx_sysf_t*     sys_header,     /*!< in: trx system header */
261
258
        mtr_t*          mtr)            /*!< in: mtr */
262
259
{
263
 
        ulint   i;
264
 
        ulint   page_no;
265
 
        ulint   space;
266
 
 
267
 
        UT_LIST_INIT(trx_sys->rseg_list);
268
 
 
269
 
        trx_sys->rseg_history_len = 0;
 
260
        ulint           i;
270
261
 
271
262
        for (i = 0; i < TRX_SYS_N_RSEGS; i++) {
 
263
                ulint   page_no;
272
264
 
273
265
                page_no = trx_sysf_rseg_get_page_no(sys_header, i, mtr);
274
266
 
275
267
                if (page_no == FIL_NULL) {
276
 
 
277
268
                        trx_sys_set_nth_rseg(trx_sys, i, NULL);
278
269
                } else {
279
 
                        ulint   zip_size;
 
270
                        ulint           space;
 
271
                        ulint           zip_size;
 
272
                        trx_rseg_t*     rseg = NULL;
 
273
 
 
274
                        ut_a(!trx_rseg_get_on_id(i));
280
275
 
281
276
                        space = trx_sysf_rseg_get_space(sys_header, i, mtr);
282
277
 
283
278
                        zip_size = space ? fil_space_get_zip_size(space) : 0;
284
279
 
285
 
                        trx_rseg_mem_create(i, space, zip_size, page_no, mtr);
 
280
                        rseg = trx_rseg_mem_create(
 
281
                                i, space, zip_size, page_no, mtr);
 
282
 
 
283
                        ut_a(rseg->id == i);
286
284
                }
287
285
        }
288
286
}
 
287
 
 
288
/*********************************************************************
 
289
Creates a rollback segment.
 
290
@return pointer to new rollback segment if create successful */
 
291
UNIV_INTERN
 
292
trx_rseg_t*
 
293
trx_rseg_create(void)
 
294
/*=================*/
 
295
{
 
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
 
 
306
        mutex_enter(&kernel_mutex);
 
307
 
 
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);
 
331
        }
 
332
 
 
333
        mutex_exit(&kernel_mutex);
 
334
        mtr_commit(&mtr);
 
335
 
 
336
        return(rseg);
 
337
}
 
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