← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Brian Aker
  • Date: 2010-10-15 03:36:56 UTC
  • mfrom: (1843.7.6 refactor)
  • Revision ID: brian@tangent.org-20101015033656-9u3aptcc6ipoc1vj
This removes two of our dead plugins (the bad schedulers).
Also this fixes help messages to say "schema" instead of "database"
everywhere..

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
}
188
191
        ulint   page_no,        /*!< in: page number of the segment header */
189
192
        mtr_t*  mtr)            /*!< in: mtr */
190
193
{
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;
195
196
        trx_ulogf_t*    undo_log_hdr;
 
197
        fil_addr_t      node_addr;
196
198
        ulint           sum_of_undo_sizes;
 
199
        ulint           len;
197
200
 
198
201
        ut_ad(mutex_own(&kernel_mutex));
199
202
 
200
 
        rseg = mem_zalloc(sizeof(trx_rseg_t));
 
203
        rseg = mem_alloc(sizeof(trx_rseg_t));
201
204
 
202
205
        rseg->id = id;
203
206
        rseg->space = space;
204
207
        rseg->zip_size = zip_size;
205
208
        rseg->page_no = page_no;
206
209
 
207
 
        mutex_create(rseg_mutex_key, &rseg->mutex, SYNC_RSEG);
 
210
        mutex_create(&rseg->mutex, SYNC_RSEG);
208
211
 
209
212
        UT_LIST_ADD_LAST(rseg_list, trx_sys->rseg_list, rseg);
210
213
 
236
239
                                                 node_addr.page,
237
240
                                                 mtr) + node_addr.boffset;
238
241
 
239
 
                rseg->last_trx_no = mach_read_from_8(
240
 
                        undo_log_hdr + TRX_UNDO_TRX_NO);
 
242
                rseg->last_trx_no = mtr_read_dulint(
 
243
                        undo_log_hdr + TRX_UNDO_TRX_NO, mtr);
241
244
                rseg->last_del_marks = mtr_read_ulint(
242
245
                        undo_log_hdr + TRX_UNDO_DEL_MARKS, MLOG_2BYTES, mtr);
243
246
        } else {
247
250
        return(rseg);
248
251
}
249
252
 
250
 
/********************************************************************
251
 
Creates the memory copies for the rollback segments and initializes the
 
253
/*********************************************************************//**
 
254
Creates the memory copies for rollback segments and initializes the
252
255
rseg list and array in trx_sys at a database startup. */
253
 
static
 
256
UNIV_INTERN
254
257
void
255
 
trx_rseg_create_instance(
256
 
/*=====================*/
 
258
trx_rseg_list_and_array_init(
 
259
/*=========================*/
257
260
        trx_sysf_t*     sys_header,     /*!< in: trx system header */
258
261
        mtr_t*          mtr)            /*!< in: mtr */
259
262
{
260
 
        ulint           i;
 
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
270
 
262
271
        for (i = 0; i < TRX_SYS_N_RSEGS; i++) {
263
 
                ulint   page_no;
264
272
 
265
273
                page_no = trx_sysf_rseg_get_page_no(sys_header, i, mtr);
266
274
 
267
275
                if (page_no == FIL_NULL) {
 
276
 
268
277
                        trx_sys_set_nth_rseg(trx_sys, i, NULL);
269
278
                } else {
270
 
                        ulint           space;
271
 
                        ulint           zip_size;
272
 
                        trx_rseg_t*     rseg = NULL;
273
 
 
274
 
                        ut_a(!trx_rseg_get_on_id(i));
 
279
                        ulint   zip_size;
275
280
 
276
281
                        space = trx_sysf_rseg_get_space(sys_header, i, mtr);
277
282
 
278
283
                        zip_size = space ? fil_space_get_zip_size(space) : 0;
279
284
 
280
 
                        rseg = trx_rseg_mem_create(
281
 
                                i, space, zip_size, page_no, mtr);
282
 
 
283
 
                        ut_a(rseg->id == i);
 
285
                        trx_rseg_mem_create(i, space, zip_size, page_no, mtr);
284
286
                }
285
287
        }
286
288
}
287
289
 
288
 
/*********************************************************************
289
 
Creates a rollback segment.
290
 
@return pointer to new rollback segment if create successful */
 
290
/****************************************************************//**
 
291
Creates a new rollback segment to the database.
 
292
@return the created segment object, NULL if fail */
291
293
UNIV_INTERN
292
294
trx_rseg_t*
293
 
trx_rseg_create(void)
294
 
/*=================*/
 
295
trx_rseg_create(
 
296
/*============*/
 
297
        ulint   space,          /*!< in: space id */
 
298
        ulint   max_size,       /*!< in: max size in pages */
 
299
        ulint*  id,             /*!< out: rseg id */
 
300
        mtr_t*  mtr)            /*!< in: mtr */
295
301
{
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
 
 
 
302
        ulint           flags;
 
303
        ulint           zip_size;
 
304
        ulint           page_no;
 
305
        trx_rseg_t*     rseg;
 
306
 
 
307
        mtr_x_lock(fil_space_get_latch(space, &flags), mtr);
 
308
        zip_size = dict_table_flags_to_zip_size(flags);
306
309
        mutex_enter(&kernel_mutex);
307
310
 
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);
 
311
        page_no = trx_rseg_header_create(space, zip_size, max_size, id, mtr);
 
312
 
 
313
        if (page_no == FIL_NULL) {
 
314
 
 
315
                mutex_exit(&kernel_mutex);
 
316
                return(NULL);
331
317
        }
332
318
 
 
319
        rseg = trx_rseg_mem_create(*id, space, zip_size, page_no, mtr);
 
320
 
333
321
        mutex_exit(&kernel_mutex);
334
 
        mtr_commit(&mtr);
335
322
 
336
323
        return(rseg);
337
324
}
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