← Back to branch summary

~ubuntu-branches/ubuntu/trusty/drizzle/trusty

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Monty Taylor
  • Date: 2010-12-09 06:02:39 UTC
  • mto: This revision was merged to the branch mainline in revision 5.
  • Revision ID: james.westby@ubuntu.com-20101209060239-t0ujftvcvd558yno
Tags: upstream-2010.12.05
Import upstream version 2010.12.05

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
 
239
236
                                                 node_addr.page,
240
237
                                                 mtr) + node_addr.boffset;
241
238
 
242
 
                rseg->last_trx_no = mtr_read_dulint(
243
 
                        undo_log_hdr + TRX_UNDO_TRX_NO, mtr);
 
239
                rseg->last_trx_no = mach_read_from_8(
 
240
                        undo_log_hdr + TRX_UNDO_TRX_NO);
244
241
                rseg->last_del_marks = mtr_read_ulint(
245
242
                        undo_log_hdr + TRX_UNDO_DEL_MARKS, MLOG_2BYTES, mtr);
246
243
        } else {
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