← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Monty Taylor
  • Date: 2011-02-13 17:26:39 UTC
  • mfrom: (2157.2.2 give-in-to-pkg-config)
  • mto: This revision was merged to the branch mainline in revision 2166.
  • Revision ID: mordred@inaugust.com-20110213172639-nhy7i72sfhoq13ms
Merged in pkg-config fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/trx/trx0rseg.cc
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (c) 1996, 2010, Innobase Oy. All Rights Reserved.
 
3
Copyright (C) 1996, 2010, 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
 
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
        void *rseg_buf= mem_zalloc(sizeof(trx_rseg_t));
 
201
        rseg = static_cast<trx_rseg_t *>(rseg_buf);
204
202
 
205
203
        rseg->id = id;
206
204
        rseg->space = space;
207
205
        rseg->zip_size = zip_size;
208
206
        rseg->page_no = page_no;
209
207
 
210
 
        mutex_create(&rseg->mutex, SYNC_RSEG);
 
208
        mutex_create(rseg_mutex_key, &rseg->mutex, SYNC_RSEG);
211
209
 
212
210
        UT_LIST_ADD_LAST(rseg_list, trx_sys->rseg_list, rseg);
213
211
 
239
237
                                                 node_addr.page,
240
238
                                                 mtr) + node_addr.boffset;
241
239
 
242
 
                rseg->last_trx_no = mtr_read_dulint(
243
 
                        undo_log_hdr + TRX_UNDO_TRX_NO, mtr);
 
240
                rseg->last_trx_no = mach_read_from_8(
 
241
                        undo_log_hdr + TRX_UNDO_TRX_NO);
244
242
                rseg->last_del_marks = mtr_read_ulint(
245
243
                        undo_log_hdr + TRX_UNDO_DEL_MARKS, MLOG_2BYTES, mtr);
246
244
        } else {
250
248
        return(rseg);
251
249
}
252
250
 
253
 
/*********************************************************************//**
254
 
Creates the memory copies for rollback segments and initializes the
 
251
/********************************************************************
 
252
Creates the memory copies for the rollback segments and initializes the
255
253
rseg list and array in trx_sys at a database startup. */
256
 
UNIV_INTERN
 
254
static
257
255
void
258
 
trx_rseg_list_and_array_init(
259
 
/*=========================*/
 
256
trx_rseg_create_instance(
 
257
/*=====================*/
260
258
        trx_sysf_t*     sys_header,     /*!< in: trx system header */
261
259
        mtr_t*          mtr)            /*!< in: mtr */
262
260
{
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;
 
261
        ulint           i;
270
262
 
271
263
        for (i = 0; i < TRX_SYS_N_RSEGS; i++) {
 
264
                ulint   page_no;
272
265
 
273
266
                page_no = trx_sysf_rseg_get_page_no(sys_header, i, mtr);
274
267
 
275
268
                if (page_no == FIL_NULL) {
276
 
 
277
269
                        trx_sys_set_nth_rseg(trx_sys, i, NULL);
278
270
                } else {
279
 
                        ulint   zip_size;
 
271
                        ulint           space;
 
272
                        ulint           zip_size;
 
273
                        trx_rseg_t*     rseg = NULL;
 
274
 
 
275
                        ut_a(!trx_rseg_get_on_id(i));
280
276
 
281
277
                        space = trx_sysf_rseg_get_space(sys_header, i, mtr);
282
278
 
283
279
                        zip_size = space ? fil_space_get_zip_size(space) : 0;
284
280
 
285
 
                        trx_rseg_mem_create(i, space, zip_size, page_no, mtr);
 
281
                        rseg = trx_rseg_mem_create(
 
282
                                i, space, zip_size, page_no, mtr);
 
283
 
 
284
                        ut_a(rseg->id == i);
286
285
                }
287
286
        }
288
287
}
 
288
 
 
289
/*********************************************************************
 
290
Creates a rollback segment.
 
291
@return pointer to new rollback segment if create successful */
 
292
UNIV_INTERN
 
293
trx_rseg_t*
 
294
trx_rseg_create(void)
 
295
/*=================*/
 
296
{
 
297
        mtr_t           mtr;
 
298
        ulint           slot_no;
 
299
        trx_rseg_t*     rseg = NULL;
 
300
 
 
301
        mtr_start(&mtr);
 
302
 
 
303
        /* To obey the latching order, acquire the file space
 
304
        x-latch before the kernel mutex. */
 
305
        mtr_x_lock(fil_space_get_latch(TRX_SYS_SPACE, NULL), &mtr);
 
306
 
 
307
        mutex_enter(&kernel_mutex);
 
308
 
 
309
        slot_no = trx_sysf_rseg_find_free(&mtr);
 
310
 
 
311
        if (slot_no != ULINT_UNDEFINED) {
 
312
                ulint           space;
 
313
                ulint           page_no;
 
314
                ulint           zip_size;
 
315
                trx_sysf_t*     sys_header;
 
316
 
 
317
                page_no = trx_rseg_header_create(
 
318
                        TRX_SYS_SPACE, 0, ULINT_MAX, slot_no, &mtr);
 
319
 
 
320
                ut_a(page_no != FIL_NULL);
 
321
 
 
322
                ut_ad(!trx_rseg_get_on_id(slot_no));
 
323
 
 
324
                sys_header = trx_sysf_get(&mtr);
 
325
 
 
326
                space = trx_sysf_rseg_get_space(sys_header, slot_no, &mtr);
 
327
 
 
328
                zip_size = space ? fil_space_get_zip_size(space) : 0;
 
329
 
 
330
                rseg = trx_rseg_mem_create(
 
331
                        slot_no, space, zip_size, page_no, &mtr);
 
332
        }
 
333
 
 
334
        mutex_exit(&kernel_mutex);
 
335
        mtr_commit(&mtr);
 
336
 
 
337
        return(rseg);
 
338
}
 
339
 
 
340
/********************************************************************
 
341
Initialize the rollback instance list. */
 
342
UNIV_INTERN
 
343
void
 
344
trx_rseg_list_and_array_init(
 
345
/*=========================*/
 
346
        trx_sysf_t*     sys_header,     /* in: trx system header */
 
347
        mtr_t*          mtr)            /* in: mtr */
 
348
{
 
349
        UT_LIST_INIT(trx_sys->rseg_list);
 
350
 
 
351
        trx_sys->rseg_history_len = 0;
 
352
 
 
353
        trx_rseg_create_instance(sys_header, mtr);
 
354
}
 
355