← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/page/page0page.c

  • Committer: Brian Aker
  • Date: 2009-12-29 01:38:38 UTC
  • mfrom: (1251.1.1 drizzle)
  • Revision ID: brian@gaz-20091229013838-03kb2z5xbqw03ddt
Merge of Diego fix.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/page/page0page.c
 
1
/*****************************************************************************
 
2
 
 
3
Copyright (c) 1994, 2009, Innobase Oy. All Rights Reserved.
 
4
 
 
5
This program is free software; you can redistribute it and/or modify it under
 
6
the terms of the GNU General Public License as published by the Free Software
 
7
Foundation; version 2 of the License.
 
8
 
 
9
This program is distributed in the hope that it will be useful, but WITHOUT
 
10
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
12
 
 
13
You should have received a copy of the GNU General Public License along with
 
14
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 
15
Place, Suite 330, Boston, MA 02111-1307 USA
 
16
 
 
17
*****************************************************************************/
 
18
 
 
19
/**************************************************//**
 
20
@file page/page0page.c
 
21
Index page routines
 
22
 
 
23
Created 2/2/1994 Heikki Tuuri
 
24
*******************************************************/
 
25
 
 
26
#include "page0page.h"
 
27
#ifdef UNIV_NONINL
 
28
#include "page0page.ic"
 
29
#endif
 
30
 
 
31
#include "page0cur.h"
 
32
#include "page0zip.h"
 
33
#include "buf0buf.h"
 
34
#include "btr0btr.h"
 
35
#ifndef UNIV_HOTBACKUP
 
36
# include "srv0srv.h"
 
37
# include "lock0lock.h"
 
38
# include "fut0lst.h"
 
39
# include "btr0sea.h"
 
40
#endif /* !UNIV_HOTBACKUP */
 
41
 
 
42
/*                      THE INDEX PAGE
 
43
                        ==============
 
44
 
 
45
The index page consists of a page header which contains the page's
 
46
id and other information. On top of it are the the index records
 
47
in a heap linked into a one way linear list according to alphabetic order.
 
48
 
 
49
Just below page end is an array of pointers which we call page directory,
 
50
to about every sixth record in the list. The pointers are placed in
 
51
the directory in the alphabetical order of the records pointed to,
 
52
enabling us to make binary search using the array. Each slot n:o I
 
53
in the directory points to a record, where a 4-bit field contains a count
 
54
of those records which are in the linear list between pointer I and
 
55
the pointer I - 1 in the directory, including the record
 
56
pointed to by pointer I and not including the record pointed to by I - 1.
 
57
We say that the record pointed to by slot I, or that slot I, owns
 
58
these records. The count is always kept in the range 4 to 8, with
 
59
the exception that it is 1 for the first slot, and 1--8 for the second slot.
 
60
 
 
61
An essentially binary search can be performed in the list of index
 
62
records, like we could do if we had pointer to every record in the
 
63
page directory. The data structure is, however, more efficient when
 
64
we are doing inserts, because most inserts are just pushed on a heap.
 
65
Only every 8th insert requires block move in the directory pointer
 
66
table, which itself is quite small. A record is deleted from the page
 
67
by just taking it off the linear list and updating the number of owned
 
68
records-field of the record which owns it, and updating the page directory,
 
69
if necessary. A special case is the one when the record owns itself.
 
70
Because the overhead of inserts is so small, we may also increase the
 
71
page size from the projected default of 8 kB to 64 kB without too
 
72
much loss of efficiency in inserts. Bigger page becomes actual
 
73
when the disk transfer rate compared to seek and latency time rises.
 
74
On the present system, the page size is set so that the page transfer
 
75
time (3 ms) is 20 % of the disk random access time (15 ms).
 
76
 
 
77
When the page is split, merged, or becomes full but contains deleted
 
78
records, we have to reorganize the page.
 
79
 
 
80
Assuming a page size of 8 kB, a typical index page of a secondary
 
81
index contains 300 index entries, and the size of the page directory
 
82
is 50 x 4 bytes = 200 bytes. */
 
83
 
 
84
/***************************************************************//**
 
85
Looks for the directory slot which owns the given record.
 
86
@return the directory slot number */
 
87
UNIV_INTERN
 
88
ulint
 
89
page_dir_find_owner_slot(
 
90
/*=====================*/
 
91
        const rec_t*    rec)    /*!< in: the physical record */
 
92
{
 
93
        const page_t*                   page;
 
94
        register uint16                 rec_offs_bytes;
 
95
        register const page_dir_slot_t* slot;
 
96
        register const page_dir_slot_t* first_slot;
 
97
        register const rec_t*           r = rec;
 
98
 
 
99
        ut_ad(page_rec_check(rec));
 
100
 
 
101
        page = page_align(rec);
 
102
        first_slot = page_dir_get_nth_slot(page, 0);
 
103
        slot = page_dir_get_nth_slot(page, page_dir_get_n_slots(page) - 1);
 
104
 
 
105
        if (page_is_comp(page)) {
 
106
                while (rec_get_n_owned_new(r) == 0) {
 
107
                        r = rec_get_next_ptr_const(r, TRUE);
 
108
                        ut_ad(r >= page + PAGE_NEW_SUPREMUM);
 
109
                        ut_ad(r < page + (UNIV_PAGE_SIZE - PAGE_DIR));
 
110
                }
 
111
        } else {
 
112
                while (rec_get_n_owned_old(r) == 0) {
 
113
                        r = rec_get_next_ptr_const(r, FALSE);
 
114
                        ut_ad(r >= page + PAGE_OLD_SUPREMUM);
 
115
                        ut_ad(r < page + (UNIV_PAGE_SIZE - PAGE_DIR));
 
116
                }
 
117
        }
 
118
 
 
119
        rec_offs_bytes = mach_encode_2(r - page);
 
120
 
 
121
        while (UNIV_LIKELY(*(uint16*) slot != rec_offs_bytes)) {
 
122
 
 
123
                if (UNIV_UNLIKELY(slot == first_slot)) {
 
124
                        fprintf(stderr,
 
125
                                "InnoDB: Probable data corruption on"
 
126
                                " page %lu\n"
 
127
                                "InnoDB: Original record ",
 
128
                                (ulong) page_get_page_no(page));
 
129
 
 
130
                        if (page_is_comp(page)) {
 
131
                                fputs("(compact record)", stderr);
 
132
                        } else {
 
133
                                rec_print_old(stderr, rec);
 
134
                        }
 
135
 
 
136
                        fputs("\n"
 
137
                              "InnoDB: on that page.\n"
 
138
                              "InnoDB: Cannot find the dir slot for record ",
 
139
                              stderr);
 
140
                        if (page_is_comp(page)) {
 
141
                                fputs("(compact record)", stderr);
 
142
                        } else {
 
143
                                rec_print_old(stderr, page
 
144
                                              + mach_decode_2(rec_offs_bytes));
 
145
                        }
 
146
                        fputs("\n"
 
147
                              "InnoDB: on that page!\n", stderr);
 
148
 
 
149
                        buf_page_print(page, 0);
 
150
 
 
151
                        ut_error;
 
152
                }
 
153
 
 
154
                slot += PAGE_DIR_SLOT_SIZE;
 
155
        }
 
156
 
 
157
        return(((ulint) (first_slot - slot)) / PAGE_DIR_SLOT_SIZE);
 
158
}
 
159
 
 
160
/**************************************************************//**
 
161
Used to check the consistency of a directory slot.
 
162
@return TRUE if succeed */
 
163
static
 
164
ibool
 
165
page_dir_slot_check(
 
166
/*================*/
 
167
        page_dir_slot_t*        slot)   /*!< in: slot */
 
168
{
 
169
        page_t* page;
 
170
        ulint   n_slots;
 
171
        ulint   n_owned;
 
172
 
 
173
        ut_a(slot);
 
174
 
 
175
        page = page_align(slot);
 
176
 
 
177
        n_slots = page_dir_get_n_slots(page);
 
178
 
 
179
        ut_a(slot <= page_dir_get_nth_slot(page, 0));
 
180
        ut_a(slot >= page_dir_get_nth_slot(page, n_slots - 1));
 
181
 
 
182
        ut_a(page_rec_check(page_dir_slot_get_rec(slot)));
 
183
 
 
184
        if (page_is_comp(page)) {
 
185
                n_owned = rec_get_n_owned_new(page_dir_slot_get_rec(slot));
 
186
        } else {
 
187
                n_owned = rec_get_n_owned_old(page_dir_slot_get_rec(slot));
 
188
        }
 
189
 
 
190
        if (slot == page_dir_get_nth_slot(page, 0)) {
 
191
                ut_a(n_owned == 1);
 
192
        } else if (slot == page_dir_get_nth_slot(page, n_slots - 1)) {
 
193
                ut_a(n_owned >= 1);
 
194
                ut_a(n_owned <= PAGE_DIR_SLOT_MAX_N_OWNED);
 
195
        } else {
 
196
                ut_a(n_owned >= PAGE_DIR_SLOT_MIN_N_OWNED);
 
197
                ut_a(n_owned <= PAGE_DIR_SLOT_MAX_N_OWNED);
 
198
        }
 
199
 
 
200
        return(TRUE);
 
201
}
 
202
 
 
203
/*************************************************************//**
 
204
Sets the max trx id field value. */
 
205
UNIV_INTERN
 
206
void
 
207
page_set_max_trx_id(
 
208
/*================*/
 
209
        buf_block_t*    block,  /*!< in/out: page */
 
210
        page_zip_des_t* page_zip,/*!< in/out: compressed page, or NULL */
 
211
        trx_id_t        trx_id, /*!< in: transaction id */
 
212
        mtr_t*          mtr)    /*!< in/out: mini-transaction, or NULL */
 
213
{
 
214
        page_t*         page            = buf_block_get_frame(block);
 
215
#ifndef UNIV_HOTBACKUP
 
216
        const ibool     is_hashed       = block->is_hashed;
 
217
 
 
218
        if (is_hashed) {
 
219
                rw_lock_x_lock(&btr_search_latch);
 
220
        }
 
221
 
 
222
        ut_ad(!mtr || mtr_memo_contains(mtr, block, MTR_MEMO_PAGE_X_FIX));
 
223
#endif /* !UNIV_HOTBACKUP */
 
224
 
 
225
        /* It is not necessary to write this change to the redo log, as
 
226
        during a database recovery we assume that the max trx id of every
 
227
        page is the maximum trx id assigned before the crash. */
 
228
 
 
229
        if (UNIV_LIKELY_NULL(page_zip)) {
 
230
                mach_write_to_8(page + (PAGE_HEADER + PAGE_MAX_TRX_ID), trx_id);
 
231
                page_zip_write_header(page_zip,
 
232
                                      page + (PAGE_HEADER + PAGE_MAX_TRX_ID),
 
233
                                      8, mtr);
 
234
#ifndef UNIV_HOTBACKUP
 
235
        } else if (mtr) {
 
236
                mlog_write_dulint(page + (PAGE_HEADER + PAGE_MAX_TRX_ID),
 
237
                                  trx_id, mtr);
 
238
#endif /* !UNIV_HOTBACKUP */
 
239
        } else {
 
240
                mach_write_to_8(page + (PAGE_HEADER + PAGE_MAX_TRX_ID), trx_id);
 
241
        }
 
242
 
 
243
#ifndef UNIV_HOTBACKUP
 
244
        if (is_hashed) {
 
245
                rw_lock_x_unlock(&btr_search_latch);
 
246
        }
 
247
#endif /* !UNIV_HOTBACKUP */
 
248
}
 
249
 
 
250
/************************************************************//**
 
251
Allocates a block of memory from the heap of an index page.
 
252
@return pointer to start of allocated buffer, or NULL if allocation fails */
 
253
UNIV_INTERN
 
254
byte*
 
255
page_mem_alloc_heap(
 
256
/*================*/
 
257
        page_t*         page,   /*!< in/out: index page */
 
258
        page_zip_des_t* page_zip,/*!< in/out: compressed page with enough
 
259
                                space available for inserting the record,
 
260
                                or NULL */
 
261
        ulint           need,   /*!< in: total number of bytes needed */
 
262
        ulint*          heap_no)/*!< out: this contains the heap number
 
263
                                of the allocated record
 
264
                                if allocation succeeds */
 
265
{
 
266
        byte*   block;
 
267
        ulint   avl_space;
 
268
 
 
269
        ut_ad(page && heap_no);
 
270
 
 
271
        avl_space = page_get_max_insert_size(page, 1);
 
272
 
 
273
        if (avl_space >= need) {
 
274
                block = page_header_get_ptr(page, PAGE_HEAP_TOP);
 
275
 
 
276
                page_header_set_ptr(page, page_zip, PAGE_HEAP_TOP,
 
277
                                    block + need);
 
278
                *heap_no = page_dir_get_n_heap(page);
 
279
 
 
280
                page_dir_set_n_heap(page, page_zip, 1 + *heap_no);
 
281
 
 
282
                return(block);
 
283
        }
 
284
 
 
285
        return(NULL);
 
286
}
 
287
 
 
288
#ifndef UNIV_HOTBACKUP
 
289
/**********************************************************//**
 
290
Writes a log record of page creation. */
 
291
UNIV_INLINE
 
292
void
 
293
page_create_write_log(
 
294
/*==================*/
 
295
        buf_frame_t*    frame,  /*!< in: a buffer frame where the page is
 
296
                                created */
 
297
        mtr_t*          mtr,    /*!< in: mini-transaction handle */
 
298
        ibool           comp)   /*!< in: TRUE=compact page format */
 
299
{
 
300
        mlog_write_initial_log_record(frame, comp
 
301
                                      ? MLOG_COMP_PAGE_CREATE
 
302
                                      : MLOG_PAGE_CREATE, mtr);
 
303
}
 
304
#else /* !UNIV_HOTBACKUP */
 
305
# define page_create_write_log(frame,mtr,comp) ((void) 0)
 
306
#endif /* !UNIV_HOTBACKUP */
 
307
 
 
308
/***********************************************************//**
 
309
Parses a redo log record of creating a page.
 
310
@return end of log record or NULL */
 
311
UNIV_INTERN
 
312
byte*
 
313
page_parse_create(
 
314
/*==============*/
 
315
        byte*           ptr,    /*!< in: buffer */
 
316
        byte*           end_ptr __attribute__((unused)), /*!< in: buffer end */
 
317
        ulint           comp,   /*!< in: nonzero=compact page format */
 
318
        buf_block_t*    block,  /*!< in: block or NULL */
 
319
        mtr_t*          mtr)    /*!< in: mtr or NULL */
 
320
{
 
321
        ut_ad(ptr && end_ptr);
 
322
 
 
323
        /* The record is empty, except for the record initial part */
 
324
 
 
325
        if (block) {
 
326
                page_create(block, mtr, comp);
 
327
        }
 
328
 
 
329
        return(ptr);
 
330
}
 
331
 
 
332
/**********************************************************//**
 
333
The index page creation function.
 
334
@return pointer to the page */
 
335
static
 
336
page_t*
 
337
page_create_low(
 
338
/*============*/
 
339
        buf_block_t*    block,          /*!< in: a buffer block where the
 
340
                                        page is created */
 
341
        ulint           comp)           /*!< in: nonzero=compact page format */
 
342
{
 
343
        page_dir_slot_t* slot;
 
344
        mem_heap_t*     heap;
 
345
        dtuple_t*       tuple;
 
346
        dfield_t*       field;
 
347
        byte*           heap_top;
 
348
        rec_t*          infimum_rec;
 
349
        rec_t*          supremum_rec;
 
350
        page_t*         page;
 
351
        dict_index_t*   index;
 
352
        ulint*          offsets;
 
353
 
 
354
        ut_ad(block);
 
355
#if PAGE_BTR_IBUF_FREE_LIST + FLST_BASE_NODE_SIZE > PAGE_DATA
 
356
# error "PAGE_BTR_IBUF_FREE_LIST + FLST_BASE_NODE_SIZE > PAGE_DATA"
 
357
#endif
 
358
#if PAGE_BTR_IBUF_FREE_LIST_NODE + FLST_NODE_SIZE > PAGE_DATA
 
359
# error "PAGE_BTR_IBUF_FREE_LIST_NODE + FLST_NODE_SIZE > PAGE_DATA"
 
360
#endif
 
361
 
 
362
        /* The infimum and supremum records use a dummy index. */
 
363
        if (UNIV_LIKELY(comp)) {
 
364
                index = dict_ind_compact;
 
365
        } else {
 
366
                index = dict_ind_redundant;
 
367
        }
 
368
 
 
369
        /* 1. INCREMENT MODIFY CLOCK */
 
370
        buf_block_modify_clock_inc(block);
 
371
 
 
372
        page = buf_block_get_frame(block);
 
373
 
 
374
        fil_page_set_type(page, FIL_PAGE_INDEX);
 
375
 
 
376
        heap = mem_heap_create(200);
 
377
 
 
378
        /* 3. CREATE THE INFIMUM AND SUPREMUM RECORDS */
 
379
 
 
380
        /* Create first a data tuple for infimum record */
 
381
        tuple = dtuple_create(heap, 1);
 
382
        dtuple_set_info_bits(tuple, REC_STATUS_INFIMUM);
 
383
        field = dtuple_get_nth_field(tuple, 0);
 
384
 
 
385
        dfield_set_data(field, "infimum", 8);
 
386
        dtype_set(dfield_get_type(field),
 
387
                  DATA_VARCHAR, DATA_ENGLISH | DATA_NOT_NULL, 8);
 
388
        /* Set the corresponding physical record to its place in the page
 
389
        record heap */
 
390
 
 
391
        heap_top = page + PAGE_DATA;
 
392
 
 
393
        infimum_rec = rec_convert_dtuple_to_rec(heap_top, index, tuple, 0);
 
394
 
 
395
        if (UNIV_LIKELY(comp)) {
 
396
                ut_a(infimum_rec == page + PAGE_NEW_INFIMUM);
 
397
 
 
398
                rec_set_n_owned_new(infimum_rec, NULL, 1);
 
399
                rec_set_heap_no_new(infimum_rec, 0);
 
400
        } else {
 
401
                ut_a(infimum_rec == page + PAGE_OLD_INFIMUM);
 
402
 
 
403
                rec_set_n_owned_old(infimum_rec, 1);
 
404
                rec_set_heap_no_old(infimum_rec, 0);
 
405
        }
 
406
 
 
407
        offsets = rec_get_offsets(infimum_rec, index, NULL,
 
408
                                  ULINT_UNDEFINED, &heap);
 
409
 
 
410
        heap_top = rec_get_end(infimum_rec, offsets);
 
411
 
 
412
        /* Create then a tuple for supremum */
 
413
 
 
414
        tuple = dtuple_create(heap, 1);
 
415
        dtuple_set_info_bits(tuple, REC_STATUS_SUPREMUM);
 
416
        field = dtuple_get_nth_field(tuple, 0);
 
417
 
 
418
        dfield_set_data(field, "supremum", comp ? 8 : 9);
 
419
        dtype_set(dfield_get_type(field),
 
420
                  DATA_VARCHAR, DATA_ENGLISH | DATA_NOT_NULL, comp ? 8 : 9);
 
421
 
 
422
        supremum_rec = rec_convert_dtuple_to_rec(heap_top, index, tuple, 0);
 
423
 
 
424
        if (UNIV_LIKELY(comp)) {
 
425
                ut_a(supremum_rec == page + PAGE_NEW_SUPREMUM);
 
426
 
 
427
                rec_set_n_owned_new(supremum_rec, NULL, 1);
 
428
                rec_set_heap_no_new(supremum_rec, 1);
 
429
        } else {
 
430
                ut_a(supremum_rec == page + PAGE_OLD_SUPREMUM);
 
431
 
 
432
                rec_set_n_owned_old(supremum_rec, 1);
 
433
                rec_set_heap_no_old(supremum_rec, 1);
 
434
        }
 
435
 
 
436
        offsets = rec_get_offsets(supremum_rec, index, offsets,
 
437
                                  ULINT_UNDEFINED, &heap);
 
438
        heap_top = rec_get_end(supremum_rec, offsets);
 
439
 
 
440
        ut_ad(heap_top == page
 
441
              + (comp ? PAGE_NEW_SUPREMUM_END : PAGE_OLD_SUPREMUM_END));
 
442
 
 
443
        mem_heap_free(heap);
 
444
 
 
445
        /* 4. INITIALIZE THE PAGE */
 
446
 
 
447
        page_header_set_field(page, NULL, PAGE_N_DIR_SLOTS, 2);
 
448
        page_header_set_ptr(page, NULL, PAGE_HEAP_TOP, heap_top);
 
449
        page_header_set_field(page, NULL, PAGE_N_HEAP, comp
 
450
                              ? 0x8000 | PAGE_HEAP_NO_USER_LOW
 
451
                              : PAGE_HEAP_NO_USER_LOW);
 
452
        page_header_set_ptr(page, NULL, PAGE_FREE, NULL);
 
453
        page_header_set_field(page, NULL, PAGE_GARBAGE, 0);
 
454
        page_header_set_ptr(page, NULL, PAGE_LAST_INSERT, NULL);
 
455
        page_header_set_field(page, NULL, PAGE_DIRECTION, PAGE_NO_DIRECTION);
 
456
        page_header_set_field(page, NULL, PAGE_N_DIRECTION, 0);
 
457
        page_header_set_field(page, NULL, PAGE_N_RECS, 0);
 
458
        page_set_max_trx_id(block, NULL, ut_dulint_zero, NULL);
 
459
        memset(heap_top, 0, UNIV_PAGE_SIZE - PAGE_EMPTY_DIR_START
 
460
               - page_offset(heap_top));
 
461
 
 
462
        /* 5. SET POINTERS IN RECORDS AND DIR SLOTS */
 
463
 
 
464
        /* Set the slots to point to infimum and supremum. */
 
465
 
 
466
        slot = page_dir_get_nth_slot(page, 0);
 
467
        page_dir_slot_set_rec(slot, infimum_rec);
 
468
 
 
469
        slot = page_dir_get_nth_slot(page, 1);
 
470
        page_dir_slot_set_rec(slot, supremum_rec);
 
471
 
 
472
        /* Set the next pointers in infimum and supremum */
 
473
 
 
474
        if (UNIV_LIKELY(comp)) {
 
475
                rec_set_next_offs_new(infimum_rec, PAGE_NEW_SUPREMUM);
 
476
                rec_set_next_offs_new(supremum_rec, 0);
 
477
        } else {
 
478
                rec_set_next_offs_old(infimum_rec, PAGE_OLD_SUPREMUM);
 
479
                rec_set_next_offs_old(supremum_rec, 0);
 
480
        }
 
481
 
 
482
        return(page);
 
483
}
 
484
 
 
485
/**********************************************************//**
 
486
Create an uncompressed B-tree index page.
 
487
@return pointer to the page */
 
488
UNIV_INTERN
 
489
page_t*
 
490
page_create(
 
491
/*========*/
 
492
        buf_block_t*    block,          /*!< in: a buffer block where the
 
493
                                        page is created */
 
494
        mtr_t*          mtr,            /*!< in: mini-transaction handle */
 
495
        ulint           comp)           /*!< in: nonzero=compact page format */
 
496
{
 
497
        page_create_write_log(buf_block_get_frame(block), mtr, comp);
 
498
        return(page_create_low(block, comp));
 
499
}
 
500
 
 
501
/**********************************************************//**
 
502
Create a compressed B-tree index page.
 
503
@return pointer to the page */
 
504
UNIV_INTERN
 
505
page_t*
 
506
page_create_zip(
 
507
/*============*/
 
508
        buf_block_t*    block,          /*!< in/out: a buffer frame where the
 
509
                                        page is created */
 
510
        dict_index_t*   index,          /*!< in: the index of the page */
 
511
        ulint           level,          /*!< in: the B-tree level of the page */
 
512
        mtr_t*          mtr)            /*!< in: mini-transaction handle */
 
513
{
 
514
        page_t*         page;
 
515
        page_zip_des_t* page_zip        = buf_block_get_page_zip(block);
 
516
 
 
517
        ut_ad(block);
 
518
        ut_ad(page_zip);
 
519
        ut_ad(index);
 
520
        ut_ad(dict_table_is_comp(index->table));
 
521
 
 
522
        page = page_create_low(block, TRUE);
 
523
        mach_write_to_2(page + PAGE_HEADER + PAGE_LEVEL, level);
 
524
 
 
525
        if (UNIV_UNLIKELY(!page_zip_compress(page_zip, page, index, mtr))) {
 
526
                /* The compression of a newly created page
 
527
                should always succeed. */
 
528
                ut_error;
 
529
        }
 
530
 
 
531
        return(page);
 
532
}
 
533
 
 
534
/*************************************************************//**
 
535
Differs from page_copy_rec_list_end, because this function does not
 
536
touch the lock table and max trx id on page or compress the page. */
 
537
UNIV_INTERN
 
538
void
 
539
page_copy_rec_list_end_no_locks(
 
540
/*============================*/
 
541
        buf_block_t*    new_block,      /*!< in: index page to copy to */
 
542
        buf_block_t*    block,          /*!< in: index page of rec */
 
543
        rec_t*          rec,            /*!< in: record on page */
 
544
        dict_index_t*   index,          /*!< in: record descriptor */
 
545
        mtr_t*          mtr)            /*!< in: mtr */
 
546
{
 
547
        page_t*         new_page        = buf_block_get_frame(new_block);
 
548
        page_cur_t      cur1;
 
549
        rec_t*          cur2;
 
550
        mem_heap_t*     heap            = NULL;
 
551
        ulint           offsets_[REC_OFFS_NORMAL_SIZE];
 
552
        ulint*          offsets         = offsets_;
 
553
        rec_offs_init(offsets_);
 
554
 
 
555
        page_cur_position(rec, block, &cur1);
 
556
 
 
557
        if (page_cur_is_before_first(&cur1)) {
 
558
 
 
559
                page_cur_move_to_next(&cur1);
 
560
        }
 
561
 
 
562
        ut_a((ibool)!!page_is_comp(new_page)
 
563
             == dict_table_is_comp(index->table));
 
564
        ut_a(page_is_comp(new_page) == page_rec_is_comp(rec));
 
565
        ut_a(mach_read_from_2(new_page + UNIV_PAGE_SIZE - 10) == (ulint)
 
566
             (page_is_comp(new_page) ? PAGE_NEW_INFIMUM : PAGE_OLD_INFIMUM));
 
567
 
 
568
        cur2 = page_get_infimum_rec(buf_block_get_frame(new_block));
 
569
 
 
570
        /* Copy records from the original page to the new page */
 
571
 
 
572
        while (!page_cur_is_after_last(&cur1)) {
 
573
                rec_t*  cur1_rec = page_cur_get_rec(&cur1);
 
574
                rec_t*  ins_rec;
 
575
                offsets = rec_get_offsets(cur1_rec, index, offsets,
 
576
                                          ULINT_UNDEFINED, &heap);
 
577
                ins_rec = page_cur_insert_rec_low(cur2, index,
 
578
                                                  cur1_rec, offsets, mtr);
 
579
                if (UNIV_UNLIKELY(!ins_rec)) {
 
580
                        /* Track an assertion failure reported on the mailing
 
581
                        list on June 18th, 2003 */
 
582
 
 
583
                        buf_page_print(new_page, 0);
 
584
                        buf_page_print(page_align(rec), 0);
 
585
                        ut_print_timestamp(stderr);
 
586
 
 
587
                        fprintf(stderr,
 
588
                                "InnoDB: rec offset %lu, cur1 offset %lu,"
 
589
                                " cur2 offset %lu\n",
 
590
                                (ulong) page_offset(rec),
 
591
                                (ulong) page_offset(page_cur_get_rec(&cur1)),
 
592
                                (ulong) page_offset(cur2));
 
593
                        ut_error;
 
594
                }
 
595
 
 
596
                page_cur_move_to_next(&cur1);
 
597
                cur2 = ins_rec;
 
598
        }
 
599
 
 
600
        if (UNIV_LIKELY_NULL(heap)) {
 
601
                mem_heap_free(heap);
 
602
        }
 
603
}
 
604
 
 
605
#ifndef UNIV_HOTBACKUP
 
606
/*************************************************************//**
 
607
Copies records from page to new_page, from a given record onward,
 
608
including that record. Infimum and supremum records are not copied.
 
609
The records are copied to the start of the record list on new_page.
 
610
@return pointer to the original successor of the infimum record on
 
611
new_page, or NULL on zip overflow (new_block will be decompressed) */
 
612
UNIV_INTERN
 
613
rec_t*
 
614
page_copy_rec_list_end(
 
615
/*===================*/
 
616
        buf_block_t*    new_block,      /*!< in/out: index page to copy to */
 
617
        buf_block_t*    block,          /*!< in: index page containing rec */
 
618
        rec_t*          rec,            /*!< in: record on page */
 
619
        dict_index_t*   index,          /*!< in: record descriptor */
 
620
        mtr_t*          mtr)            /*!< in: mtr */
 
621
{
 
622
        page_t*         new_page        = buf_block_get_frame(new_block);
 
623
        page_zip_des_t* new_page_zip    = buf_block_get_page_zip(new_block);
 
624
        page_t*         page            = page_align(rec);
 
625
        rec_t*          ret             = page_rec_get_next(
 
626
                page_get_infimum_rec(new_page));
 
627
        ulint           log_mode        = 0; /* remove warning */
 
628
 
 
629
#ifdef UNIV_ZIP_DEBUG
 
630
        if (new_page_zip) {
 
631
                page_zip_des_t* page_zip = buf_block_get_page_zip(block);
 
632
                ut_a(page_zip);
 
633
 
 
634
                /* Strict page_zip_validate() may fail here.
 
635
                Furthermore, btr_compress() may set FIL_PAGE_PREV to
 
636
                FIL_NULL on new_page while leaving it intact on
 
637
                new_page_zip.  So, we cannot validate new_page_zip. */
 
638
                ut_a(page_zip_validate_low(page_zip, page, TRUE));
 
639
        }
 
640
#endif /* UNIV_ZIP_DEBUG */
 
641
        ut_ad(buf_block_get_frame(block) == page);
 
642
        ut_ad(page_is_leaf(page) == page_is_leaf(new_page));
 
643
        ut_ad(page_is_comp(page) == page_is_comp(new_page));
 
644
        /* Here, "ret" may be pointing to a user record or the
 
645
        predefined supremum record. */
 
646
 
 
647
        if (UNIV_LIKELY_NULL(new_page_zip)) {
 
648
                log_mode = mtr_set_log_mode(mtr, MTR_LOG_NONE);
 
649
        }
 
650
 
 
651
        if (page_dir_get_n_heap(new_page) == PAGE_HEAP_NO_USER_LOW) {
 
652
                page_copy_rec_list_end_to_created_page(new_page, rec,
 
653
                                                       index, mtr);
 
654
        } else {
 
655
                page_copy_rec_list_end_no_locks(new_block, block, rec,
 
656
                                                index, mtr);
 
657
        }
 
658
 
 
659
        if (UNIV_LIKELY_NULL(new_page_zip)) {
 
660
                mtr_set_log_mode(mtr, log_mode);
 
661
 
 
662
                if (UNIV_UNLIKELY
 
663
                    (!page_zip_compress(new_page_zip, new_page, index, mtr))) {
 
664
                        /* Before trying to reorganize the page,
 
665
                        store the number of preceding records on the page. */
 
666
                        ulint   ret_pos
 
667
                                = page_rec_get_n_recs_before(ret);
 
668
                        /* Before copying, "ret" was the successor of
 
669
                        the predefined infimum record.  It must still
 
670
                        have at least one predecessor (the predefined
 
671
                        infimum record, or a freshly copied record
 
672
                        that is smaller than "ret"). */
 
673
                        ut_a(ret_pos > 0);
 
674
 
 
675
                        if (UNIV_UNLIKELY
 
676
                            (!page_zip_reorganize(new_block, index, mtr))) {
 
677
 
 
678
                                if (UNIV_UNLIKELY
 
679
                                    (!page_zip_decompress(new_page_zip,
 
680
                                                          new_page))) {
 
681
                                        ut_error;
 
682
                                }
 
683
                                ut_ad(page_validate(new_page, index));
 
684
                                return(NULL);
 
685
                        } else {
 
686
                                /* The page was reorganized:
 
687
                                Seek to ret_pos. */
 
688
                                ret = new_page + PAGE_NEW_INFIMUM;
 
689
 
 
690
                                do {
 
691
                                        ret = rec_get_next_ptr(ret, TRUE);
 
692
                                } while (--ret_pos);
 
693
                        }
 
694
                }
 
695
        }
 
696
 
 
697
        /* Update the lock table, MAX_TRX_ID, and possible hash index */
 
698
 
 
699
        lock_move_rec_list_end(new_block, block, rec);
 
700
 
 
701
        if (dict_index_is_sec_or_ibuf(index) && page_is_leaf(page)) {
 
702
                page_update_max_trx_id(new_block, new_page_zip,
 
703
                                       page_get_max_trx_id(page), mtr);
 
704
        }
 
705
 
 
706
        btr_search_move_or_delete_hash_entries(new_block, block, index);
 
707
 
 
708
        return(ret);
 
709
}
 
710
 
 
711
/*************************************************************//**
 
712
Copies records from page to new_page, up to the given record,
 
713
NOT including that record. Infimum and supremum records are not copied.
 
714
The records are copied to the end of the record list on new_page.
 
715
@return pointer to the original predecessor of the supremum record on
 
716
new_page, or NULL on zip overflow (new_block will be decompressed) */
 
717
UNIV_INTERN
 
718
rec_t*
 
719
page_copy_rec_list_start(
 
720
/*=====================*/
 
721
        buf_block_t*    new_block,      /*!< in/out: index page to copy to */
 
722
        buf_block_t*    block,          /*!< in: index page containing rec */
 
723
        rec_t*          rec,            /*!< in: record on page */
 
724
        dict_index_t*   index,          /*!< in: record descriptor */
 
725
        mtr_t*          mtr)            /*!< in: mtr */
 
726
{
 
727
        page_t*         new_page        = buf_block_get_frame(new_block);
 
728
        page_zip_des_t* new_page_zip    = buf_block_get_page_zip(new_block);
 
729
        page_cur_t      cur1;
 
730
        rec_t*          cur2;
 
731
        ulint           log_mode        = 0 /* remove warning */;
 
732
        mem_heap_t*     heap            = NULL;
 
733
        rec_t*          ret
 
734
                = page_rec_get_prev(page_get_supremum_rec(new_page));
 
735
        ulint           offsets_[REC_OFFS_NORMAL_SIZE];
 
736
        ulint*          offsets         = offsets_;
 
737
        rec_offs_init(offsets_);
 
738
 
 
739
        /* Here, "ret" may be pointing to a user record or the
 
740
        predefined infimum record. */
 
741
 
 
742
        if (page_rec_is_infimum(rec)) {
 
743
 
 
744
                return(ret);
 
745
        }
 
746
 
 
747
        if (UNIV_LIKELY_NULL(new_page_zip)) {
 
748
                log_mode = mtr_set_log_mode(mtr, MTR_LOG_NONE);
 
749
        }
 
750
 
 
751
        page_cur_set_before_first(block, &cur1);
 
752
        page_cur_move_to_next(&cur1);
 
753
 
 
754
        cur2 = ret;
 
755
 
 
756
        /* Copy records from the original page to the new page */
 
757
 
 
758
        while (page_cur_get_rec(&cur1) != rec) {
 
759
                rec_t*  cur1_rec = page_cur_get_rec(&cur1);
 
760
                offsets = rec_get_offsets(cur1_rec, index, offsets,
 
761
                                          ULINT_UNDEFINED, &heap);
 
762
                cur2 = page_cur_insert_rec_low(cur2, index,
 
763
                                               cur1_rec, offsets, mtr);
 
764
                ut_a(cur2);
 
765
 
 
766
                page_cur_move_to_next(&cur1);
 
767
        }
 
768
 
 
769
        if (UNIV_LIKELY_NULL(heap)) {
 
770
                mem_heap_free(heap);
 
771
        }
 
772
 
 
773
        if (UNIV_LIKELY_NULL(new_page_zip)) {
 
774
                mtr_set_log_mode(mtr, log_mode);
 
775
 
 
776
                if (UNIV_UNLIKELY
 
777
                    (!page_zip_compress(new_page_zip, new_page, index, mtr))) {
 
778
                        /* Before trying to reorganize the page,
 
779
                        store the number of preceding records on the page. */
 
780
                        ulint   ret_pos
 
781
                                = page_rec_get_n_recs_before(ret);
 
782
                        /* Before copying, "ret" was the predecessor
 
783
                        of the predefined supremum record.  If it was
 
784
                        the predefined infimum record, then it would
 
785
                        still be the infimum.  Thus, the assertion
 
786
                        ut_a(ret_pos > 0) would fail here. */
 
787
 
 
788
                        if (UNIV_UNLIKELY
 
789
                            (!page_zip_reorganize(new_block, index, mtr))) {
 
790
 
 
791
                                if (UNIV_UNLIKELY
 
792
                                    (!page_zip_decompress(new_page_zip,
 
793
                                                          new_page))) {
 
794
                                        ut_error;
 
795
                                }
 
796
                                ut_ad(page_validate(new_page, index));
 
797
                                return(NULL);
 
798
                        } else {
 
799
                                /* The page was reorganized:
 
800
                                Seek to ret_pos. */
 
801
                                ret = new_page + PAGE_NEW_INFIMUM;
 
802
 
 
803
                                do {
 
804
                                        ret = rec_get_next_ptr(ret, TRUE);
 
805
                                } while (--ret_pos);
 
806
                        }
 
807
                }
 
808
        }
 
809
 
 
810
        /* Update MAX_TRX_ID, the lock table, and possible hash index */
 
811
 
 
812
        if (dict_index_is_sec_or_ibuf(index)
 
813
            && page_is_leaf(page_align(rec))) {
 
814
                page_update_max_trx_id(new_block, new_page_zip,
 
815
                                       page_get_max_trx_id(page_align(rec)),
 
816
                                       mtr);
 
817
        }
 
818
 
 
819
        lock_move_rec_list_start(new_block, block, rec, ret);
 
820
 
 
821
        btr_search_move_or_delete_hash_entries(new_block, block, index);
 
822
 
 
823
        return(ret);
 
824
}
 
825
 
 
826
/**********************************************************//**
 
827
Writes a log record of a record list end or start deletion. */
 
828
UNIV_INLINE
 
829
void
 
830
page_delete_rec_list_write_log(
 
831
/*===========================*/
 
832
        rec_t*          rec,    /*!< in: record on page */
 
833
        dict_index_t*   index,  /*!< in: record descriptor */
 
834
        byte            type,   /*!< in: operation type:
 
835
                                MLOG_LIST_END_DELETE, ... */
 
836
        mtr_t*          mtr)    /*!< in: mtr */
 
837
{
 
838
        byte*   log_ptr;
 
839
        ut_ad(type == MLOG_LIST_END_DELETE
 
840
              || type == MLOG_LIST_START_DELETE
 
841
              || type == MLOG_COMP_LIST_END_DELETE
 
842
              || type == MLOG_COMP_LIST_START_DELETE);
 
843
 
 
844
        log_ptr = mlog_open_and_write_index(mtr, rec, index, type, 2);
 
845
        if (log_ptr) {
 
846
                /* Write the parameter as a 2-byte ulint */
 
847
                mach_write_to_2(log_ptr, page_offset(rec));
 
848
                mlog_close(mtr, log_ptr + 2);
 
849
        }
 
850
}
 
851
#else /* !UNIV_HOTBACKUP */
 
852
# define page_delete_rec_list_write_log(rec,index,type,mtr) ((void) 0)
 
853
#endif /* !UNIV_HOTBACKUP */
 
854
 
 
855
/**********************************************************//**
 
856
Parses a log record of a record list end or start deletion.
 
857
@return end of log record or NULL */
 
858
UNIV_INTERN
 
859
byte*
 
860
page_parse_delete_rec_list(
 
861
/*=======================*/
 
862
        byte            type,   /*!< in: MLOG_LIST_END_DELETE,
 
863
                                MLOG_LIST_START_DELETE,
 
864
                                MLOG_COMP_LIST_END_DELETE or
 
865
                                MLOG_COMP_LIST_START_DELETE */
 
866
        byte*           ptr,    /*!< in: buffer */
 
867
        byte*           end_ptr,/*!< in: buffer end */
 
868
        buf_block_t*    block,  /*!< in/out: buffer block or NULL */
 
869
        dict_index_t*   index,  /*!< in: record descriptor */
 
870
        mtr_t*          mtr)    /*!< in: mtr or NULL */
 
871
{
 
872
        page_t* page;
 
873
        ulint   offset;
 
874
 
 
875
        ut_ad(type == MLOG_LIST_END_DELETE
 
876
              || type == MLOG_LIST_START_DELETE
 
877
              || type == MLOG_COMP_LIST_END_DELETE
 
878
              || type == MLOG_COMP_LIST_START_DELETE);
 
879
 
 
880
        /* Read the record offset as a 2-byte ulint */
 
881
 
 
882
        if (end_ptr < ptr + 2) {
 
883
 
 
884
                return(NULL);
 
885
        }
 
886
 
 
887
        offset = mach_read_from_2(ptr);
 
888
        ptr += 2;
 
889
 
 
890
        if (!block) {
 
891
 
 
892
                return(ptr);
 
893
        }
 
894
 
 
895
        page = buf_block_get_frame(block);
 
896
 
 
897
        ut_ad(!!page_is_comp(page) == dict_table_is_comp(index->table));
 
898
 
 
899
        if (type == MLOG_LIST_END_DELETE
 
900
            || type == MLOG_COMP_LIST_END_DELETE) {
 
901
                page_delete_rec_list_end(page + offset, block, index,
 
902
                                         ULINT_UNDEFINED, ULINT_UNDEFINED,
 
903
                                         mtr);
 
904
        } else {
 
905
                page_delete_rec_list_start(page + offset, block, index, mtr);
 
906
        }
 
907
 
 
908
        return(ptr);
 
909
}
 
910
 
 
911
/*************************************************************//**
 
912
Deletes records from a page from a given record onward, including that record.
 
913
The infimum and supremum records are not deleted. */
 
914
UNIV_INTERN
 
915
void
 
916
page_delete_rec_list_end(
 
917
/*=====================*/
 
918
        rec_t*          rec,    /*!< in: pointer to record on page */
 
919
        buf_block_t*    block,  /*!< in: buffer block of the page */
 
920
        dict_index_t*   index,  /*!< in: record descriptor */
 
921
        ulint           n_recs, /*!< in: number of records to delete,
 
922
                                or ULINT_UNDEFINED if not known */
 
923
        ulint           size,   /*!< in: the sum of the sizes of the
 
924
                                records in the end of the chain to
 
925
                                delete, or ULINT_UNDEFINED if not known */
 
926
        mtr_t*          mtr)    /*!< in: mtr */
 
927
{
 
928
        page_dir_slot_t*slot;
 
929
        ulint           slot_index;
 
930
        rec_t*          last_rec;
 
931
        rec_t*          prev_rec;
 
932
        ulint           n_owned;
 
933
        page_zip_des_t* page_zip        = buf_block_get_page_zip(block);
 
934
        page_t*         page            = page_align(rec);
 
935
        mem_heap_t*     heap            = NULL;
 
936
        ulint           offsets_[REC_OFFS_NORMAL_SIZE];
 
937
        ulint*          offsets         = offsets_;
 
938
        rec_offs_init(offsets_);
 
939
 
 
940
        ut_ad(size == ULINT_UNDEFINED || size < UNIV_PAGE_SIZE);
 
941
        ut_ad(!page_zip || page_rec_is_comp(rec));
 
942
#ifdef UNIV_ZIP_DEBUG
 
943
        ut_a(!page_zip || page_zip_validate(page_zip, page));
 
944
#endif /* UNIV_ZIP_DEBUG */
 
945
 
 
946
        if (page_rec_is_infimum(rec)) {
 
947
                rec = page_rec_get_next(rec);
 
948
        }
 
949
 
 
950
        if (page_rec_is_supremum(rec)) {
 
951
 
 
952
                return;
 
953
        }
 
954
 
 
955
        /* Reset the last insert info in the page header and increment
 
956
        the modify clock for the frame */
 
957
 
 
958
        page_header_set_ptr(page, page_zip, PAGE_LAST_INSERT, NULL);
 
959
 
 
960
        /* The page gets invalid for optimistic searches: increment the
 
961
        frame modify clock */
 
962
 
 
963
        buf_block_modify_clock_inc(block);
 
964
 
 
965
        page_delete_rec_list_write_log(rec, index, page_is_comp(page)
 
966
                                       ? MLOG_COMP_LIST_END_DELETE
 
967
                                       : MLOG_LIST_END_DELETE, mtr);
 
968
 
 
969
        if (UNIV_LIKELY_NULL(page_zip)) {
 
970
                ulint           log_mode;
 
971
 
 
972
                ut_a(page_is_comp(page));
 
973
                /* Individual deletes are not logged */
 
974
 
 
975
                log_mode = mtr_set_log_mode(mtr, MTR_LOG_NONE);
 
976
 
 
977
                do {
 
978
                        page_cur_t      cur;
 
979
                        page_cur_position(rec, block, &cur);
 
980
 
 
981
                        offsets = rec_get_offsets(rec, index, offsets,
 
982
                                                  ULINT_UNDEFINED, &heap);
 
983
                        rec = rec_get_next_ptr(rec, TRUE);
 
984
#ifdef UNIV_ZIP_DEBUG
 
985
                        ut_a(page_zip_validate(page_zip, page));
 
986
#endif /* UNIV_ZIP_DEBUG */
 
987
                        page_cur_delete_rec(&cur, index, offsets, mtr);
 
988
                } while (page_offset(rec) != PAGE_NEW_SUPREMUM);
 
989
 
 
990
                if (UNIV_LIKELY_NULL(heap)) {
 
991
                        mem_heap_free(heap);
 
992
                }
 
993
 
 
994
                /* Restore log mode */
 
995
 
 
996
                mtr_set_log_mode(mtr, log_mode);
 
997
                return;
 
998
        }
 
999
 
 
1000
        prev_rec = page_rec_get_prev(rec);
 
1001
 
 
1002
        last_rec = page_rec_get_prev(page_get_supremum_rec(page));
 
1003
 
 
1004
        if ((size == ULINT_UNDEFINED) || (n_recs == ULINT_UNDEFINED)) {
 
1005
                rec_t*          rec2            = rec;
 
1006
                /* Calculate the sum of sizes and the number of records */
 
1007
                size = 0;
 
1008
                n_recs = 0;
 
1009
 
 
1010
                do {
 
1011
                        ulint   s;
 
1012
                        offsets = rec_get_offsets(rec2, index, offsets,
 
1013
                                                  ULINT_UNDEFINED, &heap);
 
1014
                        s = rec_offs_size(offsets);
 
1015
                        ut_ad(rec2 - page + s - rec_offs_extra_size(offsets)
 
1016
                              < UNIV_PAGE_SIZE);
 
1017
                        ut_ad(size + s < UNIV_PAGE_SIZE);
 
1018
                        size += s;
 
1019
                        n_recs++;
 
1020
 
 
1021
                        rec2 = page_rec_get_next(rec2);
 
1022
                } while (!page_rec_is_supremum(rec2));
 
1023
 
 
1024
                if (UNIV_LIKELY_NULL(heap)) {
 
1025
                        mem_heap_free(heap);
 
1026
                }
 
1027
        }
 
1028
 
 
1029
        ut_ad(size < UNIV_PAGE_SIZE);
 
1030
 
 
1031
        /* Update the page directory; there is no need to balance the number
 
1032
        of the records owned by the supremum record, as it is allowed to be
 
1033
        less than PAGE_DIR_SLOT_MIN_N_OWNED */
 
1034
 
 
1035
        if (page_is_comp(page)) {
 
1036
                rec_t*  rec2    = rec;
 
1037
                ulint   count   = 0;
 
1038
 
 
1039
                while (rec_get_n_owned_new(rec2) == 0) {
 
1040
                        count++;
 
1041
 
 
1042
                        rec2 = rec_get_next_ptr(rec2, TRUE);
 
1043
                }
 
1044
 
 
1045
                ut_ad(rec_get_n_owned_new(rec2) > count);
 
1046
 
 
1047
                n_owned = rec_get_n_owned_new(rec2) - count;
 
1048
                slot_index = page_dir_find_owner_slot(rec2);
 
1049
                slot = page_dir_get_nth_slot(page, slot_index);
 
1050
        } else {
 
1051
                rec_t*  rec2    = rec;
 
1052
                ulint   count   = 0;
 
1053
 
 
1054
                while (rec_get_n_owned_old(rec2) == 0) {
 
1055
                        count++;
 
1056
 
 
1057
                        rec2 = rec_get_next_ptr(rec2, FALSE);
 
1058
                }
 
1059
 
 
1060
                ut_ad(rec_get_n_owned_old(rec2) > count);
 
1061
 
 
1062
                n_owned = rec_get_n_owned_old(rec2) - count;
 
1063
                slot_index = page_dir_find_owner_slot(rec2);
 
1064
                slot = page_dir_get_nth_slot(page, slot_index);
 
1065
        }
 
1066
 
 
1067
        page_dir_slot_set_rec(slot, page_get_supremum_rec(page));
 
1068
        page_dir_slot_set_n_owned(slot, NULL, n_owned);
 
1069
 
 
1070
        page_dir_set_n_slots(page, NULL, slot_index + 1);
 
1071
 
 
1072
        /* Remove the record chain segment from the record chain */
 
1073
        page_rec_set_next(prev_rec, page_get_supremum_rec(page));
 
1074
 
 
1075
        /* Catenate the deleted chain segment to the page free list */
 
1076
 
 
1077
        page_rec_set_next(last_rec, page_header_get_ptr(page, PAGE_FREE));
 
1078
        page_header_set_ptr(page, NULL, PAGE_FREE, rec);
 
1079
 
 
1080
        page_header_set_field(page, NULL, PAGE_GARBAGE, size
 
1081
                              + page_header_get_field(page, PAGE_GARBAGE));
 
1082
 
 
1083
        page_header_set_field(page, NULL, PAGE_N_RECS,
 
1084
                              (ulint)(page_get_n_recs(page) - n_recs));
 
1085
}
 
1086
 
 
1087
/*************************************************************//**
 
1088
Deletes records from page, up to the given record, NOT including
 
1089
that record. Infimum and supremum records are not deleted. */
 
1090
UNIV_INTERN
 
1091
void
 
1092
page_delete_rec_list_start(
 
1093
/*=======================*/
 
1094
        rec_t*          rec,    /*!< in: record on page */
 
1095
        buf_block_t*    block,  /*!< in: buffer block of the page */
 
1096
        dict_index_t*   index,  /*!< in: record descriptor */
 
1097
        mtr_t*          mtr)    /*!< in: mtr */
 
1098
{
 
1099
        page_cur_t      cur1;
 
1100
        ulint           log_mode;
 
1101
        ulint           offsets_[REC_OFFS_NORMAL_SIZE];
 
1102
        ulint*          offsets         = offsets_;
 
1103
        mem_heap_t*     heap            = NULL;
 
1104
        byte            type;
 
1105
 
 
1106
        rec_offs_init(offsets_);
 
1107
 
 
1108
        ut_ad((ibool) !!page_rec_is_comp(rec)
 
1109
              == dict_table_is_comp(index->table));
 
1110
#ifdef UNIV_ZIP_DEBUG
 
1111
        {
 
1112
                page_zip_des_t* page_zip= buf_block_get_page_zip(block);
 
1113
                page_t*         page    = buf_block_get_frame(block);
 
1114
 
 
1115
                /* page_zip_validate() would detect a min_rec_mark mismatch
 
1116
                in btr_page_split_and_insert()
 
1117
                between btr_attach_half_pages() and insert_page = ...
 
1118
                when btr_page_get_split_rec_to_left() holds
 
1119
                (direction == FSP_DOWN). */
 
1120
                ut_a(!page_zip || page_zip_validate_low(page_zip, page, TRUE));
 
1121
        }
 
1122
#endif /* UNIV_ZIP_DEBUG */
 
1123
 
 
1124
        if (page_rec_is_infimum(rec)) {
 
1125
 
 
1126
                return;
 
1127
        }
 
1128
 
 
1129
        if (page_rec_is_comp(rec)) {
 
1130
                type = MLOG_COMP_LIST_START_DELETE;
 
1131
        } else {
 
1132
                type = MLOG_LIST_START_DELETE;
 
1133
        }
 
1134
 
 
1135
        page_delete_rec_list_write_log(rec, index, type, mtr);
 
1136
 
 
1137
        page_cur_set_before_first(block, &cur1);
 
1138
        page_cur_move_to_next(&cur1);
 
1139
 
 
1140
        /* Individual deletes are not logged */
 
1141
 
 
1142
        log_mode = mtr_set_log_mode(mtr, MTR_LOG_NONE);
 
1143
 
 
1144
        while (page_cur_get_rec(&cur1) != rec) {
 
1145
                offsets = rec_get_offsets(page_cur_get_rec(&cur1), index,
 
1146
                                          offsets, ULINT_UNDEFINED, &heap);
 
1147
                page_cur_delete_rec(&cur1, index, offsets, mtr);
 
1148
        }
 
1149
 
 
1150
        if (UNIV_LIKELY_NULL(heap)) {
 
1151
                mem_heap_free(heap);
 
1152
        }
 
1153
 
 
1154
        /* Restore log mode */
 
1155
 
 
1156
        mtr_set_log_mode(mtr, log_mode);
 
1157
}
 
1158
 
 
1159
#ifndef UNIV_HOTBACKUP
 
1160
/*************************************************************//**
 
1161
Moves record list end to another page. Moved records include
 
1162
split_rec.
 
1163
@return TRUE on success; FALSE on compression failure (new_block will
 
1164
be decompressed) */
 
1165
UNIV_INTERN
 
1166
ibool
 
1167
page_move_rec_list_end(
 
1168
/*===================*/
 
1169
        buf_block_t*    new_block,      /*!< in/out: index page where to move */
 
1170
        buf_block_t*    block,          /*!< in: index page from where to move */
 
1171
        rec_t*          split_rec,      /*!< in: first record to move */
 
1172
        dict_index_t*   index,          /*!< in: record descriptor */
 
1173
        mtr_t*          mtr)            /*!< in: mtr */
 
1174
{
 
1175
        page_t*         new_page        = buf_block_get_frame(new_block);
 
1176
        ulint           old_data_size;
 
1177
        ulint           new_data_size;
 
1178
        ulint           old_n_recs;
 
1179
        ulint           new_n_recs;
 
1180
 
 
1181
        old_data_size = page_get_data_size(new_page);
 
1182
        old_n_recs = page_get_n_recs(new_page);
 
1183
#ifdef UNIV_ZIP_DEBUG
 
1184
        {
 
1185
                page_zip_des_t* new_page_zip
 
1186
                        = buf_block_get_page_zip(new_block);
 
1187
                page_zip_des_t* page_zip
 
1188
                        = buf_block_get_page_zip(block);
 
1189
                ut_a(!new_page_zip == !page_zip);
 
1190
                ut_a(!new_page_zip
 
1191
                     || page_zip_validate(new_page_zip, new_page));
 
1192
                ut_a(!page_zip
 
1193
                     || page_zip_validate(page_zip, page_align(split_rec)));
 
1194
        }
 
1195
#endif /* UNIV_ZIP_DEBUG */
 
1196
 
 
1197
        if (UNIV_UNLIKELY(!page_copy_rec_list_end(new_block, block,
 
1198
                                                  split_rec, index, mtr))) {
 
1199
                return(FALSE);
 
1200
        }
 
1201
 
 
1202
        new_data_size = page_get_data_size(new_page);
 
1203
        new_n_recs = page_get_n_recs(new_page);
 
1204
 
 
1205
        ut_ad(new_data_size >= old_data_size);
 
1206
 
 
1207
        page_delete_rec_list_end(split_rec, block, index,
 
1208
                                 new_n_recs - old_n_recs,
 
1209
                                 new_data_size - old_data_size, mtr);
 
1210
 
 
1211
        return(TRUE);
 
1212
}
 
1213
 
 
1214
/*************************************************************//**
 
1215
Moves record list start to another page. Moved records do not include
 
1216
split_rec.
 
1217
@return TRUE on success; FALSE on compression failure */
 
1218
UNIV_INTERN
 
1219
ibool
 
1220
page_move_rec_list_start(
 
1221
/*=====================*/
 
1222
        buf_block_t*    new_block,      /*!< in/out: index page where to move */
 
1223
        buf_block_t*    block,          /*!< in/out: page containing split_rec */
 
1224
        rec_t*          split_rec,      /*!< in: first record not to move */
 
1225
        dict_index_t*   index,          /*!< in: record descriptor */
 
1226
        mtr_t*          mtr)            /*!< in: mtr */
 
1227
{
 
1228
        if (UNIV_UNLIKELY(!page_copy_rec_list_start(new_block, block,
 
1229
                                                    split_rec, index, mtr))) {
 
1230
                return(FALSE);
 
1231
        }
 
1232
 
 
1233
        page_delete_rec_list_start(split_rec, block, index, mtr);
 
1234
 
 
1235
        return(TRUE);
 
1236
}
 
1237
 
 
1238
/***********************************************************************//**
 
1239
This is a low-level operation which is used in a database index creation
 
1240
to update the page number of a created B-tree to a data dictionary record. */
 
1241
UNIV_INTERN
 
1242
void
 
1243
page_rec_write_index_page_no(
 
1244
/*=========================*/
 
1245
        rec_t*  rec,    /*!< in: record to update */
 
1246
        ulint   i,      /*!< in: index of the field to update */
 
1247
        ulint   page_no,/*!< in: value to write */
 
1248
        mtr_t*  mtr)    /*!< in: mtr */
 
1249
{
 
1250
        byte*   data;
 
1251
        ulint   len;
 
1252
 
 
1253
        data = rec_get_nth_field_old(rec, i, &len);
 
1254
 
 
1255
        ut_ad(len == 4);
 
1256
 
 
1257
        mlog_write_ulint(data, page_no, MLOG_4BYTES, mtr);
 
1258
}
 
1259
#endif /* !UNIV_HOTBACKUP */
 
1260
 
 
1261
/**************************************************************//**
 
1262
Used to delete n slots from the directory. This function updates
 
1263
also n_owned fields in the records, so that the first slot after
 
1264
the deleted ones inherits the records of the deleted slots. */
 
1265
UNIV_INLINE
 
1266
void
 
1267
page_dir_delete_slot(
 
1268
/*=================*/
 
1269
        page_t*         page,   /*!< in/out: the index page */
 
1270
        page_zip_des_t* page_zip,/*!< in/out: compressed page, or NULL */
 
1271
        ulint           slot_no)/*!< in: slot to be deleted */
 
1272
{
 
1273
        page_dir_slot_t*        slot;
 
1274
        ulint                   n_owned;
 
1275
        ulint                   i;
 
1276
        ulint                   n_slots;
 
1277
 
 
1278
        ut_ad(!page_zip || page_is_comp(page));
 
1279
        ut_ad(slot_no > 0);
 
1280
        ut_ad(slot_no + 1 < page_dir_get_n_slots(page));
 
1281
 
 
1282
        n_slots = page_dir_get_n_slots(page);
 
1283
 
 
1284
        /* 1. Reset the n_owned fields of the slots to be
 
1285
        deleted */
 
1286
        slot = page_dir_get_nth_slot(page, slot_no);
 
1287
        n_owned = page_dir_slot_get_n_owned(slot);
 
1288
        page_dir_slot_set_n_owned(slot, page_zip, 0);
 
1289
 
 
1290
        /* 2. Update the n_owned value of the first non-deleted slot */
 
1291
 
 
1292
        slot = page_dir_get_nth_slot(page, slot_no + 1);
 
1293
        page_dir_slot_set_n_owned(slot, page_zip,
 
1294
                                  n_owned + page_dir_slot_get_n_owned(slot));
 
1295
 
 
1296
        /* 3. Destroy the slot by copying slots */
 
1297
        for (i = slot_no + 1; i < n_slots; i++) {
 
1298
                rec_t*  rec = (rec_t*)
 
1299
                        page_dir_slot_get_rec(page_dir_get_nth_slot(page, i));
 
1300
                page_dir_slot_set_rec(page_dir_get_nth_slot(page, i - 1), rec);
 
1301
        }
 
1302
 
 
1303
        /* 4. Zero out the last slot, which will be removed */
 
1304
        mach_write_to_2(page_dir_get_nth_slot(page, n_slots - 1), 0);
 
1305
 
 
1306
        /* 5. Update the page header */
 
1307
        page_header_set_field(page, page_zip, PAGE_N_DIR_SLOTS, n_slots - 1);
 
1308
}
 
1309
 
 
1310
/**************************************************************//**
 
1311
Used to add n slots to the directory. Does not set the record pointers
 
1312
in the added slots or update n_owned values: this is the responsibility
 
1313
of the caller. */
 
1314
UNIV_INLINE
 
1315
void
 
1316
page_dir_add_slot(
 
1317
/*==============*/
 
1318
        page_t*         page,   /*!< in/out: the index page */
 
1319
        page_zip_des_t* page_zip,/*!< in/out: comprssed page, or NULL */
 
1320
        ulint           start)  /*!< in: the slot above which the new slots
 
1321
                                are added */
 
1322
{
 
1323
        page_dir_slot_t*        slot;
 
1324
        ulint                   n_slots;
 
1325
 
 
1326
        n_slots = page_dir_get_n_slots(page);
 
1327
 
 
1328
        ut_ad(start < n_slots - 1);
 
1329
 
 
1330
        /* Update the page header */
 
1331
        page_dir_set_n_slots(page, page_zip, n_slots + 1);
 
1332
 
 
1333
        /* Move slots up */
 
1334
        slot = page_dir_get_nth_slot(page, n_slots);
 
1335
        memmove(slot, slot + PAGE_DIR_SLOT_SIZE,
 
1336
                (n_slots - 1 - start) * PAGE_DIR_SLOT_SIZE);
 
1337
}
 
1338
 
 
1339
/****************************************************************//**
 
1340
Splits a directory slot which owns too many records. */
 
1341
UNIV_INTERN
 
1342
void
 
1343
page_dir_split_slot(
 
1344
/*================*/
 
1345
        page_t*         page,   /*!< in/out: index page */
 
1346
        page_zip_des_t* page_zip,/*!< in/out: compressed page whose
 
1347
                                uncompressed part will be written, or NULL */
 
1348
        ulint           slot_no)/*!< in: the directory slot */
 
1349
{
 
1350
        rec_t*                  rec;
 
1351
        page_dir_slot_t*        new_slot;
 
1352
        page_dir_slot_t*        prev_slot;
 
1353
        page_dir_slot_t*        slot;
 
1354
        ulint                   i;
 
1355
        ulint                   n_owned;
 
1356
 
 
1357
        ut_ad(page);
 
1358
        ut_ad(!page_zip || page_is_comp(page));
 
1359
        ut_ad(slot_no > 0);
 
1360
 
 
1361
        slot = page_dir_get_nth_slot(page, slot_no);
 
1362
 
 
1363
        n_owned = page_dir_slot_get_n_owned(slot);
 
1364
        ut_ad(n_owned == PAGE_DIR_SLOT_MAX_N_OWNED + 1);
 
1365
 
 
1366
        /* 1. We loop to find a record approximately in the middle of the
 
1367
        records owned by the slot. */
 
1368
 
 
1369
        prev_slot = page_dir_get_nth_slot(page, slot_no - 1);
 
1370
        rec = (rec_t*) page_dir_slot_get_rec(prev_slot);
 
1371
 
 
1372
        for (i = 0; i < n_owned / 2; i++) {
 
1373
                rec = page_rec_get_next(rec);
 
1374
        }
 
1375
 
 
1376
        ut_ad(n_owned / 2 >= PAGE_DIR_SLOT_MIN_N_OWNED);
 
1377
 
 
1378
        /* 2. We add one directory slot immediately below the slot to be
 
1379
        split. */
 
1380
 
 
1381
        page_dir_add_slot(page, page_zip, slot_no - 1);
 
1382
 
 
1383
        /* The added slot is now number slot_no, and the old slot is
 
1384
        now number slot_no + 1 */
 
1385
 
 
1386
        new_slot = page_dir_get_nth_slot(page, slot_no);
 
1387
        slot = page_dir_get_nth_slot(page, slot_no + 1);
 
1388
 
 
1389
        /* 3. We store the appropriate values to the new slot. */
 
1390
 
 
1391
        page_dir_slot_set_rec(new_slot, rec);
 
1392
        page_dir_slot_set_n_owned(new_slot, page_zip, n_owned / 2);
 
1393
 
 
1394
        /* 4. Finally, we update the number of records field of the
 
1395
        original slot */
 
1396
 
 
1397
        page_dir_slot_set_n_owned(slot, page_zip, n_owned - (n_owned / 2));
 
1398
}
 
1399
 
 
1400
/*************************************************************//**
 
1401
Tries to balance the given directory slot with too few records with the upper
 
1402
neighbor, so that there are at least the minimum number of records owned by
 
1403
the slot; this may result in the merging of two slots. */
 
1404
UNIV_INTERN
 
1405
void
 
1406
page_dir_balance_slot(
 
1407
/*==================*/
 
1408
        page_t*         page,   /*!< in/out: index page */
 
1409
        page_zip_des_t* page_zip,/*!< in/out: compressed page, or NULL */
 
1410
        ulint           slot_no)/*!< in: the directory slot */
 
1411
{
 
1412
        page_dir_slot_t*        slot;
 
1413
        page_dir_slot_t*        up_slot;
 
1414
        ulint                   n_owned;
 
1415
        ulint                   up_n_owned;
 
1416
        rec_t*                  old_rec;
 
1417
        rec_t*                  new_rec;
 
1418
 
 
1419
        ut_ad(page);
 
1420
        ut_ad(!page_zip || page_is_comp(page));
 
1421
        ut_ad(slot_no > 0);
 
1422
 
 
1423
        slot = page_dir_get_nth_slot(page, slot_no);
 
1424
 
 
1425
        /* The last directory slot cannot be balanced with the upper
 
1426
        neighbor, as there is none. */
 
1427
 
 
1428
        if (UNIV_UNLIKELY(slot_no == page_dir_get_n_slots(page) - 1)) {
 
1429
 
 
1430
                return;
 
1431
        }
 
1432
 
 
1433
        up_slot = page_dir_get_nth_slot(page, slot_no + 1);
 
1434
 
 
1435
        n_owned = page_dir_slot_get_n_owned(slot);
 
1436
        up_n_owned = page_dir_slot_get_n_owned(up_slot);
 
1437
 
 
1438
        ut_ad(n_owned == PAGE_DIR_SLOT_MIN_N_OWNED - 1);
 
1439
 
 
1440
        /* If the upper slot has the minimum value of n_owned, we will merge
 
1441
        the two slots, therefore we assert: */
 
1442
        ut_ad(2 * PAGE_DIR_SLOT_MIN_N_OWNED - 1 <= PAGE_DIR_SLOT_MAX_N_OWNED);
 
1443
 
 
1444
        if (up_n_owned > PAGE_DIR_SLOT_MIN_N_OWNED) {
 
1445
 
 
1446
                /* In this case we can just transfer one record owned
 
1447
                by the upper slot to the property of the lower slot */
 
1448
                old_rec = (rec_t*) page_dir_slot_get_rec(slot);
 
1449
 
 
1450
                if (page_is_comp(page)) {
 
1451
                        new_rec = rec_get_next_ptr(old_rec, TRUE);
 
1452
 
 
1453
                        rec_set_n_owned_new(old_rec, page_zip, 0);
 
1454
                        rec_set_n_owned_new(new_rec, page_zip, n_owned + 1);
 
1455
                } else {
 
1456
                        new_rec = rec_get_next_ptr(old_rec, FALSE);
 
1457
 
 
1458
                        rec_set_n_owned_old(old_rec, 0);
 
1459
                        rec_set_n_owned_old(new_rec, n_owned + 1);
 
1460
                }
 
1461
 
 
1462
                page_dir_slot_set_rec(slot, new_rec);
 
1463
 
 
1464
                page_dir_slot_set_n_owned(up_slot, page_zip, up_n_owned -1);
 
1465
        } else {
 
1466
                /* In this case we may merge the two slots */
 
1467
                page_dir_delete_slot(page, page_zip, slot_no);
 
1468
        }
 
1469
}
 
1470
 
 
1471
#ifndef UNIV_HOTBACKUP
 
1472
/************************************************************//**
 
1473
Returns the middle record of the record list. If there are an even number
 
1474
of records in the list, returns the first record of the upper half-list.
 
1475
@return middle record */
 
1476
UNIV_INTERN
 
1477
rec_t*
 
1478
page_get_middle_rec(
 
1479
/*================*/
 
1480
        page_t* page)   /*!< in: page */
 
1481
{
 
1482
        page_dir_slot_t*        slot;
 
1483
        ulint                   middle;
 
1484
        ulint                   i;
 
1485
        ulint                   n_owned;
 
1486
        ulint                   count;
 
1487
        rec_t*                  rec;
 
1488
 
 
1489
        /* This many records we must leave behind */
 
1490
        middle = (page_get_n_recs(page) + PAGE_HEAP_NO_USER_LOW) / 2;
 
1491
 
 
1492
        count = 0;
 
1493
 
 
1494
        for (i = 0;; i++) {
 
1495
 
 
1496
                slot = page_dir_get_nth_slot(page, i);
 
1497
                n_owned = page_dir_slot_get_n_owned(slot);
 
1498
 
 
1499
                if (count + n_owned > middle) {
 
1500
                        break;
 
1501
                } else {
 
1502
                        count += n_owned;
 
1503
                }
 
1504
        }
 
1505
 
 
1506
        ut_ad(i > 0);
 
1507
        slot = page_dir_get_nth_slot(page, i - 1);
 
1508
        rec = (rec_t*) page_dir_slot_get_rec(slot);
 
1509
        rec = page_rec_get_next(rec);
 
1510
 
 
1511
        /* There are now count records behind rec */
 
1512
 
 
1513
        for (i = 0; i < middle - count; i++) {
 
1514
                rec = page_rec_get_next(rec);
 
1515
        }
 
1516
 
 
1517
        return(rec);
 
1518
}
 
1519
#endif /* !UNIV_HOTBACKUP */
 
1520
 
 
1521
/***************************************************************//**
 
1522
Returns the number of records before the given record in chain.
 
1523
The number includes infimum and supremum records.
 
1524
@return number of records */
 
1525
UNIV_INTERN
 
1526
ulint
 
1527
page_rec_get_n_recs_before(
 
1528
/*=======================*/
 
1529
        const rec_t*    rec)    /*!< in: the physical record */
 
1530
{
 
1531
        const page_dir_slot_t*  slot;
 
1532
        const rec_t*            slot_rec;
 
1533
        const page_t*           page;
 
1534
        ulint                   i;
 
1535
        lint                    n       = 0;
 
1536
 
 
1537
        ut_ad(page_rec_check(rec));
 
1538
 
 
1539
        page = page_align(rec);
 
1540
        if (page_is_comp(page)) {
 
1541
                while (rec_get_n_owned_new(rec) == 0) {
 
1542
 
 
1543
                        rec = rec_get_next_ptr_const(rec, TRUE);
 
1544
                        n--;
 
1545
                }
 
1546
 
 
1547
                for (i = 0; ; i++) {
 
1548
                        slot = page_dir_get_nth_slot(page, i);
 
1549
                        slot_rec = page_dir_slot_get_rec(slot);
 
1550
 
 
1551
                        n += rec_get_n_owned_new(slot_rec);
 
1552
 
 
1553
                        if (rec == slot_rec) {
 
1554
 
 
1555
                                break;
 
1556
                        }
 
1557
                }
 
1558
        } else {
 
1559
                while (rec_get_n_owned_old(rec) == 0) {
 
1560
 
 
1561
                        rec = rec_get_next_ptr_const(rec, FALSE);
 
1562
                        n--;
 
1563
                }
 
1564
 
 
1565
                for (i = 0; ; i++) {
 
1566
                        slot = page_dir_get_nth_slot(page, i);
 
1567
                        slot_rec = page_dir_slot_get_rec(slot);
 
1568
 
 
1569
                        n += rec_get_n_owned_old(slot_rec);
 
1570
 
 
1571
                        if (rec == slot_rec) {
 
1572
 
 
1573
                                break;
 
1574
                        }
 
1575
                }
 
1576
        }
 
1577
 
 
1578
        n--;
 
1579
 
 
1580
        ut_ad(n >= 0);
 
1581
 
 
1582
        return((ulint) n);
 
1583
}
 
1584
 
 
1585
#ifndef UNIV_HOTBACKUP
 
1586
/************************************************************//**
 
1587
Prints record contents including the data relevant only in
 
1588
the index page context. */
 
1589
UNIV_INTERN
 
1590
void
 
1591
page_rec_print(
 
1592
/*===========*/
 
1593
        const rec_t*    rec,    /*!< in: physical record */
 
1594
        const ulint*    offsets)/*!< in: record descriptor */
 
1595
{
 
1596
        ut_a(!page_rec_is_comp(rec) == !rec_offs_comp(offsets));
 
1597
        rec_print_new(stderr, rec, offsets);
 
1598
        if (page_rec_is_comp(rec)) {
 
1599
                fprintf(stderr,
 
1600
                        " n_owned: %lu; heap_no: %lu; next rec: %lu\n",
 
1601
                        (ulong) rec_get_n_owned_new(rec),
 
1602
                        (ulong) rec_get_heap_no_new(rec),
 
1603
                        (ulong) rec_get_next_offs(rec, TRUE));
 
1604
        } else {
 
1605
                fprintf(stderr,
 
1606
                        " n_owned: %lu; heap_no: %lu; next rec: %lu\n",
 
1607
                        (ulong) rec_get_n_owned_old(rec),
 
1608
                        (ulong) rec_get_heap_no_old(rec),
 
1609
                        (ulong) rec_get_next_offs(rec, TRUE));
 
1610
        }
 
1611
 
 
1612
        page_rec_check(rec);
 
1613
        rec_validate(rec, offsets);
 
1614
}
 
1615
 
 
1616
/***************************************************************//**
 
1617
This is used to print the contents of the directory for
 
1618
debugging purposes. */
 
1619
UNIV_INTERN
 
1620
void
 
1621
page_dir_print(
 
1622
/*===========*/
 
1623
        page_t* page,   /*!< in: index page */
 
1624
        ulint   pr_n)   /*!< in: print n first and n last entries */
 
1625
{
 
1626
        ulint                   n;
 
1627
        ulint                   i;
 
1628
        page_dir_slot_t*        slot;
 
1629
 
 
1630
        n = page_dir_get_n_slots(page);
 
1631
 
 
1632
        fprintf(stderr, "--------------------------------\n"
 
1633
                "PAGE DIRECTORY\n"
 
1634
                "Page address %p\n"
 
1635
                "Directory stack top at offs: %lu; number of slots: %lu\n",
 
1636
                page, (ulong) page_offset(page_dir_get_nth_slot(page, n - 1)),
 
1637
                (ulong) n);
 
1638
        for (i = 0; i < n; i++) {
 
1639
                slot = page_dir_get_nth_slot(page, i);
 
1640
                if ((i == pr_n) && (i < n - pr_n)) {
 
1641
                        fputs("    ...   \n", stderr);
 
1642
                }
 
1643
                if ((i < pr_n) || (i >= n - pr_n)) {
 
1644
                        fprintf(stderr,
 
1645
                                "Contents of slot: %lu: n_owned: %lu,"
 
1646
                                " rec offs: %lu\n",
 
1647
                                (ulong) i,
 
1648
                                (ulong) page_dir_slot_get_n_owned(slot),
 
1649
                                (ulong)
 
1650
                                page_offset(page_dir_slot_get_rec(slot)));
 
1651
                }
 
1652
        }
 
1653
        fprintf(stderr, "Total of %lu records\n"
 
1654
                "--------------------------------\n",
 
1655
                (ulong) (PAGE_HEAP_NO_USER_LOW + page_get_n_recs(page)));
 
1656
}
 
1657
 
 
1658
/***************************************************************//**
 
1659
This is used to print the contents of the page record list for
 
1660
debugging purposes. */
 
1661
UNIV_INTERN
 
1662
void
 
1663
page_print_list(
 
1664
/*============*/
 
1665
        buf_block_t*    block,  /*!< in: index page */
 
1666
        dict_index_t*   index,  /*!< in: dictionary index of the page */
 
1667
        ulint           pr_n)   /*!< in: print n first and n last entries */
 
1668
{
 
1669
        page_t*         page            = block->frame;
 
1670
        page_cur_t      cur;
 
1671
        ulint           count;
 
1672
        ulint           n_recs;
 
1673
        mem_heap_t*     heap            = NULL;
 
1674
        ulint           offsets_[REC_OFFS_NORMAL_SIZE];
 
1675
        ulint*          offsets         = offsets_;
 
1676
        rec_offs_init(offsets_);
 
1677
 
 
1678
        ut_a((ibool)!!page_is_comp(page) == dict_table_is_comp(index->table));
 
1679
 
 
1680
        fprintf(stderr,
 
1681
                "--------------------------------\n"
 
1682
                "PAGE RECORD LIST\n"
 
1683
                "Page address %p\n", page);
 
1684
 
 
1685
        n_recs = page_get_n_recs(page);
 
1686
 
 
1687
        page_cur_set_before_first(block, &cur);
 
1688
        count = 0;
 
1689
        for (;;) {
 
1690
                offsets = rec_get_offsets(cur.rec, index, offsets,
 
1691
                                          ULINT_UNDEFINED, &heap);
 
1692
                page_rec_print(cur.rec, offsets);
 
1693
 
 
1694
                if (count == pr_n) {
 
1695
                        break;
 
1696
                }
 
1697
                if (page_cur_is_after_last(&cur)) {
 
1698
                        break;
 
1699
                }
 
1700
                page_cur_move_to_next(&cur);
 
1701
                count++;
 
1702
        }
 
1703
 
 
1704
        if (n_recs > 2 * pr_n) {
 
1705
                fputs(" ... \n", stderr);
 
1706
        }
 
1707
 
 
1708
        while (!page_cur_is_after_last(&cur)) {
 
1709
                page_cur_move_to_next(&cur);
 
1710
 
 
1711
                if (count + pr_n >= n_recs) {
 
1712
                        offsets = rec_get_offsets(cur.rec, index, offsets,
 
1713
                                                  ULINT_UNDEFINED, &heap);
 
1714
                        page_rec_print(cur.rec, offsets);
 
1715
                }
 
1716
                count++;
 
1717
        }
 
1718
 
 
1719
        fprintf(stderr,
 
1720
                "Total of %lu records \n"
 
1721
                "--------------------------------\n",
 
1722
                (ulong) (count + 1));
 
1723
 
 
1724
        if (UNIV_LIKELY_NULL(heap)) {
 
1725
                mem_heap_free(heap);
 
1726
        }
 
1727
}
 
1728
 
 
1729
/***************************************************************//**
 
1730
Prints the info in a page header. */
 
1731
UNIV_INTERN
 
1732
void
 
1733
page_header_print(
 
1734
/*==============*/
 
1735
        const page_t*   page)
 
1736
{
 
1737
        fprintf(stderr,
 
1738
                "--------------------------------\n"
 
1739
                "PAGE HEADER INFO\n"
 
1740
                "Page address %p, n records %lu (%s)\n"
 
1741
                "n dir slots %lu, heap top %lu\n"
 
1742
                "Page n heap %lu, free %lu, garbage %lu\n"
 
1743
                "Page last insert %lu, direction %lu, n direction %lu\n",
 
1744
                page, (ulong) page_header_get_field(page, PAGE_N_RECS),
 
1745
                page_is_comp(page) ? "compact format" : "original format",
 
1746
                (ulong) page_header_get_field(page, PAGE_N_DIR_SLOTS),
 
1747
                (ulong) page_header_get_field(page, PAGE_HEAP_TOP),
 
1748
                (ulong) page_dir_get_n_heap(page),
 
1749
                (ulong) page_header_get_field(page, PAGE_FREE),
 
1750
                (ulong) page_header_get_field(page, PAGE_GARBAGE),
 
1751
                (ulong) page_header_get_field(page, PAGE_LAST_INSERT),
 
1752
                (ulong) page_header_get_field(page, PAGE_DIRECTION),
 
1753
                (ulong) page_header_get_field(page, PAGE_N_DIRECTION));
 
1754
}
 
1755
 
 
1756
/***************************************************************//**
 
1757
This is used to print the contents of the page for
 
1758
debugging purposes. */
 
1759
UNIV_INTERN
 
1760
void
 
1761
page_print(
 
1762
/*=======*/
 
1763
        buf_block_t*    block,  /*!< in: index page */
 
1764
        dict_index_t*   index,  /*!< in: dictionary index of the page */
 
1765
        ulint           dn,     /*!< in: print dn first and last entries
 
1766
                                in directory */
 
1767
        ulint           rn)     /*!< in: print rn first and last records
 
1768
                                in directory */
 
1769
{
 
1770
        page_t* page = block->frame;
 
1771
 
 
1772
        page_header_print(page);
 
1773
        page_dir_print(page, dn);
 
1774
        page_print_list(block, index, rn);
 
1775
}
 
1776
#endif /* !UNIV_HOTBACKUP */
 
1777
 
 
1778
/***************************************************************//**
 
1779
The following is used to validate a record on a page. This function
 
1780
differs from rec_validate as it can also check the n_owned field and
 
1781
the heap_no field.
 
1782
@return TRUE if ok */
 
1783
UNIV_INTERN
 
1784
ibool
 
1785
page_rec_validate(
 
1786
/*==============*/
 
1787
        rec_t*          rec,    /*!< in: physical record */
 
1788
        const ulint*    offsets)/*!< in: array returned by rec_get_offsets() */
 
1789
{
 
1790
        ulint   n_owned;
 
1791
        ulint   heap_no;
 
1792
        page_t* page;
 
1793
 
 
1794
        page = page_align(rec);
 
1795
        ut_a(!page_is_comp(page) == !rec_offs_comp(offsets));
 
1796
 
 
1797
        page_rec_check(rec);
 
1798
        rec_validate(rec, offsets);
 
1799
 
 
1800
        if (page_rec_is_comp(rec)) {
 
1801
                n_owned = rec_get_n_owned_new(rec);
 
1802
                heap_no = rec_get_heap_no_new(rec);
 
1803
        } else {
 
1804
                n_owned = rec_get_n_owned_old(rec);
 
1805
                heap_no = rec_get_heap_no_old(rec);
 
1806
        }
 
1807
 
 
1808
        if (UNIV_UNLIKELY(!(n_owned <= PAGE_DIR_SLOT_MAX_N_OWNED))) {
 
1809
                fprintf(stderr,
 
1810
                        "InnoDB: Dir slot of rec %lu, n owned too big %lu\n",
 
1811
                        (ulong) page_offset(rec), (ulong) n_owned);
 
1812
                return(FALSE);
 
1813
        }
 
1814
 
 
1815
        if (UNIV_UNLIKELY(!(heap_no < page_dir_get_n_heap(page)))) {
 
1816
                fprintf(stderr,
 
1817
                        "InnoDB: Heap no of rec %lu too big %lu %lu\n",
 
1818
                        (ulong) page_offset(rec), (ulong) heap_no,
 
1819
                        (ulong) page_dir_get_n_heap(page));
 
1820
                return(FALSE);
 
1821
        }
 
1822
 
 
1823
        return(TRUE);
 
1824
}
 
1825
 
 
1826
#ifndef UNIV_HOTBACKUP
 
1827
/***************************************************************//**
 
1828
Checks that the first directory slot points to the infimum record and
 
1829
the last to the supremum. This function is intended to track if the
 
1830
bug fixed in 4.0.14 has caused corruption to users' databases. */
 
1831
UNIV_INTERN
 
1832
void
 
1833
page_check_dir(
 
1834
/*===========*/
 
1835
        const page_t*   page)   /*!< in: index page */
 
1836
{
 
1837
        ulint   n_slots;
 
1838
        ulint   infimum_offs;
 
1839
        ulint   supremum_offs;
 
1840
 
 
1841
        n_slots = page_dir_get_n_slots(page);
 
1842
        infimum_offs = mach_read_from_2(page_dir_get_nth_slot(page, 0));
 
1843
        supremum_offs = mach_read_from_2(page_dir_get_nth_slot(page,
 
1844
                                                               n_slots - 1));
 
1845
 
 
1846
        if (UNIV_UNLIKELY(!page_rec_is_infimum_low(infimum_offs))) {
 
1847
 
 
1848
                fprintf(stderr,
 
1849
                        "InnoDB: Page directory corruption:"
 
1850
                        " infimum not pointed to\n");
 
1851
                buf_page_print(page, 0);
 
1852
        }
 
1853
 
 
1854
        if (UNIV_UNLIKELY(!page_rec_is_supremum_low(supremum_offs))) {
 
1855
 
 
1856
                fprintf(stderr,
 
1857
                        "InnoDB: Page directory corruption:"
 
1858
                        " supremum not pointed to\n");
 
1859
                buf_page_print(page, 0);
 
1860
        }
 
1861
}
 
1862
#endif /* !UNIV_HOTBACKUP */
 
1863
 
 
1864
/***************************************************************//**
 
1865
This function checks the consistency of an index page when we do not
 
1866
know the index. This is also resilient so that this should never crash
 
1867
even if the page is total garbage.
 
1868
@return TRUE if ok */
 
1869
UNIV_INTERN
 
1870
ibool
 
1871
page_simple_validate_old(
 
1872
/*=====================*/
 
1873
        page_t* page)   /*!< in: old-style index page */
 
1874
{
 
1875
        page_dir_slot_t* slot;
 
1876
        ulint           slot_no;
 
1877
        ulint           n_slots;
 
1878
        rec_t*          rec;
 
1879
        byte*           rec_heap_top;
 
1880
        ulint           count;
 
1881
        ulint           own_count;
 
1882
        ibool           ret     = FALSE;
 
1883
 
 
1884
        ut_a(!page_is_comp(page));
 
1885
 
 
1886
        /* Check first that the record heap and the directory do not
 
1887
        overlap. */
 
1888
 
 
1889
        n_slots = page_dir_get_n_slots(page);
 
1890
 
 
1891
        if (UNIV_UNLIKELY(n_slots > UNIV_PAGE_SIZE / 4)) {
 
1892
                fprintf(stderr,
 
1893
                        "InnoDB: Nonsensical number %lu of page dir slots\n",
 
1894
                        (ulong) n_slots);
 
1895
 
 
1896
                goto func_exit;
 
1897
        }
 
1898
 
 
1899
        rec_heap_top = page_header_get_ptr(page, PAGE_HEAP_TOP);
 
1900
 
 
1901
        if (UNIV_UNLIKELY(rec_heap_top
 
1902
                          > page_dir_get_nth_slot(page, n_slots - 1))) {
 
1903
 
 
1904
                fprintf(stderr,
 
1905
                        "InnoDB: Record heap and dir overlap on a page,"
 
1906
                        " heap top %lu, dir %lu\n",
 
1907
                        (ulong) page_header_get_field(page, PAGE_HEAP_TOP),
 
1908
                        (ulong)
 
1909
                        page_offset(page_dir_get_nth_slot(page, n_slots - 1)));
 
1910
 
 
1911
                goto func_exit;
 
1912
        }
 
1913
 
 
1914
        /* Validate the record list in a loop checking also that it is
 
1915
        consistent with the page record directory. */
 
1916
 
 
1917
        count = 0;
 
1918
        own_count = 1;
 
1919
        slot_no = 0;
 
1920
        slot = page_dir_get_nth_slot(page, slot_no);
 
1921
 
 
1922
        rec = page_get_infimum_rec(page);
 
1923
 
 
1924
        for (;;) {
 
1925
                if (UNIV_UNLIKELY(rec > rec_heap_top)) {
 
1926
                        fprintf(stderr,
 
1927
                                "InnoDB: Record %lu is above"
 
1928
                                " rec heap top %lu\n",
 
1929
                                (ulong)(rec - page),
 
1930
                                (ulong)(rec_heap_top - page));
 
1931
 
 
1932
                        goto func_exit;
 
1933
                }
 
1934
 
 
1935
                if (UNIV_UNLIKELY(rec_get_n_owned_old(rec))) {
 
1936
                        /* This is a record pointed to by a dir slot */
 
1937
                        if (UNIV_UNLIKELY(rec_get_n_owned_old(rec)
 
1938
                                          != own_count)) {
 
1939
 
 
1940
                                fprintf(stderr,
 
1941
                                        "InnoDB: Wrong owned count %lu, %lu,"
 
1942
                                        " rec %lu\n",
 
1943
                                        (ulong) rec_get_n_owned_old(rec),
 
1944
                                        (ulong) own_count,
 
1945
                                        (ulong)(rec - page));
 
1946
 
 
1947
                                goto func_exit;
 
1948
                        }
 
1949
 
 
1950
                        if (UNIV_UNLIKELY
 
1951
                            (page_dir_slot_get_rec(slot) != rec)) {
 
1952
                                fprintf(stderr,
 
1953
                                        "InnoDB: Dir slot does not point"
 
1954
                                        " to right rec %lu\n",
 
1955
                                        (ulong)(rec - page));
 
1956
 
 
1957
                                goto func_exit;
 
1958
                        }
 
1959
 
 
1960
                        own_count = 0;
 
1961
 
 
1962
                        if (!page_rec_is_supremum(rec)) {
 
1963
                                slot_no++;
 
1964
                                slot = page_dir_get_nth_slot(page, slot_no);
 
1965
                        }
 
1966
                }
 
1967
 
 
1968
                if (page_rec_is_supremum(rec)) {
 
1969
 
 
1970
                        break;
 
1971
                }
 
1972
 
 
1973
                if (UNIV_UNLIKELY
 
1974
                    (rec_get_next_offs(rec, FALSE) < FIL_PAGE_DATA
 
1975
                     || rec_get_next_offs(rec, FALSE) >= UNIV_PAGE_SIZE)) {
 
1976
                        fprintf(stderr,
 
1977
                                "InnoDB: Next record offset"
 
1978
                                " nonsensical %lu for rec %lu\n",
 
1979
                                (ulong) rec_get_next_offs(rec, FALSE),
 
1980
                                (ulong) (rec - page));
 
1981
 
 
1982
                        goto func_exit;
 
1983
                }
 
1984
 
 
1985
                count++;
 
1986
 
 
1987
                if (UNIV_UNLIKELY(count > UNIV_PAGE_SIZE)) {
 
1988
                        fprintf(stderr,
 
1989
                                "InnoDB: Page record list appears"
 
1990
                                " to be circular %lu\n",
 
1991
                                (ulong) count);
 
1992
                        goto func_exit;
 
1993
                }
 
1994
 
 
1995
                rec = page_rec_get_next(rec);
 
1996
                own_count++;
 
1997
        }
 
1998
 
 
1999
        if (UNIV_UNLIKELY(rec_get_n_owned_old(rec) == 0)) {
 
2000
                fprintf(stderr, "InnoDB: n owned is zero in a supremum rec\n");
 
2001
 
 
2002
                goto func_exit;
 
2003
        }
 
2004
 
 
2005
        if (UNIV_UNLIKELY(slot_no != n_slots - 1)) {
 
2006
                fprintf(stderr, "InnoDB: n slots wrong %lu, %lu\n",
 
2007
                        (ulong) slot_no, (ulong) (n_slots - 1));
 
2008
                goto func_exit;
 
2009
        }
 
2010
 
 
2011
        if (UNIV_UNLIKELY(page_header_get_field(page, PAGE_N_RECS)
 
2012
                          + PAGE_HEAP_NO_USER_LOW
 
2013
                          != count + 1)) {
 
2014
                fprintf(stderr, "InnoDB: n recs wrong %lu %lu\n",
 
2015
                        (ulong) page_header_get_field(page, PAGE_N_RECS)
 
2016
                        + PAGE_HEAP_NO_USER_LOW,
 
2017
                        (ulong) (count + 1));
 
2018
 
 
2019
                goto func_exit;
 
2020
        }
 
2021
 
 
2022
        /* Check then the free list */
 
2023
        rec = page_header_get_ptr(page, PAGE_FREE);
 
2024
 
 
2025
        while (rec != NULL) {
 
2026
                if (UNIV_UNLIKELY(rec < page + FIL_PAGE_DATA
 
2027
                                  || rec >= page + UNIV_PAGE_SIZE)) {
 
2028
                        fprintf(stderr,
 
2029
                                "InnoDB: Free list record has"
 
2030
                                " a nonsensical offset %lu\n",
 
2031
                                (ulong) (rec - page));
 
2032
 
 
2033
                        goto func_exit;
 
2034
                }
 
2035
 
 
2036
                if (UNIV_UNLIKELY(rec > rec_heap_top)) {
 
2037
                        fprintf(stderr,
 
2038
                                "InnoDB: Free list record %lu"
 
2039
                                " is above rec heap top %lu\n",
 
2040
                                (ulong) (rec - page),
 
2041
                                (ulong) (rec_heap_top - page));
 
2042
 
 
2043
                        goto func_exit;
 
2044
                }
 
2045
 
 
2046
                count++;
 
2047
 
 
2048
                if (UNIV_UNLIKELY(count > UNIV_PAGE_SIZE)) {
 
2049
                        fprintf(stderr,
 
2050
                                "InnoDB: Page free list appears"
 
2051
                                " to be circular %lu\n",
 
2052
                                (ulong) count);
 
2053
                        goto func_exit;
 
2054
                }
 
2055
 
 
2056
                rec = page_rec_get_next(rec);
 
2057
        }
 
2058
 
 
2059
        if (UNIV_UNLIKELY(page_dir_get_n_heap(page) != count + 1)) {
 
2060
 
 
2061
                fprintf(stderr, "InnoDB: N heap is wrong %lu, %lu\n",
 
2062
                        (ulong) page_dir_get_n_heap(page),
 
2063
                        (ulong) (count + 1));
 
2064
 
 
2065
                goto func_exit;
 
2066
        }
 
2067
 
 
2068
        ret = TRUE;
 
2069
 
 
2070
func_exit:
 
2071
        return(ret);
 
2072
}
 
2073
 
 
2074
/***************************************************************//**
 
2075
This function checks the consistency of an index page when we do not
 
2076
know the index. This is also resilient so that this should never crash
 
2077
even if the page is total garbage.
 
2078
@return TRUE if ok */
 
2079
UNIV_INTERN
 
2080
ibool
 
2081
page_simple_validate_new(
 
2082
/*=====================*/
 
2083
        page_t* page)   /*!< in: new-style index page */
 
2084
{
 
2085
        page_dir_slot_t* slot;
 
2086
        ulint           slot_no;
 
2087
        ulint           n_slots;
 
2088
        rec_t*          rec;
 
2089
        byte*           rec_heap_top;
 
2090
        ulint           count;
 
2091
        ulint           own_count;
 
2092
        ibool           ret     = FALSE;
 
2093
 
 
2094
        ut_a(page_is_comp(page));
 
2095
 
 
2096
        /* Check first that the record heap and the directory do not
 
2097
        overlap. */
 
2098
 
 
2099
        n_slots = page_dir_get_n_slots(page);
 
2100
 
 
2101
        if (UNIV_UNLIKELY(n_slots > UNIV_PAGE_SIZE / 4)) {
 
2102
                fprintf(stderr,
 
2103
                        "InnoDB: Nonsensical number %lu"
 
2104
                        " of page dir slots\n", (ulong) n_slots);
 
2105
 
 
2106
                goto func_exit;
 
2107
        }
 
2108
 
 
2109
        rec_heap_top = page_header_get_ptr(page, PAGE_HEAP_TOP);
 
2110
 
 
2111
        if (UNIV_UNLIKELY(rec_heap_top
 
2112
                          > page_dir_get_nth_slot(page, n_slots - 1))) {
 
2113
 
 
2114
                fprintf(stderr,
 
2115
                        "InnoDB: Record heap and dir overlap on a page,"
 
2116
                        " heap top %lu, dir %lu\n",
 
2117
                        (ulong) page_header_get_field(page, PAGE_HEAP_TOP),
 
2118
                        (ulong)
 
2119
                        page_offset(page_dir_get_nth_slot(page, n_slots - 1)));
 
2120
 
 
2121
                goto func_exit;
 
2122
        }
 
2123
 
 
2124
        /* Validate the record list in a loop checking also that it is
 
2125
        consistent with the page record directory. */
 
2126
 
 
2127
        count = 0;
 
2128
        own_count = 1;
 
2129
        slot_no = 0;
 
2130
        slot = page_dir_get_nth_slot(page, slot_no);
 
2131
 
 
2132
        rec = page_get_infimum_rec(page);
 
2133
 
 
2134
        for (;;) {
 
2135
                if (UNIV_UNLIKELY(rec > rec_heap_top)) {
 
2136
                        fprintf(stderr,
 
2137
                                "InnoDB: Record %lu is above rec"
 
2138
                                " heap top %lu\n",
 
2139
                                (ulong) page_offset(rec),
 
2140
                                (ulong) page_offset(rec_heap_top));
 
2141
 
 
2142
                        goto func_exit;
 
2143
                }
 
2144
 
 
2145
                if (UNIV_UNLIKELY(rec_get_n_owned_new(rec))) {
 
2146
                        /* This is a record pointed to by a dir slot */
 
2147
                        if (UNIV_UNLIKELY(rec_get_n_owned_new(rec)
 
2148
                                          != own_count)) {
 
2149
 
 
2150
                                fprintf(stderr,
 
2151
                                        "InnoDB: Wrong owned count %lu, %lu,"
 
2152
                                        " rec %lu\n",
 
2153
                                        (ulong) rec_get_n_owned_new(rec),
 
2154
                                        (ulong) own_count,
 
2155
                                        (ulong) page_offset(rec));
 
2156
 
 
2157
                                goto func_exit;
 
2158
                        }
 
2159
 
 
2160
                        if (UNIV_UNLIKELY
 
2161
                            (page_dir_slot_get_rec(slot) != rec)) {
 
2162
                                fprintf(stderr,
 
2163
                                        "InnoDB: Dir slot does not point"
 
2164
                                        " to right rec %lu\n",
 
2165
                                        (ulong) page_offset(rec));
 
2166
 
 
2167
                                goto func_exit;
 
2168
                        }
 
2169
 
 
2170
                        own_count = 0;
 
2171
 
 
2172
                        if (!page_rec_is_supremum(rec)) {
 
2173
                                slot_no++;
 
2174
                                slot = page_dir_get_nth_slot(page, slot_no);
 
2175
                        }
 
2176
                }
 
2177
 
 
2178
                if (page_rec_is_supremum(rec)) {
 
2179
 
 
2180
                        break;
 
2181
                }
 
2182
 
 
2183
                if (UNIV_UNLIKELY
 
2184
                    (rec_get_next_offs(rec, TRUE) < FIL_PAGE_DATA
 
2185
                     || rec_get_next_offs(rec, TRUE) >= UNIV_PAGE_SIZE)) {
 
2186
                        fprintf(stderr,
 
2187
                                "InnoDB: Next record offset nonsensical %lu"
 
2188
                                " for rec %lu\n",
 
2189
                                (ulong) rec_get_next_offs(rec, TRUE),
 
2190
                                (ulong) page_offset(rec));
 
2191
 
 
2192
                        goto func_exit;
 
2193
                }
 
2194
 
 
2195
                count++;
 
2196
 
 
2197
                if (UNIV_UNLIKELY(count > UNIV_PAGE_SIZE)) {
 
2198
                        fprintf(stderr,
 
2199
                                "InnoDB: Page record list appears"
 
2200
                                " to be circular %lu\n",
 
2201
                                (ulong) count);
 
2202
                        goto func_exit;
 
2203
                }
 
2204
 
 
2205
                rec = page_rec_get_next(rec);
 
2206
                own_count++;
 
2207
        }
 
2208
 
 
2209
        if (UNIV_UNLIKELY(rec_get_n_owned_new(rec) == 0)) {
 
2210
                fprintf(stderr, "InnoDB: n owned is zero"
 
2211
                        " in a supremum rec\n");
 
2212
 
 
2213
                goto func_exit;
 
2214
        }
 
2215
 
 
2216
        if (UNIV_UNLIKELY(slot_no != n_slots - 1)) {
 
2217
                fprintf(stderr, "InnoDB: n slots wrong %lu, %lu\n",
 
2218
                        (ulong) slot_no, (ulong) (n_slots - 1));
 
2219
                goto func_exit;
 
2220
        }
 
2221
 
 
2222
        if (UNIV_UNLIKELY(page_header_get_field(page, PAGE_N_RECS)
 
2223
                          + PAGE_HEAP_NO_USER_LOW
 
2224
                          != count + 1)) {
 
2225
                fprintf(stderr, "InnoDB: n recs wrong %lu %lu\n",
 
2226
                        (ulong) page_header_get_field(page, PAGE_N_RECS)
 
2227
                        + PAGE_HEAP_NO_USER_LOW,
 
2228
                        (ulong) (count + 1));
 
2229
 
 
2230
                goto func_exit;
 
2231
        }
 
2232
 
 
2233
        /* Check then the free list */
 
2234
        rec = page_header_get_ptr(page, PAGE_FREE);
 
2235
 
 
2236
        while (rec != NULL) {
 
2237
                if (UNIV_UNLIKELY(rec < page + FIL_PAGE_DATA
 
2238
                                  || rec >= page + UNIV_PAGE_SIZE)) {
 
2239
                        fprintf(stderr,
 
2240
                                "InnoDB: Free list record has"
 
2241
                                " a nonsensical offset %lu\n",
 
2242
                                (ulong) page_offset(rec));
 
2243
 
 
2244
                        goto func_exit;
 
2245
                }
 
2246
 
 
2247
                if (UNIV_UNLIKELY(rec > rec_heap_top)) {
 
2248
                        fprintf(stderr,
 
2249
                                "InnoDB: Free list record %lu"
 
2250
                                " is above rec heap top %lu\n",
 
2251
                                (ulong) page_offset(rec),
 
2252
                                (ulong) page_offset(rec_heap_top));
 
2253
 
 
2254
                        goto func_exit;
 
2255
                }
 
2256
 
 
2257
                count++;
 
2258
 
 
2259
                if (UNIV_UNLIKELY(count > UNIV_PAGE_SIZE)) {
 
2260
                        fprintf(stderr,
 
2261
                                "InnoDB: Page free list appears"
 
2262
                                " to be circular %lu\n",
 
2263
                                (ulong) count);
 
2264
                        goto func_exit;
 
2265
                }
 
2266
 
 
2267
                rec = page_rec_get_next(rec);
 
2268
        }
 
2269
 
 
2270
        if (UNIV_UNLIKELY(page_dir_get_n_heap(page) != count + 1)) {
 
2271
 
 
2272
                fprintf(stderr, "InnoDB: N heap is wrong %lu, %lu\n",
 
2273
                        (ulong) page_dir_get_n_heap(page),
 
2274
                        (ulong) (count + 1));
 
2275
 
 
2276
                goto func_exit;
 
2277
        }
 
2278
 
 
2279
        ret = TRUE;
 
2280
 
 
2281
func_exit:
 
2282
        return(ret);
 
2283
}
 
2284
 
 
2285
/***************************************************************//**
 
2286
This function checks the consistency of an index page.
 
2287
@return TRUE if ok */
 
2288
UNIV_INTERN
 
2289
ibool
 
2290
page_validate(
 
2291
/*==========*/
 
2292
        page_t*         page,   /*!< in: index page */
 
2293
        dict_index_t*   index)  /*!< in: data dictionary index containing
 
2294
                                the page record type definition */
 
2295
{
 
2296
        page_dir_slot_t*slot;
 
2297
        mem_heap_t*     heap;
 
2298
        byte*           buf;
 
2299
        ulint           count;
 
2300
        ulint           own_count;
 
2301
        ulint           rec_own_count;
 
2302
        ulint           slot_no;
 
2303
        ulint           data_size;
 
2304
        rec_t*          rec;
 
2305
        rec_t*          old_rec         = NULL;
 
2306
        ulint           offs;
 
2307
        ulint           n_slots;
 
2308
        ibool           ret             = FALSE;
 
2309
        ulint           i;
 
2310
        ulint*          offsets         = NULL;
 
2311
        ulint*          old_offsets     = NULL;
 
2312
 
 
2313
        if (UNIV_UNLIKELY((ibool) !!page_is_comp(page)
 
2314
                          != dict_table_is_comp(index->table))) {
 
2315
                fputs("InnoDB: 'compact format' flag mismatch\n", stderr);
 
2316
                goto func_exit2;
 
2317
        }
 
2318
        if (page_is_comp(page)) {
 
2319
                if (UNIV_UNLIKELY(!page_simple_validate_new(page))) {
 
2320
                        goto func_exit2;
 
2321
                }
 
2322
        } else {
 
2323
                if (UNIV_UNLIKELY(!page_simple_validate_old(page))) {
 
2324
                        goto func_exit2;
 
2325
                }
 
2326
        }
 
2327
 
 
2328
        heap = mem_heap_create(UNIV_PAGE_SIZE + 200);
 
2329
 
 
2330
        /* The following buffer is used to check that the
 
2331
        records in the page record heap do not overlap */
 
2332
 
 
2333
        buf = mem_heap_zalloc(heap, UNIV_PAGE_SIZE);
 
2334
 
 
2335
        /* Check first that the record heap and the directory do not
 
2336
        overlap. */
 
2337
 
 
2338
        n_slots = page_dir_get_n_slots(page);
 
2339
 
 
2340
        if (UNIV_UNLIKELY(!(page_header_get_ptr(page, PAGE_HEAP_TOP)
 
2341
                            <= page_dir_get_nth_slot(page, n_slots - 1)))) {
 
2342
 
 
2343
                fprintf(stderr, 
 
2344
                        "InnoDB: Record heap and dir overlap"
 
2345
                        " on space %lu page %lu index %s, %p, %p\n",
 
2346
                        (ulong) page_get_space_id(page),
 
2347
                        (ulong) page_get_page_no(page), index->name,
 
2348
                        page_header_get_ptr(page, PAGE_HEAP_TOP),
 
2349
                        page_dir_get_nth_slot(page, n_slots - 1));
 
2350
 
 
2351
                goto func_exit;
 
2352
        }
 
2353
 
 
2354
        /* Validate the record list in a loop checking also that
 
2355
        it is consistent with the directory. */
 
2356
        count = 0;
 
2357
        data_size = 0;
 
2358
        own_count = 1;
 
2359
        slot_no = 0;
 
2360
        slot = page_dir_get_nth_slot(page, slot_no);
 
2361
 
 
2362
        rec = page_get_infimum_rec(page);
 
2363
 
 
2364
        for (;;) {
 
2365
                offsets = rec_get_offsets(rec, index, offsets,
 
2366
                                          ULINT_UNDEFINED, &heap);
 
2367
 
 
2368
                if (page_is_comp(page) && page_rec_is_user_rec(rec)
 
2369
                    && UNIV_UNLIKELY(rec_get_node_ptr_flag(rec)
 
2370
                                     == page_is_leaf(page))) {
 
2371
                        fputs("InnoDB: node_ptr flag mismatch\n", stderr);
 
2372
                        goto func_exit;
 
2373
                }
 
2374
 
 
2375
                if (UNIV_UNLIKELY(!page_rec_validate(rec, offsets))) {
 
2376
                        goto func_exit;
 
2377
                }
 
2378
 
 
2379
#ifndef UNIV_HOTBACKUP
 
2380
                /* Check that the records are in the ascending order */
 
2381
                if (UNIV_LIKELY(count >= PAGE_HEAP_NO_USER_LOW)
 
2382
                    && !page_rec_is_supremum(rec)) {
 
2383
                        if (UNIV_UNLIKELY
 
2384
                            (1 != cmp_rec_rec(rec, old_rec,
 
2385
                                              offsets, old_offsets, index))) {
 
2386
                                fprintf(stderr, 
 
2387
                                        "InnoDB: Records in wrong order"
 
2388
                                        " on space %lu page %lu index %s\n",
 
2389
                                        (ulong) page_get_space_id(page),
 
2390
                                        (ulong) page_get_page_no(page),
 
2391
                                        index->name);
 
2392
                                fputs("\nInnoDB: previous record ", stderr);
 
2393
                                rec_print_new(stderr, old_rec, old_offsets);
 
2394
                                fputs("\nInnoDB: record ", stderr);
 
2395
                                rec_print_new(stderr, rec, offsets);
 
2396
                                putc('\n', stderr);
 
2397
 
 
2398
                                goto func_exit;
 
2399
                        }
 
2400
                }
 
2401
#endif /* !UNIV_HOTBACKUP */
 
2402
 
 
2403
                if (page_rec_is_user_rec(rec)) {
 
2404
 
 
2405
                        data_size += rec_offs_size(offsets);
 
2406
                }
 
2407
 
 
2408
                offs = page_offset(rec_get_start(rec, offsets));
 
2409
 
 
2410
                for (i = rec_offs_size(offsets); i--; ) {
 
2411
                        if (UNIV_UNLIKELY(buf[offs + i])) {
 
2412
                                /* No other record may overlap this */
 
2413
 
 
2414
                                fputs("InnoDB: Record overlaps another\n",
 
2415
                                      stderr);
 
2416
                                goto func_exit;
 
2417
                        }
 
2418
 
 
2419
                        buf[offs + i] = 1;
 
2420
                }
 
2421
 
 
2422
                if (page_is_comp(page)) {
 
2423
                        rec_own_count = rec_get_n_owned_new(rec);
 
2424
                } else {
 
2425
                        rec_own_count = rec_get_n_owned_old(rec);
 
2426
                }
 
2427
 
 
2428
                if (UNIV_UNLIKELY(rec_own_count)) {
 
2429
                        /* This is a record pointed to by a dir slot */
 
2430
                        if (UNIV_UNLIKELY(rec_own_count != own_count)) {
 
2431
                                fprintf(stderr,
 
2432
                                        "InnoDB: Wrong owned count %lu, %lu\n",
 
2433
                                        (ulong) rec_own_count,
 
2434
                                        (ulong) own_count);
 
2435
                                goto func_exit;
 
2436
                        }
 
2437
 
 
2438
                        if (page_dir_slot_get_rec(slot) != rec) {
 
2439
                                fputs("InnoDB: Dir slot does not"
 
2440
                                      " point to right rec\n",
 
2441
                                      stderr);
 
2442
                                goto func_exit;
 
2443
                        }
 
2444
 
 
2445
                        page_dir_slot_check(slot);
 
2446
 
 
2447
                        own_count = 0;
 
2448
                        if (!page_rec_is_supremum(rec)) {
 
2449
                                slot_no++;
 
2450
                                slot = page_dir_get_nth_slot(page, slot_no);
 
2451
                        }
 
2452
                }
 
2453
 
 
2454
                if (page_rec_is_supremum(rec)) {
 
2455
                        break;
 
2456
                }
 
2457
 
 
2458
                count++;
 
2459
                own_count++;
 
2460
                old_rec = rec;
 
2461
                rec = page_rec_get_next(rec);
 
2462
 
 
2463
                /* set old_offsets to offsets; recycle offsets */
 
2464
                {
 
2465
                        ulint* offs = old_offsets;
 
2466
                        old_offsets = offsets;
 
2467
                        offsets = offs;
 
2468
                }
 
2469
        }
 
2470
 
 
2471
        if (page_is_comp(page)) {
 
2472
                if (UNIV_UNLIKELY(rec_get_n_owned_new(rec) == 0)) {
 
2473
 
 
2474
                        goto n_owned_zero;
 
2475
                }
 
2476
        } else if (UNIV_UNLIKELY(rec_get_n_owned_old(rec) == 0)) {
 
2477
n_owned_zero:
 
2478
                fputs("InnoDB: n owned is zero\n", stderr);
 
2479
                goto func_exit;
 
2480
        }
 
2481
 
 
2482
        if (UNIV_UNLIKELY(slot_no != n_slots - 1)) {
 
2483
                fprintf(stderr, "InnoDB: n slots wrong %lu %lu\n",
 
2484
                        (ulong) slot_no, (ulong) (n_slots - 1));
 
2485
                goto func_exit;
 
2486
        }
 
2487
 
 
2488
        if (UNIV_UNLIKELY(page_header_get_field(page, PAGE_N_RECS)
 
2489
                          + PAGE_HEAP_NO_USER_LOW
 
2490
                          != count + 1)) {
 
2491
                fprintf(stderr, "InnoDB: n recs wrong %lu %lu\n",
 
2492
                        (ulong) page_header_get_field(page, PAGE_N_RECS)
 
2493
                        + PAGE_HEAP_NO_USER_LOW,
 
2494
                        (ulong) (count + 1));
 
2495
                goto func_exit;
 
2496
        }
 
2497
 
 
2498
        if (UNIV_UNLIKELY(data_size != page_get_data_size(page))) {
 
2499
                fprintf(stderr,
 
2500
                        "InnoDB: Summed data size %lu, returned by func %lu\n",
 
2501
                        (ulong) data_size, (ulong) page_get_data_size(page));
 
2502
                goto func_exit;
 
2503
        }
 
2504
 
 
2505
        /* Check then the free list */
 
2506
        rec = page_header_get_ptr(page, PAGE_FREE);
 
2507
 
 
2508
        while (rec != NULL) {
 
2509
                offsets = rec_get_offsets(rec, index, offsets,
 
2510
                                          ULINT_UNDEFINED, &heap);
 
2511
                if (UNIV_UNLIKELY(!page_rec_validate(rec, offsets))) {
 
2512
 
 
2513
                        goto func_exit;
 
2514
                }
 
2515
 
 
2516
                count++;
 
2517
                offs = page_offset(rec_get_start(rec, offsets));
 
2518
 
 
2519
                for (i = rec_offs_size(offsets); i--; ) {
 
2520
 
 
2521
                        if (UNIV_UNLIKELY(buf[offs + i])) {
 
2522
                                fputs("InnoDB: Record overlaps another"
 
2523
                                      " in free list\n", stderr);
 
2524
                                goto func_exit;
 
2525
                        }
 
2526
 
 
2527
                        buf[offs + i] = 1;
 
2528
                }
 
2529
 
 
2530
                rec = page_rec_get_next(rec);
 
2531
        }
 
2532
 
 
2533
        if (UNIV_UNLIKELY(page_dir_get_n_heap(page) != count + 1)) {
 
2534
                fprintf(stderr, "InnoDB: N heap is wrong %lu %lu\n",
 
2535
                        (ulong) page_dir_get_n_heap(page),
 
2536
                        (ulong) count + 1);
 
2537
                goto func_exit;
 
2538
        }
 
2539
 
 
2540
        ret = TRUE;
 
2541
 
 
2542
func_exit:
 
2543
        mem_heap_free(heap);
 
2544
 
 
2545
        if (UNIV_UNLIKELY(ret == FALSE)) {
 
2546
func_exit2:
 
2547
                fprintf(stderr, 
 
2548
                        "InnoDB: Apparent corruption"
 
2549
                        " in space %lu page %lu index %s\n",
 
2550
                        (ulong) page_get_space_id(page),
 
2551
                        (ulong) page_get_page_no(page),
 
2552
                        index->name);
 
2553
                buf_page_print(page, 0);
 
2554
        }
 
2555
 
 
2556
        return(ret);
 
2557
}
 
2558
 
 
2559
#ifndef UNIV_HOTBACKUP
 
2560
/***************************************************************//**
 
2561
Looks in the page record list for a record with the given heap number.
 
2562
@return record, NULL if not found */
 
2563
UNIV_INTERN
 
2564
const rec_t*
 
2565
page_find_rec_with_heap_no(
 
2566
/*=======================*/
 
2567
        const page_t*   page,   /*!< in: index page */
 
2568
        ulint           heap_no)/*!< in: heap number */
 
2569
{
 
2570
        const rec_t*    rec;
 
2571
 
 
2572
        if (page_is_comp(page)) {
 
2573
                rec = page + PAGE_NEW_INFIMUM;
 
2574
 
 
2575
                for(;;) {
 
2576
                        ulint   rec_heap_no = rec_get_heap_no_new(rec);
 
2577
 
 
2578
                        if (rec_heap_no == heap_no) {
 
2579
 
 
2580
                                return(rec);
 
2581
                        } else if (rec_heap_no == PAGE_HEAP_NO_SUPREMUM) {
 
2582
 
 
2583
                                return(NULL);
 
2584
                        }
 
2585
 
 
2586
                        rec = page + rec_get_next_offs(rec, TRUE);
 
2587
                }
 
2588
        } else {
 
2589
                rec = page + PAGE_OLD_INFIMUM;
 
2590
 
 
2591
                for (;;) {
 
2592
                        ulint   rec_heap_no = rec_get_heap_no_old(rec);
 
2593
 
 
2594
                        if (rec_heap_no == heap_no) {
 
2595
 
 
2596
                                return(rec);
 
2597
                        } else if (rec_heap_no == PAGE_HEAP_NO_SUPREMUM) {
 
2598
 
 
2599
                                return(NULL);
 
2600
                        }
 
2601
 
 
2602
                        rec = page + rec_get_next_offs(rec, FALSE);
 
2603
                }
 
2604
        }
 
2605
}
 
2606
#endif /* !UNIV_HOTBACKUP */