← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/fut/fut0lst.c

  • Committer: Brian Aker
  • Date: 2008-09-04 19:31:00 UTC
  • Revision ID: brian@tangent.org-20080904193100-l849hgghfy4urj43
Changing default character set from this point on.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/fut/fut0lst.c
13
13
#endif
14
14
 
15
15
#include "buf0buf.h"
16
 
#include "page0page.h"
 
16
 
17
17
 
18
18
/************************************************************************
19
19
Adds a node to an empty list. */
32
32
 
33
33
        ut_ad(mtr && base && node);
34
34
        ut_ad(base != node);
35
 
        ut_ad(mtr_memo_contains_page(mtr, base, MTR_MEMO_PAGE_X_FIX));
36
 
        ut_ad(mtr_memo_contains_page(mtr, node, MTR_MEMO_PAGE_X_FIX));
 
35
        ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
 
36
                                MTR_MEMO_PAGE_X_FIX));
 
37
        ut_ad(mtr_memo_contains(mtr, buf_block_align(node),
 
38
                                MTR_MEMO_PAGE_X_FIX));
37
39
        len = flst_get_len(base, mtr);
38
40
        ut_a(len == 0);
39
41
 
53
55
 
54
56
/************************************************************************
55
57
Adds a node as the last node in a list. */
56
 
UNIV_INTERN
 
58
 
57
59
void
58
60
flst_add_last(
59
61
/*==========*/
69
71
 
70
72
        ut_ad(mtr && base && node);
71
73
        ut_ad(base != node);
72
 
        ut_ad(mtr_memo_contains_page(mtr, base, MTR_MEMO_PAGE_X_FIX));
73
 
        ut_ad(mtr_memo_contains_page(mtr, node, MTR_MEMO_PAGE_X_FIX));
 
74
        ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
 
75
                                MTR_MEMO_PAGE_X_FIX));
 
76
        ut_ad(mtr_memo_contains(mtr, buf_block_align(node),
 
77
                                MTR_MEMO_PAGE_X_FIX));
74
78
        len = flst_get_len(base, mtr);
75
79
        last_addr = flst_get_last(base, mtr);
76
80
 
79
83
        /* If the list is not empty, call flst_insert_after */
80
84
        if (len != 0) {
81
85
                if (last_addr.page == node_addr.page) {
82
 
                        last_node = page_align(node) + last_addr.boffset;
 
86
                        last_node = buf_frame_align(node) + last_addr.boffset;
83
87
                } else {
84
 
                        ulint   zip_size = fil_space_get_zip_size(space);
85
 
 
86
 
                        last_node = fut_get_ptr(space, zip_size, last_addr,
87
 
                                                RW_X_LATCH, mtr);
 
88
                        last_node = fut_get_ptr(space, last_addr, RW_X_LATCH,
 
89
                                                mtr);
88
90
                }
89
91
 
90
92
                flst_insert_after(base, last_node, node, mtr);
96
98
 
97
99
/************************************************************************
98
100
Adds a node as the first node in a list. */
99
 
UNIV_INTERN
 
101
 
100
102
void
101
103
flst_add_first(
102
104
/*===========*/
112
114
 
113
115
        ut_ad(mtr && base && node);
114
116
        ut_ad(base != node);
115
 
        ut_ad(mtr_memo_contains_page(mtr, base, MTR_MEMO_PAGE_X_FIX));
116
 
        ut_ad(mtr_memo_contains_page(mtr, node, MTR_MEMO_PAGE_X_FIX));
 
117
        ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
 
118
                                MTR_MEMO_PAGE_X_FIX));
 
119
        ut_ad(mtr_memo_contains(mtr, buf_block_align(node),
 
120
                                MTR_MEMO_PAGE_X_FIX));
117
121
        len = flst_get_len(base, mtr);
118
122
        first_addr = flst_get_first(base, mtr);
119
123
 
122
126
        /* If the list is not empty, call flst_insert_before */
123
127
        if (len != 0) {
124
128
                if (first_addr.page == node_addr.page) {
125
 
                        first_node = page_align(node) + first_addr.boffset;
 
129
                        first_node = buf_frame_align(node)
 
130
                                + first_addr.boffset;
126
131
                } else {
127
 
                        ulint   zip_size = fil_space_get_zip_size(space);
128
 
 
129
 
                        first_node = fut_get_ptr(space, zip_size, first_addr,
 
132
                        first_node = fut_get_ptr(space, first_addr,
130
133
                                                 RW_X_LATCH, mtr);
131
134
                }
132
135
 
139
142
 
140
143
/************************************************************************
141
144
Inserts a node after another in a list. */
142
 
UNIV_INTERN
 
145
 
143
146
void
144
147
flst_insert_after(
145
148
/*==============*/
159
162
        ut_ad(base != node1);
160
163
        ut_ad(base != node2);
161
164
        ut_ad(node2 != node1);
162
 
        ut_ad(mtr_memo_contains_page(mtr, base, MTR_MEMO_PAGE_X_FIX));
163
 
        ut_ad(mtr_memo_contains_page(mtr, node1, MTR_MEMO_PAGE_X_FIX));
164
 
        ut_ad(mtr_memo_contains_page(mtr, node2, MTR_MEMO_PAGE_X_FIX));
 
165
        ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
 
166
                                MTR_MEMO_PAGE_X_FIX));
 
167
        ut_ad(mtr_memo_contains(mtr, buf_block_align(node1),
 
168
                                MTR_MEMO_PAGE_X_FIX));
 
169
        ut_ad(mtr_memo_contains(mtr, buf_block_align(node2),
 
170
                                MTR_MEMO_PAGE_X_FIX));
165
171
 
166
172
        buf_ptr_get_fsp_addr(node1, &space, &node1_addr);
167
173
        buf_ptr_get_fsp_addr(node2, &space, &node2_addr);
174
180
 
175
181
        if (!fil_addr_is_null(node3_addr)) {
176
182
                /* Update prev field of node3 */
177
 
                ulint   zip_size = fil_space_get_zip_size(space);
178
 
 
179
 
                node3 = fut_get_ptr(space, zip_size,
180
 
                                    node3_addr, RW_X_LATCH, mtr);
 
183
                node3 = fut_get_ptr(space, node3_addr, RW_X_LATCH, mtr);
181
184
                flst_write_addr(node3 + FLST_PREV, node2_addr, mtr);
182
185
        } else {
183
186
                /* node1 was last in list: update last field in base */
194
197
 
195
198
/************************************************************************
196
199
Inserts a node before another in a list. */
197
 
UNIV_INTERN
 
200
 
198
201
void
199
202
flst_insert_before(
200
203
/*===============*/
214
217
        ut_ad(base != node2);
215
218
        ut_ad(base != node3);
216
219
        ut_ad(node2 != node3);
217
 
        ut_ad(mtr_memo_contains_page(mtr, base, MTR_MEMO_PAGE_X_FIX));
218
 
        ut_ad(mtr_memo_contains_page(mtr, node2, MTR_MEMO_PAGE_X_FIX));
219
 
        ut_ad(mtr_memo_contains_page(mtr, node3, MTR_MEMO_PAGE_X_FIX));
 
220
        ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
 
221
                                MTR_MEMO_PAGE_X_FIX));
 
222
        ut_ad(mtr_memo_contains(mtr, buf_block_align(node2),
 
223
                                MTR_MEMO_PAGE_X_FIX));
 
224
        ut_ad(mtr_memo_contains(mtr, buf_block_align(node3),
 
225
                                MTR_MEMO_PAGE_X_FIX));
220
226
 
221
227
        buf_ptr_get_fsp_addr(node2, &space, &node2_addr);
222
228
        buf_ptr_get_fsp_addr(node3, &space, &node3_addr);
228
234
        flst_write_addr(node2 + FLST_NEXT, node3_addr, mtr);
229
235
 
230
236
        if (!fil_addr_is_null(node1_addr)) {
231
 
                ulint   zip_size = fil_space_get_zip_size(space);
232
237
                /* Update next field of node1 */
233
 
                node1 = fut_get_ptr(space, zip_size, node1_addr,
234
 
                                    RW_X_LATCH, mtr);
 
238
                node1 = fut_get_ptr(space, node1_addr, RW_X_LATCH, mtr);
235
239
                flst_write_addr(node1 + FLST_NEXT, node2_addr, mtr);
236
240
        } else {
237
241
                /* node3 was first in list: update first field in base */
248
252
 
249
253
/************************************************************************
250
254
Removes a node. */
251
 
UNIV_INTERN
 
255
 
252
256
void
253
257
flst_remove(
254
258
/*========*/
257
261
        mtr_t*                  mtr)    /* in: mini-transaction handle */
258
262
{
259
263
        ulint           space;
260
 
        ulint           zip_size;
261
264
        flst_node_t*    node1;
262
265
        fil_addr_t      node1_addr;
263
266
        fil_addr_t      node2_addr;
266
269
        ulint           len;
267
270
 
268
271
        ut_ad(mtr && node2 && base);
269
 
        ut_ad(mtr_memo_contains_page(mtr, base, MTR_MEMO_PAGE_X_FIX));
270
 
        ut_ad(mtr_memo_contains_page(mtr, node2, MTR_MEMO_PAGE_X_FIX));
 
272
        ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
 
273
                                MTR_MEMO_PAGE_X_FIX));
 
274
        ut_ad(mtr_memo_contains(mtr, buf_block_align(node2),
 
275
                                MTR_MEMO_PAGE_X_FIX));
271
276
 
272
277
        buf_ptr_get_fsp_addr(node2, &space, &node2_addr);
273
 
        zip_size = fil_space_get_zip_size(space);
274
278
 
275
279
        node1_addr = flst_get_prev_addr(node2, mtr);
276
280
        node3_addr = flst_get_next_addr(node2, mtr);
281
285
 
282
286
                if (node1_addr.page == node2_addr.page) {
283
287
 
284
 
                        node1 = page_align(node2) + node1_addr.boffset;
 
288
                        node1 = buf_frame_align(node2) + node1_addr.boffset;
285
289
                } else {
286
 
                        node1 = fut_get_ptr(space, zip_size,
287
 
                                            node1_addr, RW_X_LATCH, mtr);
 
290
                        node1 = fut_get_ptr(space, node1_addr, RW_X_LATCH,
 
291
                                            mtr);
288
292
                }
289
293
 
290
294
                ut_ad(node1 != node2);
300
304
 
301
305
                if (node3_addr.page == node2_addr.page) {
302
306
 
303
 
                        node3 = page_align(node2) + node3_addr.boffset;
 
307
                        node3 = buf_frame_align(node2) + node3_addr.boffset;
304
308
                } else {
305
 
                        node3 = fut_get_ptr(space, zip_size,
306
 
                                            node3_addr, RW_X_LATCH, mtr);
 
309
                        node3 = fut_get_ptr(space, node3_addr, RW_X_LATCH,
 
310
                                            mtr);
307
311
                }
308
312
 
309
313
                ut_ad(node2 != node3);
325
329
Cuts off the tail of the list, including the node given. The number of
326
330
nodes which will be removed must be provided by the caller, as this function
327
331
does not measure the length of the tail. */
328
 
UNIV_INTERN
 
332
 
329
333
void
330
334
flst_cut_end(
331
335
/*=========*/
342
346
        ulint           len;
343
347
 
344
348
        ut_ad(mtr && node2 && base);
345
 
        ut_ad(mtr_memo_contains_page(mtr, base, MTR_MEMO_PAGE_X_FIX));
346
 
        ut_ad(mtr_memo_contains_page(mtr, node2, MTR_MEMO_PAGE_X_FIX));
 
349
        ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
 
350
                                MTR_MEMO_PAGE_X_FIX));
 
351
        ut_ad(mtr_memo_contains(mtr, buf_block_align(node2),
 
352
                                MTR_MEMO_PAGE_X_FIX));
347
353
        ut_ad(n_nodes > 0);
348
354
 
349
355
        buf_ptr_get_fsp_addr(node2, &space, &node2_addr);
356
362
 
357
363
                if (node1_addr.page == node2_addr.page) {
358
364
 
359
 
                        node1 = page_align(node2) + node1_addr.boffset;
 
365
                        node1 = buf_frame_align(node2) + node1_addr.boffset;
360
366
                } else {
361
 
                        node1 = fut_get_ptr(space,
362
 
                                            fil_space_get_zip_size(space),
363
 
                                            node1_addr, RW_X_LATCH, mtr);
 
367
                        node1 = fut_get_ptr(space, node1_addr, RW_X_LATCH,
 
368
                                            mtr);
364
369
                }
365
370
 
366
371
                flst_write_addr(node1 + FLST_NEXT, fil_addr_null, mtr);
382
387
Cuts off the tail of the list, not including the given node. The number of
383
388
nodes which will be removed must be provided by the caller, as this function
384
389
does not measure the length of the tail. */
385
 
UNIV_INTERN
 
390
 
386
391
void
387
392
flst_truncate_end(
388
393
/*==============*/
396
401
        ulint           space;
397
402
 
398
403
        ut_ad(mtr && node2 && base);
399
 
        ut_ad(mtr_memo_contains_page(mtr, base, MTR_MEMO_PAGE_X_FIX));
400
 
        ut_ad(mtr_memo_contains_page(mtr, node2, MTR_MEMO_PAGE_X_FIX));
 
404
        ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
 
405
                                MTR_MEMO_PAGE_X_FIX));
 
406
        ut_ad(mtr_memo_contains(mtr, buf_block_align(node2),
 
407
                                MTR_MEMO_PAGE_X_FIX));
401
408
        if (n_nodes == 0) {
402
409
 
403
410
                ut_ad(fil_addr_is_null(flst_get_next_addr(node2, mtr)));
421
428
 
422
429
/************************************************************************
423
430
Validates a file-based list. */
424
 
UNIV_INTERN
 
431
 
425
432
ibool
426
433
flst_validate(
427
434
/*==========*/
428
435
                                        /* out: TRUE if ok */
429
 
        const flst_base_node_t* base,   /* in: pointer to base node of list */
 
436
        flst_base_node_t*       base,   /* in: pointer to base node of list */
430
437
        mtr_t*                  mtr1)   /* in: mtr */
431
438
{
432
 
        ulint                   space;
433
 
        ulint                   zip_size;
434
 
        const flst_node_t*      node;
435
 
        fil_addr_t              node_addr;
436
 
        fil_addr_t              base_addr;
437
 
        ulint                   len;
438
 
        ulint                   i;
439
 
        mtr_t                   mtr2;
 
439
        ulint           space;
 
440
        flst_node_t*    node;
 
441
        fil_addr_t      node_addr;
 
442
        fil_addr_t      base_addr;
 
443
        ulint           len;
 
444
        ulint           i;
 
445
        mtr_t           mtr2;
440
446
 
441
447
        ut_ad(base);
442
 
        ut_ad(mtr_memo_contains_page(mtr1, base, MTR_MEMO_PAGE_X_FIX));
 
448
        ut_ad(mtr_memo_contains(mtr1, buf_block_align(base),
 
449
                                MTR_MEMO_PAGE_X_FIX));
443
450
 
444
451
        /* We use two mini-transaction handles: the first is used to
445
452
        lock the base node, and prevent other threads from modifying the
450
457
 
451
458
        /* Find out the space id */
452
459
        buf_ptr_get_fsp_addr(base, &space, &base_addr);
453
 
        zip_size = fil_space_get_zip_size(space);
454
460
 
455
461
        len = flst_get_len(base, mtr1);
456
462
        node_addr = flst_get_first(base, mtr1);
458
464
        for (i = 0; i < len; i++) {
459
465
                mtr_start(&mtr2);
460
466
 
461
 
                node = fut_get_ptr(space, zip_size,
462
 
                                   node_addr, RW_X_LATCH, &mtr2);
 
467
                node = fut_get_ptr(space, node_addr, RW_X_LATCH, &mtr2);
463
468
                node_addr = flst_get_next_addr(node, &mtr2);
464
469
 
465
470
                mtr_commit(&mtr2); /* Commit mtr2 each round to prevent buffer
473
478
        for (i = 0; i < len; i++) {
474
479
                mtr_start(&mtr2);
475
480
 
476
 
                node = fut_get_ptr(space, zip_size,
477
 
                                   node_addr, RW_X_LATCH, &mtr2);
 
481
                node = fut_get_ptr(space, node_addr, RW_X_LATCH, &mtr2);
478
482
                node_addr = flst_get_prev_addr(node, &mtr2);
479
483
 
480
484
                mtr_commit(&mtr2); /* Commit mtr2 each round to prevent buffer
488
492
 
489
493
/************************************************************************
490
494
Prints info of a file-based list. */
491
 
UNIV_INTERN
 
495
 
492
496
void
493
497
flst_print(
494
498
/*=======*/
495
 
        const flst_base_node_t* base,   /* in: pointer to base node of list */
 
499
        flst_base_node_t*       base,   /* in: pointer to base node of list */
496
500
        mtr_t*                  mtr)    /* in: mtr */
497
501
{
498
 
        const buf_frame_t*      frame;
499
 
        ulint                   len;
 
502
        buf_frame_t*    frame;
 
503
        ulint           len;
500
504
 
501
505
        ut_ad(base && mtr);
502
 
        ut_ad(mtr_memo_contains_page(mtr, base, MTR_MEMO_PAGE_X_FIX));
503
 
        frame = page_align((byte*) base);
 
506
        ut_ad(mtr_memo_contains(mtr, buf_block_align(base),
 
507
                                MTR_MEMO_PAGE_X_FIX));
 
508
        frame = buf_frame_align(base);
504
509
 
505
510
        len = flst_get_len(base, mtr);
506
511
 
507
512
        fprintf(stderr,
508
513
                "FILE-BASED LIST:\n"
509
514
                "Base node in space %lu page %lu byte offset %lu; len %lu\n",
510
 
                (ulong) page_get_space_id(frame),
511
 
                (ulong) page_get_page_no(frame),
512
 
                (ulong) page_offset(base), (ulong) len);
 
515
                (ulong) buf_frame_get_space_id(frame),
 
516
                (ulong) buf_frame_get_page_no(frame),
 
517
                (ulong) (base - frame), (ulong) len);
513
518
}