~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

• browse files at revision 2030.1.2
• compare with another revision
• download diff
• download tarball
• view history from revision 2030.1.2

• reverse the comparison (2030.1.2 to 2165.1.3)
• stop comparing with revision 2165.1.3

Show diffs side-by-side

added

removed

plugin/innobase/log/log0recv.c

180

180

                return;

181

181

        }

182

182

 

183

 

        recv_sys = static_cast<recv_sys_t *>(mem_alloc(sizeof(*recv_sys)));

 

183

        recv_sys = 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 = static_cast<byte *>(ut_malloc(RECV_PARSING_BUF_SIZE));

 

330

        recv_sys->buf = 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 = static_cast<byte *>(mem_alloc(2 * OS_FILE_LOG_BLOCK_SIZE));

 

340

        recv_sys->last_block_buf_start = mem_alloc(2 * OS_FILE_LOG_BLOCK_SIZE);

341

341

 

342

 

        recv_sys->last_block = static_cast<byte *>(ut_align(recv_sys->last_block_buf_start,

343

 

                                        OS_FILE_LOG_BLOCK_SIZE));

 

342

        recv_sys->last_block = 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 = static_cast<recv_addr_t *>(HASH_GET_FIRST(recv_sys->addr_hash,

1323

 

                                   recv_hash(space, page_no)));

 

1322

        recv_addr = 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 = static_cast<recv_addr_t *>(HASH_GET_NEXT(addr_hash, recv_addr));

 

1331

                recv_addr = 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 = static_cast<recv_t *>(mem_heap_alloc(recv_sys->heap, sizeof(recv_t)));

 

1366

        recv = 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 = static_cast<recv_addr_t *>(mem_heap_alloc(recv_sys->heap,

1376

 

                                           sizeof(recv_addr_t)));

 

1375

                recv_addr = 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 = static_cast<recv_data_t *>(mem_heap_alloc(recv_sys->heap,

1409

 

                                           sizeof(recv_data_t) + len));

 

1408

                recv_data = 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 = static_cast<byte *>(mem_alloc(recv->len));

 

1571

                        buf = mem_alloc(recv->len);

1572

1572

 

1573

1573

                        recv_data_copy_to_buf(buf, recv);

1574

1574

                } else {

1589

1589

 

1590

1590

                if (recv->start_lsn >= page_lsn) {

1591

1591

 

1592

 

                        ib_uint64_t     page_end_lsn;

 

1592

                        ib_uint64_t     end_lsn;

1593

1593

 

1594

1594

                        if (!modification_to_page) {

1595

1595

 

1613

1613

                                                         buf + recv->len,

1614

1614

                                                         block, &mtr);

1615

1615

 

1616

 

                        page_end_lsn = recv->start_lsn + recv->len;

1617

 

                        mach_write_to_8(FIL_PAGE_LSN + page, page_end_lsn);

 

1616

                        end_lsn = recv->start_lsn + recv->len;

 

1617

                        mach_write_to_8(FIL_PAGE_LSN + page, end_lsn);

1618

1618

                        mach_write_to_8(UNIV_PAGE_SIZE

1619

1619

                                        - FIL_PAGE_END_LSN_OLD_CHKSUM

1620

 

                                        + page, page_end_lsn);

 

1620

                                        + page, end_lsn);

1621

1621

 

1622

1622

                        if (page_zip) {

1623

1623

                                mach_write_to_8(FIL_PAGE_LSN

1624

 

                                                + page_zip->data, page_end_lsn);

 

1624

                                                + page_zip->data, end_lsn);

1625

1625

                        }

1626

1626

                }

1627

1627

 

1767

1767

 

1768

1768

        for (i = 0; i < hash_get_n_cells(recv_sys->addr_hash); i++) {

1769

1769

 

1770

 

                recv_addr = static_cast<recv_addr_t *>(HASH_GET_FIRST(recv_sys->addr_hash, i));

 

1770

                recv_addr = 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 = static_cast<recv_addr_t *>(HASH_GET_NEXT(addr_hash, recv_addr));

 

1811

                        recv_addr = HASH_GET_NEXT(addr_hash, recv_addr);

1812

1812

                }

1813

1813

 

1814

1814

                if (has_printed

3267

3267

        }

3268

3268

#endif /* UNIV_DEBUG */

3269

3269

 

 

3270

        if (recv_needed_recovery) {

 

3271

                trx_sys_print_mysql_master_log_pos();

 

3272

                trx_sys_print_mysql_binlog_offset();

 

3273

        }

 

3274

 

3270

3275

        if (recv_sys->found_corrupt_log) {

3271

3276

 

3272

3277

                fprintf(stderr,

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1