← Back to branch summary

~jlukas79/+junk/mysql-server

« back to all changes in this revision

Viewing changes to storage/maria/unittest/ma_test_loghandler-t.c

manual merge 6.0-main --> 6.0-bka-review

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/maria/unittest/ma_test_loghandler-t.c
 
1
/* Copyright (C) 2006-2008 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
#include "../maria_def.h"
 
17
#include <stdio.h>
 
18
#include <errno.h>
 
19
#include <tap.h>
 
20
#include "../trnman.h"
 
21
 
 
22
extern my_bool maria_log_remove();
 
23
extern void example_loghandler_init();
 
24
 
 
25
#ifndef DBUG_OFF
 
26
static const char *default_dbug_option;
 
27
#endif
 
28
static TRN *trn= &dummy_transaction_object;
 
29
 
 
30
#define PCACHE_SIZE (1024*1024*10)
 
31
 
 
32
#define LONG_BUFFER_SIZE (100 * 1024)
 
33
 
 
34
#ifdef LONG_LOG_TEST
 
35
#define LOG_FLAGS 0
 
36
#define LOG_FILE_SIZE (1024L*1024L*8)
 
37
#define ITERATIONS (1600*4)
 
38
 
 
39
#else
 
40
#undef SKIP_BIG_TESTS
 
41
#define SKIP_BIG_TESTS(X) /* no-op */
 
42
#define LOG_FLAGS (TRANSLOG_SECTOR_PROTECTION | TRANSLOG_PAGE_CRC)
 
43
#define LOG_FILE_SIZE (1024L*1024L*8L)
 
44
#define ITERATIONS 1600
 
45
#endif
 
46
 
 
47
/*
 
48
#define LOG_FLAGS 0
 
49
#define LOG_FILE_SIZE 1024L*1024L*1024L
 
50
#define ITERATIONS 181000
 
51
*/
 
52
 
 
53
/*
 
54
#define LOG_FLAGS 0
 
55
#define LOG_FILE_SIZE 1024L*1024L*3L
 
56
#define ITERATIONS 1600
 
57
*/
 
58
 
 
59
/*
 
60
#define LOG_FLAGS 0
 
61
#define LOG_FILE_SIZE 1024L*1024L*100L
 
62
#define ITERATIONS 65000
 
63
*/
 
64
 
 
65
/*
 
66
  Generate random value in the range (0,LONG_BUFFER_SIZE)
 
67
*/
 
68
static uint32 rand_buffer_size()
 
69
{
 
70
  return (uint32)((ulonglong)rand()*(LONG_BUFFER_SIZE + 1)/RAND_MAX);
 
71
}
 
72
 
 
73
/*
 
74
  Check that the buffer filled correctly
 
75
 
 
76
  SYNOPSIS
 
77
    check_content()
 
78
    ptr                  Pointer to the buffer
 
79
    length               length of the buffer
 
80
 
 
81
  RETURN
 
82
    0 - OK
 
83
    1 - Error
 
84
*/
 
85
 
 
86
 
 
87
static my_bool check_content(uchar *ptr, ulong length)
 
88
{
 
89
  ulong i;
 
90
  uchar buff[2];
 
91
  for (i= 0; i < length; i++)
 
92
  {
 
93
    if (i % 2 == 0)
 
94
      int2store(buff, i >> 1);
 
95
    if (ptr[i] != buff[i % 2])
 
96
    {
 
97
      fprintf(stderr, "Byte # %lu is %x instead of %x",
 
98
              i, (uint) ptr[i], (uint) buff[i % 2]);
 
99
      return 1;
 
100
    }
 
101
  }
 
102
  return 0;
 
103
}
 
104
 
 
105
 
 
106
/*
 
107
  Report OK for read operation
 
108
 
 
109
  SYNOPSIS
 
110
    read_ok()
 
111
    rec                  the record header
 
112
*/
 
113
 
 
114
void read_ok(TRANSLOG_HEADER_BUFFER *rec)
 
115
{
 
116
  char buff[80];
 
117
  my_snprintf(buff, sizeof(buff), "read record type: %u  LSN: (%lu,0x%lx)",
 
118
           rec->type, LSN_IN_PARTS(rec->lsn));
 
119
  ok(1, buff);
 
120
}
 
121
 
 
122
/*
 
123
  Read whole record content, and check content (put with offset)
 
124
 
 
125
  SYNOPSIS
 
126
    read_and_check_content()
 
127
    rec                  The record header buffer
 
128
    buffer               The buffer to read the record in
 
129
    skip                 Skip this number of bytes ot the record content
 
130
 
 
131
  RETURN
 
132
    0 - OK
 
133
    1 - Error
 
134
*/
 
135
 
 
136
static my_bool read_and_check_content(TRANSLOG_HEADER_BUFFER *rec,
 
137
                                      uchar *buffer, uint skip)
 
138
{
 
139
  DBUG_ASSERT(rec->record_length < LONG_BUFFER_SIZE * 2 + 7 * 2 + 2);
 
140
  if (translog_read_record(rec->lsn, 0, rec->record_length, buffer, NULL) !=
 
141
      rec->record_length)
 
142
      return 1;
 
143
  return check_content(buffer + skip, rec->record_length - skip);
 
144
}
 
145
 
 
146
 
 
147
int main(int argc __attribute__((unused)), char *argv[])
 
148
{
 
149
  uint32 i;
 
150
  uint32 rec_len;
 
151
  uint pagen;
 
152
  uchar long_tr_id[6];
 
153
  uchar lsn_buff[23]=
 
154
  {
 
155
    0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA,
 
156
    0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA,
 
157
    0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55
 
158
  };
 
159
  uchar long_buffer[LONG_BUFFER_SIZE * 2 + LSN_STORE_SIZE * 2 + 2];
 
160
  PAGECACHE pagecache;
 
161
  LSN lsn, lsn_base, first_lsn;
 
162
  TRANSLOG_HEADER_BUFFER rec;
 
163
  LEX_CUSTRING parts[TRANSLOG_INTERNAL_PARTS + 3];
 
164
  struct st_translog_scanner_data scanner;
 
165
  int rc;
 
166
 
 
167
  MY_INIT(argv[0]);
 
168
 
 
169
  if (my_set_max_open_files(100) < 100)
 
170
  {
 
171
    fprintf(stderr, "can't allocate 100 file descriptors\n");
 
172
    exit(1);
 
173
  }
 
174
  bzero(&pagecache, sizeof(pagecache));
 
175
  maria_data_root= (char *)".";
 
176
  if (maria_log_remove())
 
177
    exit(1);
 
178
 
 
179
  for (i= 0; i < (LONG_BUFFER_SIZE + LSN_STORE_SIZE * 2 + 2); i+= 2)
 
180
  {
 
181
    int2store(long_buffer + i, (i >> 1));
 
182
    /* long_buffer[i]= (i & 0xFF); */
 
183
  }
 
184
 
 
185
  bzero(long_tr_id, 6);
 
186
#ifndef DBUG_OFF
 
187
#if defined(__WIN__)
 
188
  default_dbug_option= "d:t:i:O,\\ma_test_loghandler.trace";
 
189
#else
 
190
  default_dbug_option= "d:t:i:o,/tmp/ma_test_loghandler.trace";
 
191
#endif
 
192
  if (argc > 1)
 
193
  {
 
194
    DBUG_SET(default_dbug_option);
 
195
    DBUG_SET_INITIAL(default_dbug_option);
 
196
  }
 
197
#endif
 
198
 
 
199
  if (ma_control_file_open(TRUE, TRUE))
 
200
  {
 
201
    fprintf(stderr, "Can't init control file (%d)\n", errno);
 
202
    exit(1);
 
203
  }
 
204
  if ((pagen= init_pagecache(&pagecache, PCACHE_SIZE, 0, 0,
 
205
                             TRANSLOG_PAGE_SIZE, 0)) == 0)
 
206
  {
 
207
    fprintf(stderr, "Got error: init_pagecache() (errno: %d)\n", errno);
 
208
    exit(1);
 
209
  }
 
210
  if (translog_init_with_table(".", LOG_FILE_SIZE, 50112, 0, &pagecache,
 
211
                               LOG_FLAGS, 0, &translog_example_table_init,
 
212
                               0))
 
213
  {
 
214
    fprintf(stderr, "Can't init loghandler (%d)\n", errno);
 
215
    exit(1);
 
216
  }
 
217
  /* Suppressing of automatic record writing */
 
218
  trn->first_undo_lsn|= TRANSACTION_LOGGED_LONG_ID;
 
219
 
 
220
  plan(((ITERATIONS - 1) * 4 + 1)*2 + ITERATIONS - 1 + 1);
 
221
 
 
222
  SKIP_BIG_TESTS(((ITERATIONS - 1) * 4 + 1)*2 + ITERATIONS - 1 + 1)
 
223
  {
 
224
 
 
225
  srand(122334817L);
 
226
 
 
227
  long_tr_id[5]= 0xff;
 
228
 
 
229
  int4store(long_tr_id, 0);
 
230
  parts[TRANSLOG_INTERNAL_PARTS + 0].str= (char*)long_tr_id;
 
231
  parts[TRANSLOG_INTERNAL_PARTS + 0].length= 6;
 
232
  trn->short_id= 0;
 
233
  trn->first_undo_lsn= TRANSACTION_LOGGED_LONG_ID;
 
234
  if (translog_write_record(&lsn,
 
235
                            LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
 
236
                            trn, NULL, 6, TRANSLOG_INTERNAL_PARTS + 1,
 
237
                            parts, NULL, NULL))
 
238
  {
 
239
    fprintf(stderr, "Can't write record #%lu\n", (ulong) 0);
 
240
    translog_destroy();
 
241
    ok(0, "write LOGREC_FIXED_RECORD_0LSN_EXAMPLE");
 
242
    exit(1);
 
243
  }
 
244
  ok(1, "write LOGREC_FIXED_RECORD_0LSN_EXAMPLE");
 
245
  lsn_base= first_lsn= lsn;
 
246
 
 
247
  for (i= 1; i < ITERATIONS; i++)
 
248
  {
 
249
    trn->short_id= i % 0xFFFF;
 
250
    if (i % 2)
 
251
    {
 
252
      lsn_store(lsn_buff, lsn_base);
 
253
      parts[TRANSLOG_INTERNAL_PARTS + 0].str= (char*)lsn_buff;
 
254
      parts[TRANSLOG_INTERNAL_PARTS + 0].length= LSN_STORE_SIZE;
 
255
      /* check auto-count feature */
 
256
      parts[TRANSLOG_INTERNAL_PARTS + 1].str= NULL;
 
257
      parts[TRANSLOG_INTERNAL_PARTS + 1].length= 0;
 
258
      if (translog_write_record(&lsn, LOGREC_FIXED_RECORD_1LSN_EXAMPLE, trn,
 
259
                                NULL, LSN_STORE_SIZE, 0, parts, NULL, NULL))
 
260
      {
 
261
        fprintf(stderr, "1 Can't write reference defore record #%lu\n",
 
262
                (ulong) i);
 
263
        translog_destroy();
 
264
        ok(0, "write LOGREC_FIXED_RECORD_1LSN_EXAMPLE");
 
265
        exit(1);
 
266
      }
 
267
      ok(1, "write LOGREC_FIXED_RECORD_1LSN_EXAMPLE");
 
268
      lsn_store(lsn_buff, lsn_base);
 
269
      if ((rec_len= rand_buffer_size()) < 12)
 
270
        rec_len= 12;
 
271
      parts[TRANSLOG_INTERNAL_PARTS + 0].str= (char*)lsn_buff;
 
272
      parts[TRANSLOG_INTERNAL_PARTS + 0].length= LSN_STORE_SIZE;
 
273
      parts[TRANSLOG_INTERNAL_PARTS + 1].str= (char*)long_buffer;
 
274
      parts[TRANSLOG_INTERNAL_PARTS + 1].length= rec_len;
 
275
      /* check record length auto-counting */
 
276
      if (translog_write_record(&lsn,
 
277
                                LOGREC_VARIABLE_RECORD_1LSN_EXAMPLE,
 
278
                                trn, NULL, 0, TRANSLOG_INTERNAL_PARTS + 2,
 
279
                                parts, NULL, NULL))
 
280
      {
 
281
        fprintf(stderr, "1 Can't write var reference defore record #%lu\n",
 
282
                (ulong) i);
 
283
        translog_destroy();
 
284
        ok(0, "write LOGREC_VARIABLE_RECORD_1LSN_EXAMPLE");
 
285
        exit(1);
 
286
      }
 
287
      ok(1, "write LOGREC_VARIABLE_RECORD_1LSN_EXAMPLE");
 
288
    }
 
289
    else
 
290
    {
 
291
      lsn_store(lsn_buff, lsn_base);
 
292
      lsn_store(lsn_buff + LSN_STORE_SIZE, first_lsn);
 
293
      parts[TRANSLOG_INTERNAL_PARTS + 0].str= (char*)lsn_buff;
 
294
      parts[TRANSLOG_INTERNAL_PARTS + 0].length= 23;
 
295
      if (translog_write_record(&lsn,
 
296
                                LOGREC_FIXED_RECORD_2LSN_EXAMPLE,
 
297
                                trn, NULL, 23, TRANSLOG_INTERNAL_PARTS + 1,
 
298
                                parts, NULL, NULL))
 
299
      {
 
300
        fprintf(stderr, "0 Can't write reference defore record #%lu\n",
 
301
                (ulong) i);
 
302
        translog_destroy();
 
303
        ok(0, "write LOGREC_FIXED_RECORD_2LSN_EXAMPLE");
 
304
        exit(1);
 
305
      }
 
306
      ok(1, "write LOGREC_FIXED_RECORD_2LSN_EXAMPLE");
 
307
      lsn_store(lsn_buff, lsn_base);
 
308
      lsn_store(lsn_buff + LSN_STORE_SIZE, first_lsn);
 
309
      if ((rec_len= rand_buffer_size()) < 19)
 
310
        rec_len= 19;
 
311
      parts[TRANSLOG_INTERNAL_PARTS + 0].str= (char*)lsn_buff;
 
312
      parts[TRANSLOG_INTERNAL_PARTS + 0].length= 14;
 
313
      parts[TRANSLOG_INTERNAL_PARTS + 1].str= (char*)long_buffer;
 
314
      parts[TRANSLOG_INTERNAL_PARTS + 1].length= rec_len;
 
315
      if (translog_write_record(&lsn,
 
316
                                LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE,
 
317
                                trn, NULL, 14 + rec_len,
 
318
                                TRANSLOG_INTERNAL_PARTS + 2, parts, NULL,
 
319
                                NULL))
 
320
      {
 
321
        fprintf(stderr, "0 Can't write var reference defore record #%lu\n",
 
322
                (ulong) i);
 
323
        translog_destroy();
 
324
        ok(0, "write LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE");
 
325
        exit(1);
 
326
      }
 
327
      ok(1, "write LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE");
 
328
    }
 
329
    int4store(long_tr_id, i);
 
330
    parts[TRANSLOG_INTERNAL_PARTS + 0].str= (char*)long_tr_id;
 
331
    parts[TRANSLOG_INTERNAL_PARTS + 0].length= 6;
 
332
    if (translog_write_record(&lsn,
 
333
                              LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
 
334
                              trn, NULL, 6,
 
335
                              TRANSLOG_INTERNAL_PARTS + 1,
 
336
                              parts, NULL, NULL))
 
337
    {
 
338
      fprintf(stderr, "Can't write record #%lu\n", (ulong) i);
 
339
      translog_destroy();
 
340
      ok(0, "write LOGREC_FIXED_RECORD_0LSN_EXAMPLE");
 
341
      exit(1);
 
342
    }
 
343
    ok(1, "write LOGREC_FIXED_RECORD_0LSN_EXAMPLE");
 
344
 
 
345
    lsn_base= lsn;
 
346
 
 
347
    if ((rec_len= rand_buffer_size()) < 9)
 
348
      rec_len= 9;
 
349
    parts[TRANSLOG_INTERNAL_PARTS + 0].str= (char*)long_buffer;
 
350
    parts[TRANSLOG_INTERNAL_PARTS + 0].length= rec_len;
 
351
    if (translog_write_record(&lsn,
 
352
                              LOGREC_VARIABLE_RECORD_0LSN_EXAMPLE,
 
353
                              trn, NULL, rec_len,
 
354
                              TRANSLOG_INTERNAL_PARTS + 1,
 
355
                              parts, NULL, NULL))
 
356
    {
 
357
      fprintf(stderr, "Can't write variable record #%lu\n", (ulong) i);
 
358
      translog_destroy();
 
359
      ok(0, "write LOGREC_VARIABLE_RECORD_0LSN_EXAMPLE");
 
360
      exit(1);
 
361
    }
 
362
    ok(1, "write LOGREC_VARIABLE_RECORD_0LSN_EXAMPLE");
 
363
    if (translog_flush(lsn))
 
364
    {
 
365
      fprintf(stderr, "Can't flush #%lu\n", (ulong) i);
 
366
      translog_destroy();
 
367
      ok(0, "flush");
 
368
      exit(1);
 
369
    }
 
370
    ok(1, "flush");
 
371
  }
 
372
 
 
373
  if (translog_flush(translog_get_horizon()))
 
374
  {
 
375
    fprintf(stderr, "Can't flush up to horizon\n");
 
376
    translog_destroy();
 
377
    ok(0, "flush");
 
378
    exit(1);
 
379
  }
 
380
  ok(1, "flush");
 
381
 
 
382
  srand(122334817L);
 
383
 
 
384
  rc= 1;
 
385
 
 
386
  {
 
387
    int len= translog_read_record_header(first_lsn, &rec);
 
388
    if (len == RECHEADER_READ_ERROR)
 
389
    {
 
390
      fprintf(stderr, "translog_read_record_header failed (%d)\n", errno);
 
391
      goto err;
 
392
    }
 
393
    if (rec.type !=LOGREC_FIXED_RECORD_0LSN_EXAMPLE || rec.short_trid != 0 ||
 
394
        rec.record_length != 6 || uint4korr(rec.header) != 0 ||
 
395
        ((uchar)rec.header[4]) != 0 || ((uchar)rec.header[5]) != 0xFF ||
 
396
        first_lsn != rec.lsn)
 
397
    {
 
398
      fprintf(stderr, "Incorrect LOGREC_FIXED_RECORD_0LSN_EXAMPLE "
 
399
              "data read(0)\n"
 
400
              "type %u, strid %u, len %u, i: %u, 4: %u 5: %u, "
 
401
              "lsn(%lu,0x%lx)\n",
 
402
              (uint) rec.type, (uint) rec.short_trid, (uint) rec.record_length,
 
403
              (uint) uint4korr(rec.header), (uint) rec.header[4],
 
404
              (uint) rec.header[5],
 
405
              LSN_IN_PARTS(rec.lsn));
 
406
      goto err;
 
407
    }
 
408
    read_ok(&rec);
 
409
    translog_free_record_header(&rec);
 
410
    lsn= first_lsn;
 
411
    if (translog_scanner_init(first_lsn, 1, &scanner, 0))
 
412
    {
 
413
      fprintf(stderr, "scanner init failed\n");
 
414
      goto err;
 
415
    }
 
416
    for (i= 1;; i++)
 
417
    {
 
418
      len= translog_read_next_record_header(&scanner, &rec);
 
419
      if (len == RECHEADER_READ_ERROR)
 
420
      {
 
421
        fprintf(stderr, "1-%d translog_read_next_record_header failed (%d)\n",
 
422
                i, errno);
 
423
        goto err;
 
424
      }
 
425
      if (len == RECHEADER_READ_EOF)
 
426
      {
 
427
        if (i != ITERATIONS)
 
428
        {
 
429
          fprintf(stderr, "EOL met at iteration %u instead of %u\n",
 
430
                  i, ITERATIONS);
 
431
          goto err;
 
432
        }
 
433
        break;
 
434
      }
 
435
      if (i % 2)
 
436
      {
 
437
        LSN ref;
 
438
        ref= lsn_korr(rec.header);
 
439
        if (rec.type != LOGREC_FIXED_RECORD_1LSN_EXAMPLE ||
 
440
            rec.short_trid != (i % 0xFFFF) ||
 
441
            rec.record_length != 7 || ref != lsn)
 
442
        {
 
443
          fprintf(stderr, "Incorrect LOGREC_FIXED_RECORD_1LSN_EXAMPLE "
 
444
                  "data read(%d) "
 
445
                  "type: %u  strid: %u  len: %u"
 
446
                  "ref: (%lu,0x%lx)  (%lu,0x%lx)  "
 
447
                  "lsn(%lu,0x%lx)\n",
 
448
                  i, (uint) rec.type, (uint) rec.short_trid,
 
449
                  (uint) rec.record_length,
 
450
                  LSN_IN_PARTS(ref), LSN_IN_PARTS(lsn),
 
451
                  LSN_IN_PARTS(rec.lsn));
 
452
          goto err;
 
453
        }
 
454
      }
 
455
      else
 
456
      {
 
457
        LSN ref1, ref2;
 
458
        ref1= lsn_korr(rec.header);
 
459
        ref2= lsn_korr(rec.header + LSN_STORE_SIZE);
 
460
        if (rec.type != LOGREC_FIXED_RECORD_2LSN_EXAMPLE ||
 
461
            rec.short_trid != (i % 0xFFFF) ||
 
462
            rec.record_length != 23 ||
 
463
            ref1 != lsn ||
 
464
            ref2 != first_lsn ||
 
465
            ((uchar)rec.header[22]) != 0x55 ||
 
466
            ((uchar)rec.header[21]) != 0xAA ||
 
467
            ((uchar)rec.header[20]) != 0x55 ||
 
468
            ((uchar)rec.header[19]) != 0xAA ||
 
469
            ((uchar)rec.header[18]) != 0x55 ||
 
470
            ((uchar)rec.header[17]) != 0xAA ||
 
471
            ((uchar)rec.header[16]) != 0x55 ||
 
472
            ((uchar)rec.header[15]) != 0xAA ||
 
473
            ((uchar)rec.header[14]) != 0x55)
 
474
        {
 
475
          fprintf(stderr, "Incorrect LOGREC_FIXED_RECORD_2LSN_EXAMPLE "
 
476
                  "data read(%d) "
 
477
                  "type %u, strid %u, len %u, ref1(%lu,0x%lx), "
 
478
                  "ref2(%lu,0x%lx) %x%x%x%x%x%x%x%x%x "
 
479
                  "lsn(%lu,0x%lx)\n",
 
480
                  i, (uint) rec.type, (uint) rec.short_trid,
 
481
                  (uint) rec.record_length,
 
482
                  LSN_IN_PARTS(ref1), LSN_IN_PARTS(ref2),
 
483
                  (uint) rec.header[14], (uint) rec.header[15],
 
484
                  (uint) rec.header[16], (uint) rec.header[17],
 
485
                  (uint) rec.header[18], (uint) rec.header[19],
 
486
                  (uint) rec.header[20], (uint) rec.header[21],
 
487
                  (uint) rec.header[22],
 
488
                  LSN_IN_PARTS(rec.lsn));
 
489
          goto err;
 
490
        }
 
491
      }
 
492
      read_ok(&rec);
 
493
      translog_free_record_header(&rec);
 
494
 
 
495
      len= translog_read_next_record_header(&scanner, &rec);
 
496
      if (len == RECHEADER_READ_ERROR)
 
497
      {
 
498
        fprintf(stderr, "1-%d translog_read_next_record_header (var) "
 
499
                "failed (%d)\n", i, errno);
 
500
        goto err;
 
501
      }
 
502
      if (len == RECHEADER_READ_EOF)
 
503
      {
 
504
        fprintf(stderr, "EOL met at the middle of iteration (first var) %u "
 
505
                "instead of beginning of %u\n", i, ITERATIONS);
 
506
        goto err;
 
507
      }
 
508
      if (i % 2)
 
509
      {
 
510
        LSN ref;
 
511
        ref= lsn_korr(rec.header);
 
512
        if ((rec_len= rand_buffer_size()) < 12)
 
513
          rec_len= 12;
 
514
        if (rec.type != LOGREC_VARIABLE_RECORD_1LSN_EXAMPLE ||
 
515
            rec.short_trid != (i % 0xFFFF) ||
 
516
            rec.record_length != rec_len + LSN_STORE_SIZE ||
 
517
            len != 12 || ref != lsn ||
 
518
            check_content(rec.header + LSN_STORE_SIZE, len - LSN_STORE_SIZE))
 
519
        {
 
520
          fprintf(stderr, "Incorrect LOGREC_VARIABLE_RECORD_1LSN_EXAMPLE "
 
521
                  "data read(%d)"
 
522
                  "type %u (%d), strid %u (%d), len %lu, %lu + 7 (%d), "
 
523
                  "hdr len: %u (%d), "
 
524
                  "ref(%lu,0x%lx), lsn(%lu,0x%lx) (%d), content: %d\n",
 
525
                  i, (uint) rec.type,
 
526
                  rec.type != LOGREC_VARIABLE_RECORD_1LSN_EXAMPLE,
 
527
                  (uint) rec.short_trid,
 
528
                  rec.short_trid != (i % 0xFFFF),
 
529
                  (ulong) rec.record_length, (ulong) rec_len,
 
530
                  rec.record_length != rec_len + LSN_STORE_SIZE,
 
531
                  (uint) len,
 
532
                  len != 12,
 
533
                  LSN_IN_PARTS(ref), LSN_IN_PARTS(rec.lsn),
 
534
                  (len != 12 || ref != lsn),
 
535
                  check_content(rec.header + LSN_STORE_SIZE,
 
536
                                len - LSN_STORE_SIZE));
 
537
          goto err;
 
538
        }
 
539
        if (read_and_check_content(&rec, long_buffer, LSN_STORE_SIZE))
 
540
        {
 
541
          fprintf(stderr,
 
542
                  "Incorrect LOGREC_VARIABLE_RECORD_1LSN_EXAMPLE "
 
543
                  "in whole rec read lsn(%lu,0x%lx)\n",
 
544
                  LSN_IN_PARTS(rec.lsn));
 
545
          goto err;
 
546
        }
 
547
      }
 
548
      else
 
549
      {
 
550
        LSN ref1, ref2;
 
551
        ref1= lsn_korr(rec.header);
 
552
        ref2= lsn_korr(rec.header + LSN_STORE_SIZE);
 
553
        if ((rec_len= rand_buffer_size()) < 19)
 
554
          rec_len= 19;
 
555
        if (rec.type != LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE ||
 
556
            rec.short_trid != (i % 0xFFFF) ||
 
557
            rec.record_length != rec_len + LSN_STORE_SIZE * 2 ||
 
558
            len != 19 ||
 
559
            ref1 != lsn ||
 
560
            ref2 != first_lsn ||
 
561
            check_content(rec.header + LSN_STORE_SIZE * 2,
 
562
                          len - LSN_STORE_SIZE * 2))
 
563
        {
 
564
          fprintf(stderr, "Incorrect LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE "
 
565
                  "data read(%d) "
 
566
                  "type %u, strid %u, len %lu != %lu + 14, hdr len: %d, "
 
567
                  "ref1(%lu,0x%lx), ref2(%lu,0x%lx), "
 
568
                  "lsn(%lu,0x%lx)\n",
 
569
                  i, (uint) rec.type, (uint) rec.short_trid,
 
570
                  (ulong) rec.record_length, (ulong) rec_len,
 
571
                  len, LSN_IN_PARTS(ref1), LSN_IN_PARTS(ref2),
 
572
                  LSN_IN_PARTS(rec.lsn));
 
573
          goto err;
 
574
        }
 
575
        if (read_and_check_content(&rec, long_buffer, LSN_STORE_SIZE * 2))
 
576
        {
 
577
          fprintf(stderr,
 
578
                  "Incorrect LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE "
 
579
                  "in whole rec read lsn(%lu,0x%lx)\n",
 
580
                  LSN_IN_PARTS(rec.lsn));
 
581
          goto err;
 
582
        }
 
583
      }
 
584
      read_ok(&rec);
 
585
      translog_free_record_header(&rec);
 
586
 
 
587
      len= translog_read_next_record_header(&scanner, &rec);
 
588
      if (len == RECHEADER_READ_ERROR)
 
589
      {
 
590
        fprintf(stderr, "1-%d translog_read_next_record_header failed (%d)\n",
 
591
                i, errno);
 
592
        goto err;
 
593
      }
 
594
      if (len == RECHEADER_READ_EOF)
 
595
      {
 
596
        fprintf(stderr, "EOL met at the middle of iteration %u "
 
597
                "instead of beginning of %u\n", i, ITERATIONS);
 
598
        goto err;
 
599
      }
 
600
      if (rec.type != LOGREC_FIXED_RECORD_0LSN_EXAMPLE ||
 
601
          rec.short_trid != (i % 0xFFFF) ||
 
602
          rec.record_length != 6 || uint4korr(rec.header) != i ||
 
603
          ((uchar)rec.header[4]) != 0 || ((uchar)rec.header[5]) != 0xFF)
 
604
      {
 
605
        fprintf(stderr, "Incorrect LOGREC_FIXED_RECORD_0LSN_EXAMPLE "
 
606
                "data read(%d)\n"
 
607
                "type %u, strid %u, len %u, i: %u, 4: %u 5: %u "
 
608
                "lsn(%lu,0x%lx)\n",
 
609
                i, (uint) rec.type, (uint) rec.short_trid,
 
610
                (uint) rec.record_length,
 
611
                (uint) uint4korr(rec.header), (uint) rec.header[4],
 
612
                (uint) rec.header[5],
 
613
                LSN_IN_PARTS(rec.lsn));
 
614
        goto err;
 
615
      }
 
616
      lsn= rec.lsn;
 
617
      read_ok(&rec);
 
618
      translog_free_record_header(&rec);
 
619
 
 
620
      len= translog_read_next_record_header(&scanner, &rec);
 
621
      if ((rec_len= rand_buffer_size()) < 9)
 
622
        rec_len= 9;
 
623
      if (rec.type != LOGREC_VARIABLE_RECORD_0LSN_EXAMPLE ||
 
624
          rec.short_trid != (i % 0xFFFF) ||
 
625
          rec.record_length != rec_len ||
 
626
          len != 9 || check_content(rec.header, (uint)len))
 
627
      {
 
628
        fprintf(stderr, "Incorrect LOGREC_VARIABLE_RECORD_0LSN_EXAMPLE "
 
629
                "data read(%d) "
 
630
                "type %u, strid %u, len %lu != %lu, hdr len: %d, "
 
631
                "lsn(%lu,0x%lx)\n",
 
632
                i, (uint) rec.type, (uint) rec.short_trid,
 
633
                (ulong) rec.record_length, (ulong) rec_len,
 
634
                len, LSN_IN_PARTS(rec.lsn));
 
635
        goto err;
 
636
      }
 
637
      if (read_and_check_content(&rec, long_buffer, 0))
 
638
      {
 
639
        fprintf(stderr,
 
640
                "Incorrect LOGREC_VARIABLE_RECORD_2LSN_EXAMPLE "
 
641
                "in whole rec read lsn(%lu,0x%lx)\n",
 
642
                LSN_IN_PARTS(rec.lsn));
 
643
        goto err;
 
644
      }
 
645
      read_ok(&rec);
 
646
      translog_free_record_header(&rec);
 
647
    }
 
648
  }
 
649
 
 
650
  rc= 0;
 
651
err:
 
652
  if (rc)
 
653
    ok(0, "read record");
 
654
  } /* SKIP_BIG_TESTS */
 
655
  translog_destroy();
 
656
  end_pagecache(&pagecache, 1);
 
657
  ma_control_file_end();
 
658
 
 
659
  if (maria_log_remove())
 
660
    exit(1);
 
661
 
 
662
  return(test(exit_status()));
 
663
}
 
664
 
 
665
#include "../ma_check_standalone.h"