← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/trx0sys.h

  • Committer: Brian Aker
  • Date: 2010-12-18 18:24:57 UTC
  • mfrom: (1999.6.3 trunk)
  • Revision ID: brian@tangent.org-20101218182457-yi1wd0so2hml1k1w
Merge in Lee's copyright header fix

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/trx0sys.h
1
 
/******************************************************
2
 
Transaction system
3
 
 
4
 
(c) 1996 Innobase Oy
5
 
 
6
 
Created 3/26/1996 Heikki Tuuri
7
 
*******************************************************/
8
 
 
9
 
#ifndef trx0sys_h
10
 
#define trx0sys_h
11
 
 
12
 
#include "univ.i"
13
 
 
14
 
#include "trx0types.h"
15
 
#include "mtr0mtr.h"
16
 
#include "mtr0log.h"
17
 
#include "ut0byte.h"
18
 
#include "mem0mem.h"
19
 
#include "sync0sync.h"
20
 
#include "ut0lst.h"
21
 
#include "buf0buf.h"
22
 
#include "fil0fil.h"
23
 
#include "fut0lst.h"
24
 
#include "fsp0fsp.h"
25
 
#include "read0types.h"
26
 
 
27
 
/* In a MySQL replication slave, in crash recovery we store the master log
28
 
file name and position here. We have successfully got the updates to InnoDB
29
 
up to this position. If .._pos is -1, it means no crash recovery was needed,
30
 
or there was no master log position info inside InnoDB. */
31
 
 
32
 
extern char             trx_sys_mysql_master_log_name[];
33
 
extern ib_longlong      trx_sys_mysql_master_log_pos;
34
 
 
35
 
/* If this MySQL server uses binary logging, after InnoDB has been inited
36
 
and if it has done a crash recovery, we store the binlog file name and position
37
 
here. If .._pos is -1, it means there was no binlog position info inside
38
 
InnoDB. */
39
 
 
40
 
extern char             trx_sys_mysql_bin_log_name[];
41
 
extern ib_longlong      trx_sys_mysql_bin_log_pos;
42
 
 
43
 
/* The transaction system */
44
 
extern trx_sys_t*       trx_sys;
45
 
 
46
 
/* Doublewrite system */
47
 
extern trx_doublewrite_t*       trx_doublewrite;
48
 
extern ibool                    trx_doublewrite_must_reset_space_ids;
49
 
extern ibool                    trx_sys_multiple_tablespace_format;
50
 
 
51
 
/********************************************************************
52
 
Creates the doublewrite buffer to a new InnoDB installation. The header of the
53
 
doublewrite buffer is placed on the trx system header page. */
54
 
 
55
 
void
56
 
trx_sys_create_doublewrite_buf(void);
57
 
/*================================*/
58
 
/********************************************************************
59
 
At a database startup initializes the doublewrite buffer memory structure if
60
 
we already have a doublewrite buffer created in the data files. If we are
61
 
upgrading to an InnoDB version which supports multiple tablespaces, then this
62
 
function performs the necessary update operations. If we are in a crash
63
 
recovery, this function uses a possible doublewrite buffer to restore
64
 
half-written pages in the data files. */
65
 
 
66
 
void
67
 
trx_sys_doublewrite_init_or_restore_pages(
68
 
/*======================================*/
69
 
        ibool   restore_corrupt_pages);
70
 
/********************************************************************
71
 
Marks the trx sys header when we have successfully upgraded to the >= 4.1.x
72
 
multiple tablespace format. */
73
 
 
74
 
void
75
 
trx_sys_mark_upgraded_to_multiple_tablespaces(void);
76
 
/*===============================================*/
77
 
/********************************************************************
78
 
Determines if a page number is located inside the doublewrite buffer. */
79
 
 
80
 
ibool
81
 
trx_doublewrite_page_inside(
82
 
/*========================*/
83
 
                                /* out: TRUE if the location is inside
84
 
                                the two blocks of the doublewrite buffer */
85
 
        ulint   page_no);       /* in: page number */
86
 
/*******************************************************************
87
 
Checks if a page address is the trx sys header page. */
88
 
UNIV_INLINE
89
 
ibool
90
 
trx_sys_hdr_page(
91
 
/*=============*/
92
 
                        /* out: TRUE if trx sys header page */
93
 
        ulint   space,  /* in: space */
94
 
        ulint   page_no);/* in: page number */
95
 
/*********************************************************************
96
 
Creates and initializes the central memory structures for the transaction
97
 
system. This is called when the database is started. */
98
 
 
99
 
void
100
 
trx_sys_init_at_db_start(void);
101
 
/*==========================*/
102
 
/*********************************************************************
103
 
Creates and initializes the transaction system at the database creation. */
104
 
 
105
 
void
106
 
trx_sys_create(void);
107
 
/*================*/
108
 
/********************************************************************
109
 
Looks for a free slot for a rollback segment in the trx system file copy. */
110
 
 
111
 
ulint
112
 
trx_sysf_rseg_find_free(
113
 
/*====================*/
114
 
                                        /* out: slot index or ULINT_UNDEFINED
115
 
                                        if not found */
116
 
        mtr_t*          mtr);           /* in: mtr */
117
 
/*******************************************************************
118
 
Gets the pointer in the nth slot of the rseg array. */
119
 
UNIV_INLINE
120
 
trx_rseg_t*
121
 
trx_sys_get_nth_rseg(
122
 
/*=================*/
123
 
                                /* out: pointer to rseg object, NULL if slot
124
 
                                not in use */
125
 
        trx_sys_t*      sys,    /* in: trx system */
126
 
        ulint           n);     /* in: index of slot */
127
 
/*******************************************************************
128
 
Sets the pointer in the nth slot of the rseg array. */
129
 
UNIV_INLINE
130
 
void
131
 
trx_sys_set_nth_rseg(
132
 
/*=================*/
133
 
        trx_sys_t*      sys,    /* in: trx system */
134
 
        ulint           n,      /* in: index of slot */
135
 
        trx_rseg_t*     rseg);  /* in: pointer to rseg object, NULL if slot
136
 
                                not in use */
137
 
/**************************************************************************
138
 
Gets a pointer to the transaction system file copy and x-locks its page. */
139
 
UNIV_INLINE
140
 
trx_sysf_t*
141
 
trx_sysf_get(
142
 
/*=========*/
143
 
                        /* out: pointer to system file copy, page x-locked */
144
 
        mtr_t*  mtr);   /* in: mtr */
145
 
/*********************************************************************
146
 
Gets the space of the nth rollback segment slot in the trx system
147
 
file copy. */
148
 
UNIV_INLINE
149
 
ulint
150
 
trx_sysf_rseg_get_space(
151
 
/*====================*/
152
 
                                        /* out: space id */
153
 
        trx_sysf_t*     sys_header,     /* in: trx sys file copy */
154
 
        ulint           i,              /* in: slot index == rseg id */
155
 
        mtr_t*          mtr);           /* in: mtr */
156
 
/*********************************************************************
157
 
Gets the page number of the nth rollback segment slot in the trx system
158
 
file copy. */
159
 
UNIV_INLINE
160
 
ulint
161
 
trx_sysf_rseg_get_page_no(
162
 
/*======================*/
163
 
                                        /* out: page number, FIL_NULL
164
 
                                        if slot unused */
165
 
        trx_sysf_t*     sys_header,     /* in: trx sys file copy */
166
 
        ulint           i,              /* in: slot index == rseg id */
167
 
        mtr_t*          mtr);           /* in: mtr */
168
 
/*********************************************************************
169
 
Sets the space id of the nth rollback segment slot in the trx system
170
 
file copy. */
171
 
UNIV_INLINE
172
 
void
173
 
trx_sysf_rseg_set_space(
174
 
/*====================*/
175
 
        trx_sysf_t*     sys_header,     /* in: trx sys file copy */
176
 
        ulint           i,              /* in: slot index == rseg id */
177
 
        ulint           space,          /* in: space id */
178
 
        mtr_t*          mtr);           /* in: mtr */
179
 
/*********************************************************************
180
 
Sets the page number of the nth rollback segment slot in the trx system
181
 
file copy. */
182
 
UNIV_INLINE
183
 
void
184
 
trx_sysf_rseg_set_page_no(
185
 
/*======================*/
186
 
        trx_sysf_t*     sys_header,     /* in: trx sys file copy */
187
 
        ulint           i,              /* in: slot index == rseg id */
188
 
        ulint           page_no,        /* in: page number, FIL_NULL if
189
 
                                        the slot is reset to unused */
190
 
        mtr_t*          mtr);           /* in: mtr */
191
 
/*********************************************************************
192
 
Allocates a new transaction id. */
193
 
UNIV_INLINE
194
 
dulint
195
 
trx_sys_get_new_trx_id(void);
196
 
/*========================*/
197
 
                        /* out: new, allocated trx id */
198
 
/*********************************************************************
199
 
Allocates a new transaction number. */
200
 
UNIV_INLINE
201
 
dulint
202
 
trx_sys_get_new_trx_no(void);
203
 
/*========================*/
204
 
                        /* out: new, allocated trx number */
205
 
/*********************************************************************
206
 
Writes a trx id to an index page. In case that the id size changes in
207
 
some future version, this function should be used instead of
208
 
mach_write_... */
209
 
UNIV_INLINE
210
 
void
211
 
trx_write_trx_id(
212
 
/*=============*/
213
 
        byte*   ptr,    /* in: pointer to memory where written */
214
 
        dulint  id);    /* in: id */
215
 
/*********************************************************************
216
 
Reads a trx id from an index page. In case that the id size changes in
217
 
some future version, this function should be used instead of
218
 
mach_read_... */
219
 
UNIV_INLINE
220
 
dulint
221
 
trx_read_trx_id(
222
 
/*============*/
223
 
                        /* out: id */
224
 
        byte*   ptr);   /* in: pointer to memory from where to read */
225
 
/********************************************************************
226
 
Looks for the trx handle with the given id in trx_list. */
227
 
UNIV_INLINE
228
 
trx_t*
229
 
trx_get_on_id(
230
 
/*==========*/
231
 
                        /* out: the trx handle or NULL if not found */
232
 
        dulint  trx_id);        /* in: trx id to search for */
233
 
/********************************************************************
234
 
Returns the minumum trx id in trx list. This is the smallest id for which
235
 
the trx can possibly be active. (But, you must look at the trx->conc_state to
236
 
find out if the minimum trx id transaction itself is active, or already
237
 
committed.) */
238
 
UNIV_INLINE
239
 
dulint
240
 
trx_list_get_min_trx_id(void);
241
 
/*=========================*/
242
 
                        /* out: the minimum trx id, or trx_sys->max_trx_id
243
 
                        if the trx list is empty */
244
 
/********************************************************************
245
 
Checks if a transaction with the given id is active. */
246
 
UNIV_INLINE
247
 
ibool
248
 
trx_is_active(
249
 
/*==========*/
250
 
                        /* out: TRUE if active */
251
 
        dulint  trx_id);/* in: trx id of the transaction */
252
 
/********************************************************************
253
 
Checks that trx is in the trx list. */
254
 
 
255
 
ibool
256
 
trx_in_trx_list(
257
 
/*============*/
258
 
                        /* out: TRUE if is in */
259
 
        trx_t*  in_trx);/* in: trx */
260
 
/*********************************************************************
261
 
Updates the offset information about the end of the MySQL binlog entry
262
 
which corresponds to the transaction just being committed. In a MySQL
263
 
replication slave updates the latest master binlog position up to which
264
 
replication has proceeded. */
265
 
 
266
 
void
267
 
trx_sys_update_mysql_binlog_offset(
268
 
/*===============================*/
269
 
        const char*     file_name,/* in: MySQL log file name */
270
 
        ib_longlong     offset, /* in: position in that log file */
271
 
        ulint           field,  /* in: offset of the MySQL log info field in
272
 
                                the trx sys header */
273
 
        mtr_t*          mtr);   /* in: mtr */
274
 
/*********************************************************************
275
 
Prints to stderr the MySQL binlog offset info in the trx system header if
276
 
the magic number shows it valid. */
277
 
 
278
 
void
279
 
trx_sys_print_mysql_binlog_offset(void);
280
 
/*===================================*/
281
 
#ifdef UNIV_HOTBACKUP
282
 
/*********************************************************************
283
 
Prints to stderr the MySQL binlog info in the system header if the
284
 
magic number shows it valid. */
285
 
 
286
 
void
287
 
trx_sys_print_mysql_binlog_offset_from_page(
288
 
/*========================================*/
289
 
        byte*   page);  /* in: buffer containing the trx system header page,
290
 
                        i.e., page number TRX_SYS_PAGE_NO in the tablespace */
291
 
#endif /* UNIV_HOTBACKUP */
292
 
/*********************************************************************
293
 
Prints to stderr the MySQL master log offset info in the trx system header if
294
 
the magic number shows it valid. */
295
 
 
296
 
void
297
 
trx_sys_print_mysql_master_log_pos(void);
298
 
/*====================================*/
299
 
 
300
 
/* The automatically created system rollback segment has this id */
301
 
#define TRX_SYS_SYSTEM_RSEG_ID  0
302
 
 
303
 
/* Space id and page no where the trx system file copy resides */
304
 
#define TRX_SYS_SPACE   0       /* the SYSTEM tablespace */
305
 
#define TRX_SYS_PAGE_NO FSP_TRX_SYS_PAGE_NO
306
 
 
307
 
/* The offset of the transaction system header on the page */
308
 
#define TRX_SYS         FSEG_PAGE_DATA
309
 
 
310
 
/* Transaction system header */
311
 
/*-------------------------------------------------------------*/
312
 
#define TRX_SYS_TRX_ID_STORE    0       /* the maximum trx id or trx number
313
 
                                        modulo TRX_SYS_TRX_ID_UPDATE_MARGIN
314
 
                                        written to a file page by any
315
 
                                        transaction; the assignment of
316
 
                                        transaction ids continues from this
317
 
                                        number rounded up by .._MARGIN plus
318
 
                                        .._MARGIN when the database is
319
 
                                        started */
320
 
#define TRX_SYS_FSEG_HEADER     8       /* segment header for the tablespace
321
 
                                        segment the trx system is created
322
 
                                        into */
323
 
#define TRX_SYS_RSEGS           (8 + FSEG_HEADER_SIZE)
324
 
                                        /* the start of the array of rollback
325
 
                                        segment specification slots */
326
 
/*-------------------------------------------------------------*/
327
 
 
328
 
/* Max number of rollback segments: the number of segment specification slots
329
 
in the transaction system array; rollback segment id must fit in one byte,
330
 
therefore 256; each slot is currently 8 bytes in size */
331
 
#define TRX_SYS_N_RSEGS         256
332
 
 
333
 
#define TRX_SYS_DRIZZLE_LOG_NAME_LEN    512
334
 
#define TRX_SYS_DRIZZLE_LOG_MAGIC_N     873422344
335
 
 
336
 
/* The offset of the MySQL replication info in the trx system header;
337
 
this contains the same fields as TRX_SYS_DRIZZLE_LOG_INFO below */
338
 
#define TRX_SYS_DRIZZLE_MASTER_LOG_INFO (UNIV_PAGE_SIZE - 2000)
339
 
 
340
 
/* The offset of the MySQL binlog offset info in the trx system header */
341
 
#define TRX_SYS_DRIZZLE_LOG_INFO                (UNIV_PAGE_SIZE - 1000)
342
 
#define TRX_SYS_DRIZZLE_LOG_MAGIC_N_FLD 0       /* magic number which shows
343
 
                                                if we have valid data in the
344
 
                                                MySQL binlog info; the value
345
 
                                                is ..._MAGIC_N if yes */
346
 
#define TRX_SYS_DRIZZLE_LOG_OFFSET_HIGH 4       /* high 4 bytes of the offset
347
 
                                                within that file */
348
 
#define TRX_SYS_DRIZZLE_LOG_OFFSET_LOW  8       /* low 4 bytes of the offset
349
 
                                                within that file */
350
 
#define TRX_SYS_DRIZZLE_LOG_NAME                12      /* MySQL log file name */
351
 
 
352
 
/* The offset of the doublewrite buffer header on the trx system header page */
353
 
#define TRX_SYS_DOUBLEWRITE             (UNIV_PAGE_SIZE - 200)
354
 
/*-------------------------------------------------------------*/
355
 
#define TRX_SYS_DOUBLEWRITE_FSEG        0       /* fseg header of the fseg
356
 
                                                containing the doublewrite
357
 
                                                buffer */
358
 
#define TRX_SYS_DOUBLEWRITE_MAGIC       FSEG_HEADER_SIZE
359
 
                                                /* 4-byte magic number which
360
 
                                                shows if we already have
361
 
                                                created the doublewrite
362
 
                                                buffer */
363
 
#define TRX_SYS_DOUBLEWRITE_BLOCK1      (4 + FSEG_HEADER_SIZE)
364
 
                                                /* page number of the
365
 
                                                first page in the first
366
 
                                                sequence of 64
367
 
                                                (= FSP_EXTENT_SIZE) consecutive
368
 
                                                pages in the doublewrite
369
 
                                                buffer */
370
 
#define TRX_SYS_DOUBLEWRITE_BLOCK2      (8 + FSEG_HEADER_SIZE)
371
 
                                                /* page number of the
372
 
                                                first page in the second
373
 
                                                sequence of 64 consecutive
374
 
                                                pages in the doublewrite
375
 
                                                buffer */
376
 
#define TRX_SYS_DOUBLEWRITE_REPEAT      12      /* we repeat the above 3
377
 
                                                numbers so that if the trx
378
 
                                                sys header is half-written
379
 
                                                to disk, we still may be able
380
 
                                                to recover the information */
381
 
#define TRX_SYS_DOUBLEWRITE_SPACE_ID_STORED (24 + FSEG_HEADER_SIZE)
382
 
                                                /* If this is not yet set to
383
 
                                                .._N, we must reset the
384
 
                                                doublewrite buffer, because
385
 
                                                starting from 4.1.x the space
386
 
                                                id of a data page is stored to
387
 
                                        FIL_PAGE_ARCH_LOG_NO_OR_SPACE_NO */
388
 
/*-------------------------------------------------------------*/
389
 
#define TRX_SYS_DOUBLEWRITE_MAGIC_N     536853855
390
 
#define TRX_SYS_DOUBLEWRITE_SPACE_ID_STORED_N 1783657386
391
 
 
392
 
 
393
 
#define TRX_SYS_DOUBLEWRITE_BLOCK_SIZE  FSP_EXTENT_SIZE
394
 
 
395
 
/* Doublewrite control struct */
396
 
struct trx_doublewrite_struct{
397
 
        mutex_t mutex;          /* mutex protecting the first_free field and
398
 
                                write_buf */
399
 
        ulint   block1;         /* the page number of the first
400
 
                                doublewrite block (64 pages) */
401
 
        ulint   block2;         /* page number of the second block */
402
 
        ulint   first_free;     /* first free position in write_buf measured
403
 
                                in units of UNIV_PAGE_SIZE */
404
 
        byte*   write_buf;      /* write buffer used in writing to the
405
 
                                doublewrite buffer, aligned to an
406
 
                                address divisible by UNIV_PAGE_SIZE
407
 
                                (which is required by Windows aio) */
408
 
        byte*   write_buf_unaligned; /* pointer to write_buf, but unaligned */
409
 
        buf_block_t**
410
 
                buf_block_arr;  /* array to store pointers to the buffer
411
 
                                blocks which have been cached to write_buf */
412
 
};
413
 
 
414
 
/* The transaction system central memory data structure; protected by the
415
 
kernel mutex */
416
 
struct trx_sys_struct{
417
 
        dulint          max_trx_id;     /* The smallest number not yet
418
 
                                        assigned as a transaction id or
419
 
                                        transaction number */
420
 
        UT_LIST_BASE_NODE_T(trx_t) trx_list;
421
 
                                        /* List of active and committed in
422
 
                                        memory transactions, sorted on trx id,
423
 
                                        biggest first */
424
 
        UT_LIST_BASE_NODE_T(trx_t) mysql_trx_list;
425
 
                                        /* List of transactions created
426
 
                                        for MySQL */
427
 
        UT_LIST_BASE_NODE_T(trx_rseg_t) rseg_list;
428
 
                                        /* List of rollback segment objects */
429
 
        trx_rseg_t*     latest_rseg;    /* Latest rollback segment in the
430
 
                                        round-robin assignment of rollback
431
 
                                        segments to transactions */
432
 
        trx_rseg_t*     rseg_array[TRX_SYS_N_RSEGS];
433
 
                                        /* Pointer array to rollback segments;
434
 
                                        NULL if slot not in use */
435
 
        ulint           rseg_history_len;/* Length of the TRX_RSEG_HISTORY
436
 
                                        list (update undo logs for committed
437
 
                                        transactions), protected by
438
 
                                        rseg->mutex */
439
 
        UT_LIST_BASE_NODE_T(read_view_t) view_list;
440
 
                                        /* List of read views sorted on trx no,
441
 
                                        biggest first */
442
 
};
443
 
 
444
 
/* When a trx id which is zero modulo this number (which must be a power of
445
 
two) is assigned, the field TRX_SYS_TRX_ID_STORE on the transaction system
446
 
page is updated */
447
 
#define TRX_SYS_TRX_ID_WRITE_MARGIN     256
448
 
 
449
 
#ifndef UNIV_NONINL
450
 
#include "trx0sys.ic"
451
 
#endif
452
 
 
453
 
#endif