← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/buf/buf0buf.c

  • Committer: Brian Aker
  • Date: 2010-12-24 03:44:02 UTC
  • mfrom: (2015.1.3 timestamp)
  • mto: This revision was merged to the branch mainline in revision 2028.
  • Revision ID: brian@tangent.org-20101224034402-n1hpg1yxwjz59hpw
Finish up issues with unsigned/int by fixing cast().

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/buf/buf0buf.c
52
52
#include "log0recv.h"
53
53
#include "page0zip.h"
54
54
 
55
 
#include <drizzled/errmsg_print.h>
56
 
 
57
55
/*
58
56
                IMPLEMENTATION OF THE BUFFER POOL
59
57
                =================================
529
527
                     < mach_read_from_8(read_buf + FIL_PAGE_LSN))) {
530
528
                        ut_print_timestamp(stderr);
531
529
 
532
 
                        drizzled::errmsg_printf(drizzled::error::INFO,
533
 
                                                "InnoDB: Error: page %lu log sequence number %"PRIu64". "
534
 
                                                "InnoDB: is in the future! Current system log sequence number %"PRIu64". "
535
 
                                                "Your database may be corrupt or you may have copied the InnoDB tablespace but not the InnoDB log files. See "
536
 
                                                " " REFMAN "forcing-recovery.html for more information. ",
537
 
                                                (ulong) mach_read_from_4(read_buf
538
 
                                                                         + FIL_PAGE_OFFSET),
539
 
                                                mach_read_from_8(read_buf + FIL_PAGE_LSN),
540
 
                                                current_lsn);
 
530
                        fprintf(stderr,
 
531
                                "  InnoDB: Error: page %lu log sequence number"
 
532
                                " %"PRIu64"\n"
 
533
                                "InnoDB: is in the future! Current system "
 
534
                                "log sequence number %"PRIu64".\n"
 
535
                                "InnoDB: Your database may be corrupt or "
 
536
                                "you may have copied the InnoDB\n"
 
537
                                "InnoDB: tablespace but not the InnoDB "
 
538
                                "log files. See\n"
 
539
                                "InnoDB: " REFMAN "forcing-recovery.html\n"
 
540
                                "InnoDB: for more information.\n",
 
541
                                (ulong) mach_read_from_4(read_buf
 
542
                                                         + FIL_PAGE_OFFSET),
 
543
                                mach_read_from_8(read_buf + FIL_PAGE_LSN),
 
544
                                current_lsn);
541
545
                }
542
546
        }
543
547
#endif
937
941
 
938
942
        /* Allocate the block descriptors from
939
943
        the start of the memory block. */
940
 
        chunk->blocks = static_cast<buf_block_struct *>(chunk->mem);
 
944
        chunk->blocks = chunk->mem;
941
945
 
942
946
        /* Align a pointer to the first frame.  Note that when
943
947
        os_large_page_size is smaller than UNIV_PAGE_SIZE,
944
948
        we may allocate one fewer block than requested.  When
945
949
        it is bigger, we may allocate more blocks than requested. */
946
950
 
947
 
        frame = static_cast<unsigned char *>(ut_align(chunk->mem, UNIV_PAGE_SIZE));
 
951
        frame = ut_align(chunk->mem, UNIV_PAGE_SIZE);
948
952
        chunk->size = chunk->mem_size / UNIV_PAGE_SIZE
949
953
                - (frame != chunk->mem);
950
954
 
1209
1213
 
1210
1214
        if (buf_pool_size > 0) {
1211
1215
                buf_pool->n_chunks = 1;
1212
 
                void *chunk_ptr= mem_zalloc((sizeof *chunk));
1213
 
                buf_pool->chunks = chunk = static_cast<buf_chunk_t *>(chunk_ptr);
 
1216
                buf_pool->chunks = chunk = mem_zalloc(sizeof *chunk);
1214
1217
 
1215
1218
                UT_LIST_INIT(buf_pool->free);
1216
1219
 
1299
1302
        /* We create an extra buffer pool instance, this instance is used
1300
1303
        for flushing the flush lists, to keep track of n_flush for all
1301
1304
        the buffer pools and also used as a waiting object during flushing. */
1302
 
        void *buf_pool_void_ptr= mem_zalloc(n_instances * sizeof *buf_pool_ptr);
1303
 
        buf_pool_ptr = static_cast<buf_pool_struct *>(buf_pool_void_ptr);
 
1305
        buf_pool_ptr = mem_zalloc(n_instances * sizeof *buf_pool_ptr);
1304
1306
 
1305
1307
        for (i = 0; i < n_instances; i++) {
1306
1308
                buf_pool_t*     ptr     = &buf_pool_ptr[i];
1653
1655
        buf_pool->old_pool_size = buf_pool->curr_pool_size;
1654
1656
 
1655
1657
        /* Rewrite buf_pool->chunks.  Copy everything but max_chunk. */
1656
 
        chunks = static_cast<buf_chunk_t *>(mem_alloc((buf_pool->n_chunks - 1) * sizeof *chunks));
 
1658
        chunks = mem_alloc((buf_pool->n_chunks - 1) * sizeof *chunks);
1657
1659
        memcpy(chunks, buf_pool->chunks,
1658
1660
               (max_chunk - buf_pool->chunks) * sizeof *chunks);
1659
1661
        memcpy(chunks + (max_chunk - buf_pool->chunks),
1938
1940
        buf_chunk_t*    chunk;
1939
1941
 
1940
1942
        buf_pool_mutex_enter(buf_pool);
1941
 
        chunks = static_cast<buf_chunk_t *>(mem_alloc((buf_pool->n_chunks + 1) * sizeof *chunks));
 
1943
        chunks = mem_alloc((buf_pool->n_chunks + 1) * sizeof *chunks);
1942
1944
 
1943
1945
        memcpy(chunks, buf_pool->chunks, buf_pool->n_chunks * sizeof *chunks);
1944
1946
 
3655
3657
                        mutex_exit(&block->mutex);
3656
3658
                        data = buf_buddy_alloc(buf_pool, zip_size, &lru);
3657
3659
                        mutex_enter(&block->mutex);
3658
 
                        block->page.zip.data = static_cast<unsigned char *>(data);
 
3660
                        block->page.zip.data = data;
3659
3661
 
3660
3662
                        /* To maintain the invariant
3661
3663
                        block->in_unzip_LRU_list
3678
3680
                invocation of buf_buddy_relocate_block() on
3679
3681
                uninitialized data. */
3680
3682
                data = buf_buddy_alloc(buf_pool, zip_size, &lru);
3681
 
                bpage = static_cast<buf_page_struct *>(buf_buddy_alloc(buf_pool, sizeof *bpage, &lru));
 
3683
                bpage = buf_buddy_alloc(buf_pool, sizeof *bpage, &lru);
3682
3684
 
3683
3685
                /* Initialize the buf_pool pointer. */
3684
3686
                bpage->buf_pool_index = buf_pool_index(buf_pool);
3707
3709
 
3708
3710
                page_zip_des_init(&bpage->zip);
3709
3711
                page_zip_set_size(&bpage->zip, zip_size);
3710
 
                bpage->zip.data = static_cast<unsigned char *>(data);
 
3712
                bpage->zip.data = data;
3711
3713
 
3712
3714
                mutex_enter(&buf_pool->zip_mutex);
3713
3715
                UNIV_MEM_DESC(bpage->zip.data,
3861
3863
                has been added to buf_pool->LRU and buf_pool->page_hash. */
3862
3864
                data = buf_buddy_alloc(buf_pool, zip_size, &lru);
3863
3865
                mutex_enter(&block->mutex);
3864
 
                block->page.zip.data = static_cast<unsigned char *>(data);
 
3866
                block->page.zip.data = data;
3865
3867
 
3866
3868
                /* To maintain the invariant
3867
3869
                block->in_unzip_LRU_list
4173
4175
        buf_pool_t*     buf_pool)       /*!< in: buffer pool instance */
4174
4176
{
4175
4177
        ibool           freed;
4176
 
        int     i;
 
4178
        enum buf_flush  i;
4177
4179
 
4178
4180
        buf_pool_mutex_enter(buf_pool);
4179
4181
 
4192
4194
                write activity happening. */
4193
4195
                if (buf_pool->n_flush[i] > 0) {
4194
4196
                        buf_pool_mutex_exit(buf_pool);
4195
 
                        buf_flush_wait_batch_end(buf_pool, static_cast<buf_flush>(i));
 
4197
                        buf_flush_wait_batch_end(buf_pool, i);
4196
4198
                        buf_pool_mutex_enter(buf_pool);
4197
4199
                }
4198
4200
        }
4901
4903
        fprintf(file,
4902
4904
                "LRU len: %lu, unzip_LRU len: %lu\n"
4903
4905
                "I/O sum[%lu]:cur[%lu], unzip sum[%lu]:cur[%lu]\n",
4904
 
                static_cast<ulint>(UT_LIST_GET_LEN(buf_pool->LRU)),
4905
 
                static_cast<ulint>(UT_LIST_GET_LEN(buf_pool->unzip_LRU)),
 
4906
                UT_LIST_GET_LEN(buf_pool->LRU),
 
4907
                UT_LIST_GET_LEN(buf_pool->unzip_LRU),
4906
4908
                buf_LRU_stat_sum.io, buf_LRU_stat_cur.io,
4907
4909
                buf_LRU_stat_sum.unzip, buf_LRU_stat_cur.unzip);
4908
4910