← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/log/log0recv.cc

  • Committer: Monty Taylor
  • Date: 2010-12-26 03:15:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2038.
  • Revision ID: mordred@inaugust.com-20101226031544-1cf3raipu53fnmyj
Through page.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/log/log0recv.cc
180
180
                return;
181
181
        }
182
182
 
183
 
        recv_sys = mem_alloc(sizeof(*recv_sys));
 
183
        recv_sys = static_cast<recv_sys_t *>(mem_alloc(sizeof(*recv_sys)));
184
184
        memset(recv_sys, 0x0, sizeof(*recv_sys));
185
185
 
186
186
        mutex_create(recv_sys_mutex_key, &recv_sys->mutex, SYNC_RECV);
327
327
                recv_n_pool_free_frames = 512;
328
328
        }
329
329
 
330
 
        recv_sys->buf = ut_malloc(RECV_PARSING_BUF_SIZE);
 
330
        recv_sys->buf = static_cast<byte *>(ut_malloc(RECV_PARSING_BUF_SIZE));
331
331
        recv_sys->len = 0;
332
332
        recv_sys->recovered_offset = 0;
333
333
 
337
337
        recv_sys->apply_log_recs = FALSE;
338
338
        recv_sys->apply_batch_on = FALSE;
339
339
 
340
 
        recv_sys->last_block_buf_start = mem_alloc(2 * OS_FILE_LOG_BLOCK_SIZE);
 
340
        recv_sys->last_block_buf_start = static_cast<byte *>(mem_alloc(2 * OS_FILE_LOG_BLOCK_SIZE));
341
341
 
342
 
        recv_sys->last_block = ut_align(recv_sys->last_block_buf_start,
343
 
                                        OS_FILE_LOG_BLOCK_SIZE);
 
342
        recv_sys->last_block = static_cast<byte *>(ut_align(recv_sys->last_block_buf_start,
 
343
                                        OS_FILE_LOG_BLOCK_SIZE));
344
344
        recv_sys->found_corrupt_log = FALSE;
345
345
 
346
346
        recv_max_page_lsn = 0;
1319
1319
{
1320
1320
        recv_addr_t*    recv_addr;
1321
1321
 
1322
 
        recv_addr = HASH_GET_FIRST(recv_sys->addr_hash,
1323
 
                                   recv_hash(space, page_no));
 
1322
        recv_addr = static_cast<recv_addr_t *>(HASH_GET_FIRST(recv_sys->addr_hash,
 
1323
                                   recv_hash(space, page_no)));
1324
1324
        while (recv_addr) {
1325
1325
                if ((recv_addr->space == space)
1326
1326
                    && (recv_addr->page_no == page_no)) {
1328
1328
                        break;
1329
1329
                }
1330
1330
 
1331
 
                recv_addr = HASH_GET_NEXT(addr_hash, recv_addr);
 
1331
                recv_addr = static_cast<recv_addr_t *>(HASH_GET_NEXT(addr_hash, recv_addr));
1332
1332
        }
1333
1333
 
1334
1334
        return(recv_addr);
1363
1363
 
1364
1364
        len = rec_end - body;
1365
1365
 
1366
 
        recv = mem_heap_alloc(recv_sys->heap, sizeof(recv_t));
 
1366
        recv = static_cast<recv_t *>(mem_heap_alloc(recv_sys->heap, sizeof(recv_t)));
1367
1367
        recv->type = type;
1368
1368
        recv->len = rec_end - body;
1369
1369
        recv->start_lsn = start_lsn;
1372
1372
        recv_addr = recv_get_fil_addr_struct(space, page_no);
1373
1373
 
1374
1374
        if (recv_addr == NULL) {
1375
 
                recv_addr = mem_heap_alloc(recv_sys->heap,
1376
 
                                           sizeof(recv_addr_t));
 
1375
                recv_addr = static_cast<recv_addr_t *>(mem_heap_alloc(recv_sys->heap,
 
1376
                                           sizeof(recv_addr_t)));
1377
1377
                recv_addr->space = space;
1378
1378
                recv_addr->page_no = page_no;
1379
1379
                recv_addr->state = RECV_NOT_PROCESSED;
1405
1405
                        len = RECV_DATA_BLOCK_SIZE;
1406
1406
                }
1407
1407
 
1408
 
                recv_data = mem_heap_alloc(recv_sys->heap,
1409
 
                                           sizeof(recv_data_t) + len);
 
1408
                recv_data = static_cast<recv_addr_t>(mem_heap_alloc(recv_sys->heap,
 
1409
                                           sizeof(recv_data_t) + len));
1410
1410
                *prev_field = recv_data;
1411
1411
 
1412
1412
                memcpy(recv_data + 1, body, len);
1568
1568
                        /* We have to copy the record body to a separate
1569
1569
                        buffer */
1570
1570
 
1571
 
                        buf = mem_alloc(recv->len);
 
1571
                        buf = static_cast<byte *>(mem_alloc(recv->len));
1572
1572
 
1573
1573
                        recv_data_copy_to_buf(buf, recv);
1574
1574
                } else {
1767
1767
 
1768
1768
        for (i = 0; i < hash_get_n_cells(recv_sys->addr_hash); i++) {
1769
1769
 
1770
 
                recv_addr = HASH_GET_FIRST(recv_sys->addr_hash, i);
 
1770
                recv_addr = static_cast<recv_addr_t *>(HASH_GET_FIRST(recv_sys->addr_hash, i));
1771
1771
 
1772
1772
                while (recv_addr) {
1773
1773
                        ulint   space = recv_addr->space;
1808
1808
                                mutex_enter(&(recv_sys->mutex));
1809
1809
                        }
1810
1810
 
1811
 
                        recv_addr = HASH_GET_NEXT(addr_hash, recv_addr);
 
1811
                        recv_addr = static_cast<recv_addr_t *>(HASH_GET_NEXT(addr_hash, recv_addr));
1812
1812
                }
1813
1813
 
1814
1814
                if (has_printed