mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-17 20:42:30 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add cast of integer/longlong to (ulong) to make printf/sprintf 64 bit safe

Browse source 
A after merge fix for last merge
This commit is contained in:
monty@mysql.com 2003-12-20 03:41:04 +02:00
parent 4b3e443b36
commit 0448a3f4c0
49 changed files with 816 additions and 686 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
innobase/btr/btr0btr.c
View file

@ -2217,7 +2217,8 @@ btr_print_recursive(
ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
MTR_MEMO_PAGE_X_FIX));
printf("NODE ON LEVEL %lu page number %lu\n",
btr_page_get_level(page, mtr), buf_frame_get_page_no(page));
(ulong) btr_page_get_level(page, mtr),
(ulong) buf_frame_get_page_no(page));
page_print(page, width, width);
@ -2513,8 +2514,8 @@ loop:
if (!page_validate(page, index)) {
fprintf(stderr,
"InnoDB: Error in page %lu in index %s table %s, index tree level %lu\n",
buf_frame_get_page_no(page), index->name,
index->table_name, level);
(ulong) buf_frame_get_page_no(page), index->name,
index->table_name, (ulong) level);
ret = FALSE;
} else if (level == 0) {
@ -2546,8 +2547,8 @@ loop:
fprintf(stderr,
"InnoDB: Error on pages %lu and %lu in index %s table %s\n",
buf_frame_get_page_no(page),
(unsigned long) right_page_no,
(ulong) buf_frame_get_page_no(page),
(ulong) right_page_no,
index->name, index->table_name);
fprintf(stderr,
@ -2630,7 +2631,7 @@ loop:
fprintf(stderr,
"InnoDB: Error on page %lu in index %s table %s\n",
buf_frame_get_page_no(page),
(ulong) buf_frame_get_page_no(page),
index->name, index->table_name);
buf_page_print(father_page);

22
innobase/btr/btr0sea.c
View file

@ -1532,11 +1532,11 @@ btr_search_index_print_info(
info = btr_search_get_info(index);
printf("Searches %lu, hash succ %lu, fail %lu, patt succ %lu\n",
info->n_searches, info->n_hash_succ, info->n_hash_fail,
info->n_patt_succ);
(ulong) info->n_searches, (ulong) info->n_hash_succ,
(ulong) info->n_hash_fail, (ulong) info->n_patt_succ);
printf("Total of page cur short succ for all indexes %lu\n",
page_cur_short_succ);
(ulong) page_cur_short_succ);
rw_lock_x_unlock(&btr_search_latch);
}
@ -1604,11 +1604,12 @@ btr_search_validate(void)
fprintf(stderr,
" InnoDB: Error in an adaptive hash index pointer to page %lu\n"
"ptr mem address %lu index id %lu %lu, node fold %lu, rec fold %lu\n",
buf_frame_get_page_no(page),
(ulint)(node->data),
ut_dulint_get_high(btr_page_get_index_id(page)),
ut_dulint_get_low(btr_page_get_index_id(page)),
node->fold, rec_fold((rec_t*)(node->data),
(ulong) buf_frame_get_page_no(page),
(ulong)(node->data),
(ulong) ut_dulint_get_high(btr_page_get_index_id(page)),
(ulong) ut_dulint_get_low(btr_page_get_index_id(page)),
(ulong) node->fold,
(ulong) rec_fold((rec_t*)(node->data),
block->curr_n_fields,
block->curr_n_bytes,
btr_page_get_index_id(page)));
@ -1622,8 +1623,9 @@ btr_search_validate(void)
fprintf(stderr,
"Page mem address %lu, is hashed %lu, n fields %lu, n bytes %lu\n"
"side %lu\n",
(ulint)page, block->is_hashed, block->curr_n_fields,
block->curr_n_bytes, block->curr_side);
(ulong) page, (ulong) block->is_hashed,
(ulong) block->curr_n_fields,
(ulong) block->curr_n_bytes, (ulong) block->curr_side);
if (n_page_dumps < 20) {
buf_page_print(page);

125
innobase/buf/buf0buf.c
View file

@ -321,13 +321,13 @@ buf_page_is_corrupted(
" InnoDB: Error: page %lu log sequence number %lu %lu\n"
"InnoDB: is in the future! Current system log sequence number %lu %lu.\n"
"InnoDB: Your database may be corrupt.\n",
mach_read_from_4(read_buf + FIL_PAGE_OFFSET),
ut_dulint_get_high(
(ulong) mach_read_from_4(read_buf + FIL_PAGE_OFFSET),
(ulong) ut_dulint_get_high(
mach_read_from_8(read_buf + FIL_PAGE_LSN)),
ut_dulint_get_low(
(ulong) ut_dulint_get_low(
mach_read_from_8(read_buf + FIL_PAGE_LSN)),
ut_dulint_get_high(current_lsn),
ut_dulint_get_low(current_lsn));
(ulong) ut_dulint_get_high(current_lsn),
(ulong) ut_dulint_get_low(current_lsn));
}
}
#endif
@ -381,7 +381,7 @@ buf_page_print(
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Page dump in ascii and hex (%lu bytes):\n%s",
(ulint)UNIV_PAGE_SIZE, buf);
(ulong) UNIV_PAGE_SIZE, buf);
fprintf(stderr, "InnoDB: End of page dump\n");
mem_free(buf);
@ -393,20 +393,20 @@ buf_page_print(
fprintf(stderr,
" InnoDB: Page checksum %lu, prior-to-4.0.14-form checksum %lu\n"
"InnoDB: stored checksum %lu, prior-to-4.0.14-form stored checksum %lu\n",
checksum, old_checksum,
mach_read_from_4(read_buf + FIL_PAGE_SPACE_OR_CHKSUM),
mach_read_from_4(read_buf + UNIV_PAGE_SIZE
(ulong) checksum, (ulong) old_checksum,
(ulong) mach_read_from_4(read_buf + FIL_PAGE_SPACE_OR_CHKSUM),
(ulong) mach_read_from_4(read_buf + UNIV_PAGE_SIZE
- FIL_PAGE_END_LSN_OLD_CHKSUM));
fprintf(stderr,
"InnoDB: Page lsn %lu %lu, low 4 bytes of lsn at page end %lu\n"
"InnoDB: Page number (if stored to page already) %lu,\n"
"InnoDB: space id (if created with >= MySQL-4.1.1 and stored already) %lu\n",
mach_read_from_4(read_buf + FIL_PAGE_LSN),
mach_read_from_4(read_buf + FIL_PAGE_LSN + 4),
mach_read_from_4(read_buf + UNIV_PAGE_SIZE
(ulong) mach_read_from_4(read_buf + FIL_PAGE_LSN),
(ulong) mach_read_from_4(read_buf + FIL_PAGE_LSN + 4),
(ulong) mach_read_from_4(read_buf + UNIV_PAGE_SIZE
- FIL_PAGE_END_LSN_OLD_CHKSUM + 4),
mach_read_from_4(read_buf + FIL_PAGE_OFFSET),
mach_read_from_4(read_buf + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID));
(ulong) mach_read_from_4(read_buf + FIL_PAGE_OFFSET),
(ulong) mach_read_from_4(read_buf + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID));
if (mach_read_from_2(read_buf + TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_TYPE)
== TRX_UNDO_INSERT) {
@ -422,8 +422,8 @@ buf_page_print(
if (fil_page_get_type(read_buf) == FIL_PAGE_INDEX) {
fprintf(stderr,
"InnoDB: Page may be an index page where index id is %lu %lu\n",
ut_dulint_get_high(btr_page_get_index_id(read_buf)),
ut_dulint_get_low(btr_page_get_index_id(read_buf)));
(ulong) ut_dulint_get_high(btr_page_get_index_id(read_buf)),
(ulong) ut_dulint_get_low(btr_page_get_index_id(read_buf)));
/* If the code is in ibbackup, dict_sys may be uninitialized,
i.e., NULL */
@ -513,7 +513,7 @@ buf_pool_init(
fprintf(stderr,
"InnoDB: AWE: Error: you must specify in my.cnf .._awe_mem_mb larger\n"
"InnoDB: than .._buffer_pool_size. Now the former is %lu pages,\n"
"InnoDB: the latter %lu pages.\n", curr_size, n_frames);
"InnoDB: the latter %lu pages.\n", (ulong) curr_size, (ulong) n_frames);
return(NULL);
}
@ -543,7 +543,7 @@ buf_pool_init(
fprintf(stderr,
"InnoDB: AWE: Error: physical memory must be allocated in full megabytes.\n"
"InnoDB: Trying to allocate %lu database pages.\n",
curr_size);
(ulong) curr_size);
return(NULL);
}
@ -780,7 +780,7 @@ buf_awe_map_page_to_frame(
fprintf(stderr,
"InnoDB: AWE: Fatal error: cannot find a page to unmap\n"
"InnoDB: awe_LRU_free_mapped list length %lu\n",
UT_LIST_GET_LEN(buf_pool->awe_LRU_free_mapped));
(ulong) UT_LIST_GET_LEN(buf_pool->awe_LRU_free_mapped));
ut_a(0);
}
@ -1546,8 +1546,9 @@ buf_page_init(
if (buf_page_hash_get(space, offset)) {
fprintf(stderr,
"InnoDB: Error: page %lu %lu already found from the hash table\n", space,
offset);
"InnoDB: Error: page %lu %lu already found from the hash table\n",
(ulong) space,
(ulong) offset);
buf_print();
buf_LRU_print();
buf_validate();
@ -1730,8 +1731,9 @@ buf_page_create(
/* If we get here, the page was not in buf_pool: init it there */
if (buf_debug_prints) {
printf("Creating space %lu page %lu to buffer\n", space,
offset);
printf("Creating space %lu page %lu to buffer\n",
(ulong) space,
(ulong) offset);
}
block = free_block;
@ -1809,7 +1811,7 @@ buf_page_io_complete(
fprintf(stderr,
"InnoDB: Error: page n:o stored in the page read in is %lu, should be %lu!\n",
read_page_no, block->offset);
(ulong) read_page_no, (ulong) block->offset);
}
#ifdef notdefined
if (block->offset != 0 && read_page_no == 0) {
@ -1832,7 +1834,7 @@ buf_page_io_complete(
if (buf_page_is_corrupted(block->frame)) {
fprintf(stderr,
"InnoDB: Database page corruption on disk or a failed\n"
"InnoDB: file read of page %lu.\n", block->offset);
"InnoDB: file read of page %lu.\n", (ulong) block->offset);
fprintf(stderr,
"InnoDB: You may have to recover from a backup.\n");
@ -1841,7 +1843,7 @@ buf_page_io_complete(
fprintf(stderr,
"InnoDB: Database page corruption on disk or a failed\n"
"InnoDB: file read of page %lu.\n", block->offset);
"InnoDB: file read of page %lu.\n", (ulong) block->offset);
fprintf(stderr,
"InnoDB: You may have to recover from a backup.\n");
fprintf(stderr,
@ -1922,8 +1924,8 @@ buf_page_io_complete(
mutex_exit(&(buf_pool->mutex));
if (buf_debug_prints) {
printf("page space %lu page no %lu", block->space,
block->offset);
printf("page space %lu page no %lu", (ulong) block->space,
(ulong) block->offset);
id = btr_page_get_index_id(block->frame);
index = NULL;
@ -2038,14 +2040,16 @@ buf_validate(void)
}
if (n_lru + n_free > buf_pool->curr_size) {
printf("n LRU %lu, n free %lu\n", n_lru, n_free);
printf("n LRU %lu, n free %lu\n", (ulong) n_lru,
(ulong) n_free);
ut_error;
}
ut_a(UT_LIST_GET_LEN(buf_pool->LRU) == n_lru);
if (UT_LIST_GET_LEN(buf_pool->free) != n_free) {
printf("Free list len %lu, free blocks %lu\n",
UT_LIST_GET_LEN(buf_pool->free), n_free);
(ulong) UT_LIST_GET_LEN(buf_pool->free),
(ulong) n_free);
ut_error;
}
ut_a(UT_LIST_GET_LEN(buf_pool->flush_list) == n_flush);
@ -2088,22 +2092,23 @@ buf_print(void)
mutex_enter(&(buf_pool->mutex));
printf("buf_pool size %lu \n", size);
printf("database pages %lu \n", UT_LIST_GET_LEN(buf_pool->LRU));
printf("free pages %lu \n", UT_LIST_GET_LEN(buf_pool->free));
printf("buf_pool size %lu \n", (ulong) size);
printf("database pages %lu \n", (ulong) UT_LIST_GET_LEN(buf_pool->LRU));
printf("free pages %lu \n", (ulong) UT_LIST_GET_LEN(buf_pool->free));
printf("modified database pages %lu \n",
UT_LIST_GET_LEN(buf_pool->flush_list));
(ulong) UT_LIST_GET_LEN(buf_pool->flush_list));
printf("n pending reads %lu \n", buf_pool->n_pend_reads);
printf("n pending reads %lu \n", (ulong) buf_pool->n_pend_reads);
printf("n pending flush LRU %lu list %lu single page %lu\n",
buf_pool->n_flush[BUF_FLUSH_LRU],
buf_pool->n_flush[BUF_FLUSH_LIST],
buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]);
(ulong) buf_pool->n_flush[BUF_FLUSH_LRU],
(ulong) buf_pool->n_flush[BUF_FLUSH_LIST],
(ulong) buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]);
printf("pages read %lu, created %lu, written %lu\n",
buf_pool->n_pages_read, buf_pool->n_pages_created,
buf_pool->n_pages_written);
(ulong) buf_pool->n_pages_read,
(ulong) buf_pool->n_pages_created,
(ulong) buf_pool->n_pages_written);
/* Count the number of blocks belonging to each index in the buffer */
@ -2147,7 +2152,8 @@ buf_print(void)
index = dict_index_get_if_in_cache(index_ids[i]);
printf("Block count for index %lu in buffer is about %lu",
ut_dulint_get_low(index_ids[i]), counts[i]);
(ulong) ut_dulint_get_low(index_ids[i]),
(ulong) counts[i]);
if (index) {
printf(" index name %s table %s", index->name,
@ -2224,39 +2230,39 @@ buf_print_io(
mutex_enter(&(buf_pool->mutex));
buf += sprintf(buf,
"Buffer pool size %lu\n", size);
"Buffer pool size %lu\n", (ulong) size);
buf += sprintf(buf,
"Free buffers %lu\n", UT_LIST_GET_LEN(buf_pool->free));
"Free buffers %lu\n", (ulong) UT_LIST_GET_LEN(buf_pool->free));
buf += sprintf(buf,
"Database pages %lu\n", UT_LIST_GET_LEN(buf_pool->LRU));
"Database pages %lu\n", (ulong) UT_LIST_GET_LEN(buf_pool->LRU));
/*
buf += sprintf(buf,
"Lock heap buffers %lu\n", buf_pool->n_lock_heap_pages);
"Lock heap buffers %lu\n", (ulong) buf_pool->n_lock_heap_pages);
buf += sprintf(buf,
"Hash index buffers %lu\n", buf_pool->n_adaptive_hash_pages);
"Hash index buffers %lu\n", (ulong) buf_pool->n_adaptive_hash_pages);
*/
buf += sprintf(buf,
"Modified db pages %lu\n",
UT_LIST_GET_LEN(buf_pool->flush_list));
(ulong) UT_LIST_GET_LEN(buf_pool->flush_list));
if (srv_use_awe) {
buf += sprintf(buf,
"AWE: Buffer pool memory frames %lu\n",
buf_pool->n_frames);
(ulong) buf_pool->n_frames);
buf += sprintf(buf,
"AWE: Database pages and free buffers mapped in frames %lu\n",
UT_LIST_GET_LEN(buf_pool->awe_LRU_free_mapped));
(ulong) UT_LIST_GET_LEN(buf_pool->awe_LRU_free_mapped));
}
buf += sprintf(buf, "Pending reads %lu \n", buf_pool->n_pend_reads);
buf += sprintf(buf, "Pending reads %lu \n", (ulong) buf_pool->n_pend_reads);
buf += sprintf(buf,
"Pending writes: LRU %lu, flush list %lu, single page %lu\n",
buf_pool->n_flush[BUF_FLUSH_LRU]
+ buf_pool->init_flush[BUF_FLUSH_LRU],
buf_pool->n_flush[BUF_FLUSH_LIST]
+ buf_pool->init_flush[BUF_FLUSH_LIST],
buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]);
(ulong) (buf_pool->n_flush[BUF_FLUSH_LRU]
+ buf_pool->init_flush[BUF_FLUSH_LRU]),
(ulong) (buf_pool->n_flush[BUF_FLUSH_LIST]
+ buf_pool->init_flush[BUF_FLUSH_LIST]),
(ulong) buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]);
current_time = time(NULL);
time_elapsed = 0.001 + difftime(current_time,
@ -2264,8 +2270,9 @@ buf_print_io(
buf_pool->last_printout_time = current_time;
buf += sprintf(buf, "Pages read %lu, created %lu, written %lu\n",
buf_pool->n_pages_read, buf_pool->n_pages_created,
buf_pool->n_pages_written);
(ulong) buf_pool->n_pages_read,
(ulong) buf_pool->n_pages_created,
(ulong) buf_pool->n_pages_written);
buf += sprintf(buf, "%.2f reads/s, %.2f creates/s, %.2f writes/s\n",
(buf_pool->n_pages_read - buf_pool->n_pages_read_old)
/ time_elapsed,
@ -2283,10 +2290,10 @@ buf_print_io(
if (buf_pool->n_page_gets > buf_pool->n_page_gets_old) {
buf += sprintf(buf, "Buffer pool hit rate %lu / 1000\n",
1000
(ulong) (1000
- ((1000 *
(buf_pool->n_pages_read - buf_pool->n_pages_read_old))
/ (buf_pool->n_page_gets - buf_pool->n_page_gets_old)));
/ (buf_pool->n_page_gets - buf_pool->n_page_gets_old))));
} else {
buf += sprintf(buf,
"No buffer pool page gets since the last printout\n");

12
innobase/buf/buf0flu.c
View file

@ -246,7 +246,7 @@ buf_flush_buffered_writes(void)
"InnoDB: to be written to data file. We intentionally crash server\n"
"InnoDB: to prevent corrupt data from ending up in data\n"
"InnoDB: files.\n",
block->offset, block->space);
(ulong) block->offset, (ulong) block->space);
ut_a(0);
}
@ -504,7 +504,8 @@ buf_flush_try_page(
if (buf_debug_prints) {
printf("Flushing page space %lu, page no %lu \n",
block->space, block->offset);
(ulong) block->space,
(ulong) block->offset);
}
buf_flush_write_block_low(block);
@ -592,7 +593,8 @@ buf_flush_try_page(
if (buf_debug_prints) {
printf(
"Flushing single page space %lu, page no %lu \n",
block->space, block->offset);
(ulong) block->space,
(ulong) block->offset);
}
buf_flush_write_block_low(block);
@ -823,10 +825,10 @@ buf_flush_batch(
if (buf_debug_prints && page_count > 0) {
if (flush_type == BUF_FLUSH_LRU) {
printf("Flushed %lu pages in LRU flush\n",
page_count);
(ulong) page_count);
} else if (flush_type == BUF_FLUSH_LIST) {
printf("Flushed %lu pages in flush list flush\n",
page_count);
(ulong) page_count);
} else {
ut_error;
}

44
innobase/buf/buf0lru.c
View file

@ -100,7 +100,8 @@ scan_again:
if (buf_debug_prints) {
printf(
"Dropping space %lu page %lu\n",
block->space, block->offset);
(ulong) block->space,
(ulong) block->offset);
}
if (block->is_hashed) {
@ -209,7 +210,8 @@ buf_LRU_search_and_free_block(
if (buf_debug_prints) {
printf(
"Putting space %lu page %lu to free list\n",
block->space, block->offset);
(ulong) block->space,
(ulong) block->offset);
}
buf_LRU_block_remove_hashed_page(block);
@ -329,7 +331,7 @@ loop:
"InnoDB: the buffer pool bigger?\n"
"InnoDB: Starting the InnoDB Monitor to print diagnostics, including\n"
"InnoDB: lock heap and hash index sizes.\n",
buf_pool->curr_size / (1024 * 1024 / UNIV_PAGE_SIZE));
(ulong) (buf_pool->curr_size / (1024 * 1024 / UNIV_PAGE_SIZE)));
srv_print_innodb_monitor = TRUE;
@ -396,7 +398,7 @@ loop:
"InnoDB: Warning: difficult to find free blocks from\n"
"InnoDB: the buffer pool (%lu search iterations)! Consider\n"
"InnoDB: increasing the buffer pool size.\n",
n_iterations);
(ulong) n_iterations);
fprintf(stderr,
"InnoDB: It is also possible that in your Unix version\n"
"InnoDB: fsync is very slow, or completely frozen inside\n"
@ -406,11 +408,13 @@ loop:
fprintf(stderr,
"InnoDB: Pending flushes (fsync) log: %lu; buffer pool: %lu\n",
fil_n_pending_log_flushes,
fil_n_pending_tablespace_flushes);
(ulong) fil_n_pending_log_flushes,
(ulong) fil_n_pending_tablespace_flushes);
fprintf(stderr,
"InnoDB: %lu OS file reads, %lu OS file writes, %lu OS fsyncs\n",
os_n_file_reads, os_n_file_writes, os_n_fsyncs);
(ulong) os_n_file_reads,
(ulong) os_n_file_writes,
(ulong) os_n_fsyncs);
fprintf(stderr,
"InnoDB: Starting InnoDB Monitor to print further\n"
@ -820,15 +824,15 @@ buf_LRU_block_remove_hashed_page(
if (block != buf_page_hash_get(block->space, block->offset)) {
fprintf(stderr,
"InnoDB: Error: page %lu %lu not found from the hash table\n",
block->space,
block->offset);
(ulong) block->space,
(ulong) block->offset);
if (buf_page_hash_get(block->space, block->offset)) {
fprintf(stderr,
"InnoDB: From hash table we find block %lx of %lu %lu which is not %lx\n",
(ulint)buf_page_hash_get(block->space, block->offset),
buf_page_hash_get(block->space, block->offset)->space,
buf_page_hash_get(block->space, block->offset)->offset,
(ulint)block);
(ulong) buf_page_hash_get(block->space, block->offset),
(ulong) buf_page_hash_get(block->space, block->offset)->space,
(ulong) buf_page_hash_get(block->space, block->offset)->offset,
(ulong) block);
}
buf_print();
@ -949,7 +953,7 @@ buf_LRU_print(void)
ut_ad(buf_pool);
mutex_enter(&(buf_pool->mutex));
printf("Pool ulint clock %lu\n", buf_pool->ulint_clock);
printf("Pool ulint clock %lu\n", (ulong) buf_pool->ulint_clock);
block = UT_LIST_GET_FIRST(buf_pool->LRU);
@ -957,18 +961,18 @@ buf_LRU_print(void)
while (block != NULL) {
printf("BLOCK %lu ", block->offset);
printf("BLOCK %lu ", (ulong) block->offset);
if (block->old) {
printf("old ");
}
if (block->buf_fix_count) {
printf("buffix count %lu ", block->buf_fix_count);
printf("buffix count %lu ", (ulong) block->buf_fix_count);
}
if (block->io_fix) {
printf("io_fix %lu ", block->io_fix);
printf("io_fix %lu ", (ulong) block->io_fix);
}
if (ut_dulint_cmp(block->oldest_modification,
@ -976,12 +980,12 @@ buf_LRU_print(void)
printf("modif. ");
}
printf("LRU pos %lu ", block->LRU_position);
printf("LRU pos %lu ", (ulong) block->LRU_position);
frame = buf_block_get_frame(block);
printf("type %lu ", fil_page_get_type(frame));
printf("index id %lu ", ut_dulint_get_low(
printf("type %lu ", (ulong) fil_page_get_type(frame));
printf("index id %lu ", (ulong) ut_dulint_get_low(
btr_page_get_index_id(frame)));
block = UT_LIST_GET_NEXT(LRU, block);

24
innobase/buf/buf0rea.c
View file

@ -85,7 +85,8 @@ buf_read_page_low(
+ TRX_SYS_DOUBLEWRITE_BLOCK_SIZE))) {
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Warning: trying to read doublewrite buffer page %lu\n", offset);
" InnoDB: Warning: trying to read doublewrite buffer page %lu\n",
(ulong) offset);
return(0);
}
@ -126,7 +127,8 @@ buf_read_page_low(
if (buf_debug_prints) {
printf("Posting read request for page %lu, sync %lu\n",
offset, sync);
(ulong) offset,
(ulong) sync);
}
ut_a(block->state == BUF_BLOCK_FILE_PAGE);
@ -268,7 +270,7 @@ buf_read_ahead_random(
" InnoDB: Warning: in random readahead trying to access tablespace\n"
"InnoDB: %lu page no. %lu,\n"
"InnoDB: but the tablespace does not exist or is just being dropped.\n",
space, i);
(ulong) space, (ulong) i);
}
}
}
@ -282,7 +284,8 @@ buf_read_ahead_random(
if (buf_debug_prints && (count > 0)) {
printf("Random read-ahead space %lu offset %lu pages %lu\n",
space, offset, count);
(ulong) space, (ulong) offset,
(ulong) count);
}
return(count);
@ -322,7 +325,7 @@ buf_read_page(
fprintf(stderr,
" InnoDB: error: trying to access tablespace %lu page no. %lu,\n"
"InnoDB: but the tablespace does not exist or is just being dropped.\n",
space, offset);
(ulong) space, (ulong) offset);
}
/* Flush pages from the end of the LRU list if necessary */
@ -549,7 +552,7 @@ buf_read_ahead_linear(
" InnoDB: Warning: in linear readahead trying to access tablespace\n"
"InnoDB: %lu page no. %lu,\n"
"InnoDB: but the tablespace does not exist or is just being dropped.\n",
space, i);
(ulong) space, (ulong) i);
}
}
}
@ -566,7 +569,7 @@ buf_read_ahead_linear(
if (buf_debug_prints && (count > 0)) {
printf(
"LINEAR read-ahead space %lu offset %lu pages %lu\n",
space, offset, count);
(ulong) space, (ulong) offset, (ulong) count);
}
return(count);
@ -627,7 +630,7 @@ buf_read_ibuf_merge_pages(
buf_flush_free_margin();
if (buf_debug_prints) {
printf("Ibuf merge read-ahead pages %lu\n", n_stored);
printf("Ibuf merge read-ahead pages %lu\n", (ulong) n_stored);
}
}
@ -669,7 +672,7 @@ buf_read_recv_pages(
fprintf(stderr,
"InnoDB: Error: InnoDB has waited for 50 seconds for pending\n"
"InnoDB: reads to the buffer pool to be finished.\n"
"InnoDB: Number of pending reads %lu\n", buf_pool->n_pend_reads);
"InnoDB: Number of pending reads %lu\n", (ulong) buf_pool->n_pend_reads);
os_aio_print_debug = TRUE;
}
@ -693,6 +696,7 @@ buf_read_recv_pages(
buf_flush_free_margin();
if (buf_debug_prints) {
printf("Recovery applies read-ahead pages %lu\n", n_stored);
printf("Recovery applies read-ahead pages %lu\n",
(ulong) n_stored);
}
}

5
innobase/com/com0shm.c
View file

@ -959,7 +959,7 @@ loop:
loop_count++;
if (loop_count > 1) {
printf("!!!!!!!!COM_SHM loop count %lu\n", loop_count);
printf("!!!!!!!!COM_SHM loop count %lu\n", (ulong) loop_count);
}
ut_ad(loop_count < 2);
@ -1088,7 +1088,8 @@ loop:
loop_count++;
if (loop_count > 5) {
printf("!!!!!!COM_SHM Notempty loop count %lu\n", loop_count);
printf("!!!!!!COM_SHM Notempty loop count %lu\n",
(ulong) loop_count);
}
ut_ad(loop_count < 100);

18
innobase/data/data0data.c
View file

@ -196,7 +196,8 @@ dfield_check_typed_no_assert(
fprintf(stderr,
"InnoDB: Error: data field type %lu, len %lu\n",
dfield_get_type(field)->mtype, dfield_get_len(field));
(ulong) dfield_get_type(field)->mtype,
(ulong) dfield_get_len(field));
return(FALSE);
}
@ -219,7 +220,7 @@ dtuple_check_typed_no_assert(
if (dtuple_get_n_fields(tuple) > REC_MAX_N_FIELDS) {
fprintf(stderr,
"InnoDB: Error: index entry has %lu fields\n",
dtuple_get_n_fields(tuple));
(ulong) dtuple_get_n_fields(tuple));
dtuple_sprintf(err_buf, 900, tuple);
fprintf(stderr,
@ -259,7 +260,8 @@ dfield_check_typed(
fprintf(stderr,
"InnoDB: Error: data field type %lu, len %lu\n",
dfield_get_type(field)->mtype, dfield_get_len(field));
(ulong) dfield_get_type(field)->mtype,
(ulong) dfield_get_len(field));
ut_a(0);
}
@ -433,7 +435,7 @@ dfield_print_also_hex(
data = dfield_get_data(dfield);
for (i = 0; i < len; i++) {
printf("%02lx", (ulint)*data);
printf("%02lx", (ulong)*data);
data++;
}
@ -459,10 +461,10 @@ dtuple_print(
n_fields = dtuple_get_n_fields(tuple);
printf("DATA TUPLE: %lu fields;\n", n_fields);
printf("DATA TUPLE: %lu fields;\n", (ulong) n_fields);
for (i = 0; i < n_fields; i++) {
printf(" %lu:", i);
printf(" %lu:", (ulong) i);
field = dtuple_get_nth_field(tuple, i);
@ -506,7 +508,7 @@ dtuple_sprintf(
return(len);
}
len += sprintf(buf + len, " %lu:", i);
len += sprintf(buf + len, " %lu:", (ulong) i);
field = dtuple_get_nth_field(tuple, i);
@ -567,7 +569,7 @@ dtuple_convert_big_rec(
if (size > 1000000000) {
fprintf(stderr,
"InnoDB: Warning: tuple size very big: %lu\n", size);
"InnoDB: Warning: tuple size very big: %lu\n", (ulong) size);
dtuple_sprintf(err_buf, 900, entry);
fprintf(stderr,

6
innobase/data/data0type.c
View file

@ -63,7 +63,7 @@ dtype_print(
} else if (mtype == DATA_SYS) {
printf("DATA_SYS");
} else {
printf("type %lu", mtype);
printf("type %lu", (ulong) mtype);
}
len = type->len;
@ -86,9 +86,9 @@ dtype_print(
} else if (prtype == DATA_ENGLISH) {
printf("DATA_ENGLISH");
} else {
printf("prtype %lu", mtype);
printf("prtype %lu", (ulong) mtype);
}
}
printf(" len %lu prec %lu", len, type->prec);
printf(" len %lu prec %lu", (ulong) len, (ulong) type->prec);
}

23
innobase/dict/dict0crea.c
View file

@ -1177,7 +1177,8 @@ dict_create_or_check_foreign_constraint_tables(void)
error = trx->error_state;
if (error != DB_SUCCESS) {
fprintf(stderr, "InnoDB: error %lu in creation\n", error);
fprintf(stderr, "InnoDB: error %lu in creation\n",
(ulong) error);
ut_a(error == DB_OUT_OF_FILE_SPACE);
@ -1256,27 +1257,27 @@ loop:
/* We allocate the new id from the sequence of table id's */
id = dict_hdr_get_new_id(DICT_HDR_TABLE_ID);
sprintf(buf2, "%lu_%lu", ut_dulint_get_high(id),
ut_dulint_get_low(id));
sprintf(buf2, "%lu_%lu", (ulong) ut_dulint_get_high(id),
(ulong) ut_dulint_get_low(id));
foreign->id = mem_heap_alloc(foreign->heap, ut_strlen(buf2) + 1);
ut_memcpy(foreign->id, buf2, ut_strlen(buf2) + 1);
len += sprintf(buf + len,
"INSERT INTO SYS_FOREIGN VALUES('%lu_%lu', '%s', '%s', %lu);\n",
ut_dulint_get_high(id),
ut_dulint_get_low(id),
(ulong) ut_dulint_get_high(id),
(ulong) ut_dulint_get_low(id),
table->name,
foreign->referenced_table_name,
foreign->n_fields
+ (foreign->type << 24));
(ulong) (foreign->n_fields
+ (foreign->type << 24)));
for (i = 0; i < foreign->n_fields; i++) {
len += sprintf(buf + len,
"INSERT INTO SYS_FOREIGN_COLS VALUES('%lu_%lu', %lu, '%s', '%s');\n",
ut_dulint_get_high(id),
ut_dulint_get_low(id),
i,
(ulong) ut_dulint_get_high(id),
(ulong) ut_dulint_get_low(id),
(ulong) i,
foreign->foreign_col_names[i],
foreign->referenced_col_names[i]);
}
@ -1303,7 +1304,7 @@ loop:
if (error != DB_SUCCESS) {
fprintf(stderr,
"InnoDB: Foreign key constraint creation failed:\n"
"InnoDB: internal error number %lu\n", error);
"InnoDB: internal error number %lu\n", (ulong) error);
if (error == DB_DUPLICATE_KEY) {
fprintf(stderr,

27
innobase/dict/dict0dict.c
View file

@ -3804,10 +3804,11 @@ dict_table_print_low(
printf(
"TABLE: name %s, id %lu %lu, columns %lu, indexes %lu, appr.rows %lu\n",
table->name,
ut_dulint_get_high(table->id),
ut_dulint_get_low(table->id),
table->n_cols, UT_LIST_GET_LEN(table->indexes),
(ulint)table->stat_n_rows);
(ulong) ut_dulint_get_high(table->id),
(ulong) ut_dulint_get_low(table->id),
(ulong) table->n_cols,
(ulong) UT_LIST_GET_LEN(table->indexes),
(ulong) table->stat_n_rows);
printf(" COLUMNS: ");
for (i = 0; i < table->n_cols - 1; i++) {
@ -3883,16 +3884,16 @@ dict_index_print_low(
printf(
" INDEX: name %s, table name %s, id %lu %lu, fields %lu/%lu, type %lu\n",
index->name, index->table_name,
ut_dulint_get_high(tree->id),
ut_dulint_get_low(tree->id),
index->n_user_defined_cols,
index->n_fields, index->type);
(ulong) ut_dulint_get_high(tree->id),
(ulong) ut_dulint_get_low(tree->id),
(ulong) index->n_user_defined_cols,
(ulong) index->n_fields, (ulong) index->type);
printf(
" root page %lu, appr.key vals %lu, leaf pages %lu, size pages %lu\n",
tree->page,
(ulint)n_vals,
index->stat_n_leaf_pages,
index->stat_index_size);
(ulong) tree->page,
(ulong) n_vals,
(ulong) index->stat_n_leaf_pages,
(ulong) index->stat_index_size);
printf(" FIELDS: ");
@ -3920,7 +3921,7 @@ dict_field_print_low(
printf(" %s", field->name);
if (field->prefix_len != 0) {
printf("(%lu)", field->prefix_len);
printf("(%lu)", (ulong) field->prefix_len);
}
}

106
innobase/fil/fil0fil.c
View file

@ -432,7 +432,7 @@ fil_node_create(
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Error: Could not find tablespace %lu for\n"
"InnoDB: file %s from the tablespace memory cache.\n", id, name);
"InnoDB: file %s from the tablespace memory cache.\n", (ulong) id, name);
mem_free(name2);
mem_free(node);
@ -583,7 +583,7 @@ fil_try_to_close_file_in_LRU(
if (print_info) {
fprintf(stderr,
"InnoDB: fil_sys open file LRU len %lu\n", UT_LIST_GET_LEN(system->LRU));
"InnoDB: fil_sys open file LRU len %lu\n", (ulong) UT_LIST_GET_LEN(system->LRU));
}
while (node != NULL) {
@ -598,7 +598,7 @@ fil_try_to_close_file_in_LRU(
if (print_info && node->n_pending_flushes > 0) {
fprintf(stderr,
"InnoDB: cannot close file %s, because n_pending_flushes %lu\n", node->name,
node->n_pending_flushes);
(ulong) node->n_pending_flushes);
}
if (print_info
@ -660,7 +660,8 @@ retry:
if (count2 > 20000) {
fprintf(stderr,
"InnoDB: Warning: tablespace %s has i/o ops stopped for a long time %lu\n",
space->name, count2);
space->name,
(ulong) count2);
}
mutex_exit(&(system->mutex));
@ -706,7 +707,7 @@ close_more:
" InnoDB: Warning: too many (%lu) files stay open while the maximum\n"
"InnoDB: allowed value would be %lu.\n"
"InnoDB: You may need to raise the value of innodb_max_files_open in\n"
"InnoDB: my.cnf.\n", system->n_open, system->max_n_open);
"InnoDB: my.cnf.\n", (ulong) system->n_open, (ulong) system->max_n_open);
return;
}
@ -832,7 +833,8 @@ try_again:
"InnoDB: a tablespace %lu of name %s,\n"
"InnoDB: but a tablespace %lu of the same name %s\n"
"InnoDB: already exists in the tablespace memory cache!\n",
id, name, space->id, space->name);
(ulong) id, name,
(ulong) space->id, space->name);
if (id == 0 || purpose != FIL_TABLESPACE) {
@ -866,7 +868,7 @@ try_again:
"InnoDB: Error: trying to add tablespace %lu of name %s\n"
"InnoDB: to the tablespace memory cache, but tablespace\n"
"InnoDB: %lu of name %s already exists in the tablespace\n"
"InnoDB: memory cache!\n", id, name, space->id, space->name);
"InnoDB: memory cache!\n", (ulong) id, name, (ulong) space->id, space->name);
mutex_exit(&(system->mutex));
@ -946,8 +948,8 @@ fil_assign_new_space_id(void)
"InnoDB: Warning: you are running out of new single-table tablespace id's.\n"
"InnoDB: Current counter is %lu and it must not exceed %lu!\n"
"InnoDB: To reset the counter to zero you have to dump all your tables and\n"
"InnoDB: recreate the whole InnoDB installation.\n", id,
SRV_LOG_SPACE_FIRST_ID);
"InnoDB: recreate the whole InnoDB installation.\n", (ulong) id,
(ulong) SRV_LOG_SPACE_FIRST_ID);
}
if (id >= SRV_LOG_SPACE_FIRST_ID) {
@ -956,7 +958,7 @@ fil_assign_new_space_id(void)
"InnoDB: You have run out of single-table tablespace id's!\n"
"InnoDB: Current counter is %lu.\n"
"InnoDB: To reset the counter to zero you have to dump all your tables and\n"
"InnoDB: recreate the whole InnoDB installation.\n", id);
"InnoDB: recreate the whole InnoDB installation.\n", (ulong) id);
system->max_assigned_id--;
id = ULINT_UNDEFINED;
@ -991,7 +993,7 @@ fil_space_free(
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Error: trying to remove tablespace %lu from the cache but\n"
"InnoDB: it is not there.\n", id);
"InnoDB: it is not there.\n", (ulong) id);
mutex_exit(&(system->mutex));
@ -1214,7 +1216,8 @@ fil_open_log_and_system_tablespace_files(void)
"InnoDB: tablespace files open for the whole time mysqld is running, and\n"
"InnoDB: needs to open also some .ibd files if the file-per-table storage\n"
"InnoDB: model is used. Current open files %lu, max allowed open files %lu.\n",
system->n_open, system->max_n_open);
(ulong) system->n_open,
(ulong) system->max_n_open);
}
node = UT_LIST_GET_NEXT(chain, node);
}
@ -1269,7 +1272,7 @@ fil_set_max_space_id_if_bigger(
if (max_id >= SRV_LOG_SPACE_FIRST_ID) {
fprintf(stderr,
"InnoDB: Fatal error: max tablespace id is too high, %lu\n", max_id);
"InnoDB: Fatal error: max tablespace id is too high, %lu\n", (ulong) max_id);
ut_a(0);
}
@ -1464,7 +1467,8 @@ fil_inc_pending_ibuf_merges(
if (space == NULL) {
fprintf(stderr,
"InnoDB: Error: trying to do ibuf merge to a dropped tablespace %lu\n", id);
"InnoDB: Error: trying to do ibuf merge to a dropped tablespace %lu\n",
(ulong) id);
}
if (space == NULL || space->stop_ibuf_merges) {
@ -1497,7 +1501,8 @@ fil_decr_pending_ibuf_merges(
if (space == NULL) {
fprintf(stderr,
"InnoDB: Error: decrementing ibuf merge of a dropped tablespace %lu\n", id);
"InnoDB: Error: decrementing ibuf merge of a dropped tablespace %lu\n",
(ulong) id);
}
if (space != NULL) {
@ -1767,7 +1772,8 @@ stop_ibuf_merges:
fprintf(stderr,
" InnoDB: Warning: trying to delete tablespace %s,\n"
"InnoDB: but there are %lu pending ibuf merges on it.\n"
"InnoDB: Loop %lu.\n", space->name, space->n_pending_ibuf_merges, count);
"InnoDB: Loop %lu.\n", space->name, (ulong) space->n_pending_ibuf_merges,
(ulong) count);
}
mutex_exit(&(system->mutex));
@ -1791,7 +1797,8 @@ try_again:
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Error: cannot delete tablespace %lu\n"
"InnoDB: because it is not found in the tablespace memory cache.\n", id);
"InnoDB: because it is not found in the tablespace memory cache.\n",
(ulong) id);
mutex_exit(&(system->mutex));
@ -1815,8 +1822,9 @@ try_again:
fprintf(stderr,
" InnoDB: Warning: trying to delete tablespace %s,\n"
"InnoDB: but there are %lu flushes and %lu pending i/o's on it\n"
"InnoDB: Loop %lu.\n", space->name, space->n_pending_flushes, node->n_pending,
count);
"InnoDB: Loop %lu.\n", space->name, (ulong) space->n_pending_flushes,
(ulong) node->n_pending,
(ulong) count);
}
mutex_exit(&(system->mutex));
os_thread_sleep(20000);
@ -1892,7 +1900,7 @@ fil_discard_tablespace(
fprintf(stderr,
"InnoDB: Warning: cannot delete tablespace %lu in DISCARD TABLESPACE.\n"
"InnoDB: But let us remove the insert buffer entries for this tablespace.\n",
id);
(ulong) id);
}
/* Remove all insert buffer entries for the tablespace */
@ -1989,7 +1997,8 @@ retry:
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Warning: problems renaming %s to %s, %lu iterations\n",
old_name, new_name, count);
old_name, new_name,
(ulong) count);
}
mutex_enter(&(system->mutex));
@ -2000,7 +2009,7 @@ retry:
fprintf(stderr,
"InnoDB: Error: cannot find space id %lu from the tablespace memory cache\n"
"InnoDB: though the table %s in a rename operation should have that id\n",
id, old_name);
(ulong) id, old_name);
mutex_exit(&(system->mutex));
return(FALSE);
@ -2351,11 +2360,11 @@ fil_reset_too_high_lsns(
" InnoDB: Flush lsn in the tablespace file %lu to be imported\n"
"InnoDB: is %lu %lu, which exceeds current system lsn %lu %lu.\n"
"InnoDB: We reset the lsn's in the file %s.\n",
space_id,
ut_dulint_get_high(flush_lsn),
ut_dulint_get_low(flush_lsn),
ut_dulint_get_high(current_lsn),
ut_dulint_get_low(current_lsn), filepath);
(ulong) space_id,
(ulong) ut_dulint_get_high(flush_lsn),
(ulong) ut_dulint_get_low(flush_lsn),
(ulong) ut_dulint_get_high(current_lsn),
(ulong) ut_dulint_get_low(current_lsn), filepath);
/* Loop through all the pages in the tablespace and reset the lsn and
the page checksum if necessary */
@ -2487,7 +2496,7 @@ fil_open_single_table_tablespace(
fprintf(stderr,
" InnoDB: Error: tablespace id in file %s is %lu, but in the InnoDB\n"
"InnoDB: data dictionary it is %lu.\n", filepath, space_id, id);
"InnoDB: data dictionary it is %lu.\n", filepath, (ulong) space_id, (ulong) id);
fprintf(stderr,
"InnoDB: Have you moved InnoDB .ibd files around without using the\n"
"InnoDB: commands DISCARD TABLESPACE and IMPORT TABLESPACE?\n"
@ -2587,8 +2596,9 @@ fil_load_single_table_tablespace(
if (size < FIL_IBD_FILE_INITIAL_SIZE * UNIV_PAGE_SIZE) {
fprintf(stderr,
"InnoDB: Error: the size of single-table tablespace file %s\n"
"InnoDB: is only %lu %lu, should be at least %lu!", filepath, size_high,
size_low, (ulint)4 * UNIV_PAGE_SIZE);
"InnoDB: is only %lu %lu, should be at least %lu!", filepath,
(ulong) size_high,
(ulong) size_low, (ulong) (4 * UNIV_PAGE_SIZE));
os_file_close(file);
ut_free(filepath);
@ -2612,8 +2622,9 @@ fil_load_single_table_tablespace(
#ifndef UNIV_HOTBACKUP
if (space_id == ULINT_UNDEFINED || space_id == 0) {
fprintf(stderr,
"InnoDB: Error: tablespace id %lu in file %s is not sensible\n", space_id,
filepath);
"InnoDB: Error: tablespace id %lu in file %s is not sensible\n",
(ulong) space_id,
filepath);
goto func_exit;
}
#else
@ -2845,7 +2856,7 @@ fil_print_orphaned_tablespaces(void)
&& !space->mark) {
fprintf(stderr,
"InnoDB: Warning: tablespace %s of id %lu has no matching table in\n"
"InnoDB: the InnoDB data dictionary.\n", space->name, space->id);
"InnoDB: the InnoDB data dictionary.\n", space->name, (ulong) space->id);
}
space = UT_LIST_GET_NEXT(space_list, space);
@ -2996,7 +3007,7 @@ fil_space_for_table_exists_in_mem(
"InnoDB: in InnoDB data dictionary has tablespace id %lu,\n"
"InnoDB: but tablespace with that id or name does not exist. Have\n"
"InnoDB: you deleted or moved .ibd files?\n",
name, id);
name, (ulong) id);
} else {
ut_print_timestamp(stderr);
fprintf(stderr,
@ -3005,7 +3016,8 @@ fil_space_for_table_exists_in_mem(
"InnoDB: but tablespace with that id does not exist. There is\n"
"InnoDB: a tablespace of name %s and id %lu, though. Have\n"
"InnoDB: you deleted or moved .ibd files?\n",
name, id, namespace->name, namespace->id);
name, (ulong) id, namespace->name,
(ulong) namespace->id);
}
fprintf(stderr,
"InnoDB: You can look from section 15.1 of http://www.innodb.com/ibman.html\n"
@ -3022,12 +3034,12 @@ fil_space_for_table_exists_in_mem(
" InnoDB: Error: table %s\n"
"InnoDB: in InnoDB data dictionary has tablespace id %lu,\n"
"InnoDB: but tablespace with that id has name %s.\n"
"InnoDB: Have you deleted or moved .ibd files?\n", name, id, space->name);
"InnoDB: Have you deleted or moved .ibd files?\n", name, (ulong) id, space->name);
if (namespace != NULL) {
fprintf(stderr,
"InnoDB: There is a tablespace with the right name\n"
"InnoDB: %s, but its id is %lu.\n", namespace->name, namespace->id);
"InnoDB: %s, but its id is %lu.\n", namespace->name, (ulong) namespace->id);
}
fprintf(stderr,
@ -3377,7 +3389,8 @@ fil_node_prepare_for_io(
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Warning: open files %lu exceeds the limit %lu\n",
system->n_open, system->max_n_open);
(ulong) system->n_open,
(ulong) system->max_n_open);
}
if (node->open == FALSE) {
@ -3520,7 +3533,8 @@ fil_io(
fprintf(stderr,
" InnoDB: Error: trying to do i/o to a tablespace which does not exist.\n"
"InnoDB: i/o type %lu, space id %lu, page no. %lu, i/o length %lu bytes\n",
type, space_id, block_offset, len);
(ulong) type, (ulong) space_id, (ulong) block_offset,
(ulong) len);
return(DB_TABLESPACE_DELETED);
}
@ -3543,8 +3557,9 @@ fil_io(
"InnoDB: space name %s,\n"
"InnoDB: which is outside the tablespace bounds.\n"
"InnoDB: Byte offset %lu, len %lu, i/o type %lu\n",
block_offset, space_id, space->name, byte_offset, len,
type);
(ulong) block_offset, (ulong) space_id,
space->name, (ulong) byte_offset, (ulong) len,
(ulong) type);
ut_a(0);
}
@ -3571,8 +3586,9 @@ fil_io(
"InnoDB: space name %s,\n"
"InnoDB: which is outside the tablespace bounds.\n"
"InnoDB: Byte offset %lu, len %lu, i/o type %lu\n",
block_offset, space_id, space->name, byte_offset, len,
type);
(ulong) block_offset, (ulong) space_id,
space->name, (ulong) byte_offset, (ulong) len,
(ulong) type);
ut_a(0);
}
@ -3704,8 +3720,8 @@ fil_aio_wait(
if (os_aio_use_native_aio) {
srv_io_thread_op_info[segment] = (char *) "handle native aio";
#ifdef WIN_ASYNC_IO
ret = os_aio_windows_handle(segment, 0, &fil_node, &message,
&type);
ret = os_aio_windows_handle(segment, 0, (void**) &fil_node,
&message, &type);
#elif defined(POSIX_ASYNC_IO)
ret = os_aio_posix_handle(segment, &fil_node, &message);
#else

48
innobase/fsp/fsp0fsp.c
View file

@ -938,7 +938,8 @@ fsp_header_get_space_id(
if (id != fsp_id) {
fprintf(stderr,
"InnoDB: Error: space id in fsp header %lu, but in the page header %lu\n",
fsp_id, id);
(ulong) fsp_id,
(ulong) id);
return(ULINT_UNDEFINED);
}
@ -1108,8 +1109,8 @@ fsp_try_extend_data_file(
fprintf(stderr,
"InnoDB: Error: Last data file size is %lu, max size allowed %lu\n",
srv_data_file_sizes[srv_n_data_files - 1],
srv_last_file_size_max);
(ulong) srv_data_file_sizes[srv_n_data_files - 1],
(ulong) srv_last_file_size_max);
}
size_increase = srv_last_file_size_max
@ -1444,7 +1445,7 @@ fsp_alloc_free_page(
fprintf(stderr,
"InnoDB: Error: trying to extend a single-table tablespace %lu\n"
"InnoDB: by single page(s) though the space size %lu. Page no %lu.\n",
space, space_size, page_no);
(ulong) space, (ulong) space_size, (ulong) page_no);
return(FIL_NULL);
}
success = fsp_try_extend_data_file_with_pages(space, page_no,
@ -1521,7 +1522,8 @@ fsp_free_page(
if (state != XDES_FREE_FRAG && state != XDES_FULL_FRAG) {
fprintf(stderr,
"InnoDB: Error: File space extent descriptor of page %lu has state %lu\n",
page, state);
(ulong) page,
(ulong) state);
ut_sprintf_buf(buf, ((byte*)descr) - 50, 200);
fprintf(stderr, "InnoDB: Dump of descriptor: %s\n", buf);
@ -1540,7 +1542,7 @@ fsp_free_page(
== TRUE) {
fprintf(stderr,
"InnoDB: Error: File space extent descriptor of page %lu says it is free\n",
page);
(ulong) page);
ut_sprintf_buf(buf, ((byte*)descr) - 50, 200);
fprintf(stderr, "InnoDB: Dump of descriptor: %s\n", buf);
@ -2487,7 +2489,8 @@ fseg_alloc_free_page_low(
fprintf(stderr,
"InnoDB: Error (2): trying to extend a single-table tablespace %lu\n"
"InnoDB: by single page(s) though the space size %lu. Page no %lu.\n",
space, space_size, ret_page);
(ulong) space, (ulong) space_size,
(ulong) ret_page);
return(FIL_NULL);
}
@ -2961,7 +2964,7 @@ fseg_free_page_low(
"InnoDB: though it is already marked as free in the tablespace!\n"
"InnoDB: The tablespace free space info is corrupt.\n"
"InnoDB: You may need to dump your InnoDB tables and recreate the whole\n"
"InnoDB: database!\n", page);
"InnoDB: database!\n", (ulong) page);
fprintf(stderr,
"InnoDB: If the InnoDB recovery crashes here, see section 6.1\n"
@ -3016,11 +3019,11 @@ fseg_free_page_low(
"InnoDB: Serious error: InnoDB is trying to free space %lu page %lu,\n"
"InnoDB: which does not belong to segment %lu %lu but belongs\n"
"InnoDB: to segment %lu %lu.\n",
space, page,
ut_dulint_get_high(descr_id),
ut_dulint_get_low(descr_id),
ut_dulint_get_high(seg_id),
ut_dulint_get_low(seg_id));
(ulong) space, (ulong) page,
(ulong) ut_dulint_get_high(descr_id),
(ulong) ut_dulint_get_low(descr_id),
(ulong) ut_dulint_get_high(seg_id),
(ulong) ut_dulint_get_low(seg_id));
fprintf(stderr,
"InnoDB: If the InnoDB recovery crashes here, see section 6.1\n"
@ -3537,11 +3540,13 @@ fseg_print_low(
printf(
"SEGMENT id %lu %lu space %lu; page %lu; res %lu used %lu; full ext %lu\n",
seg_id_high, seg_id_low, space, page_no, reserved, used,
n_full);
(ulong) seg_id_high, (ulong) seg_id_low, (ulong) space,
(ulong) page_no, (ulong) reserved, (ulong) used,
(ulong) n_full);
printf(
"fragm pages %lu; free extents %lu; not full extents %lu: pages %lu\n",
n_frag, n_free, n_not_full, n_used);
(ulong) n_frag, (ulong) n_free, (ulong) n_not_full,
(ulong) n_used);
}
/***********************************************************************
@ -3844,15 +3849,16 @@ fsp_print(
seg_id_low = ut_dulint_get_low(d_var);
seg_id_high = ut_dulint_get_high(d_var);
printf("FILE SPACE INFO: id %lu\n", space);
printf("FILE SPACE INFO: id %lu\n", (ulong) space);
printf("size %lu, free limit %lu, free extents %lu\n",
size, free_limit, n_free);
(ulong) size, (ulong) free_limit, (ulong) n_free);
printf(
"not full frag extents %lu: used pages %lu, full frag extents %lu\n",
n_free_frag, frag_n_used, n_full_frag);
(ulong) n_free_frag, (ulong) frag_n_used, (ulong) n_full_frag);
printf("first seg id not used %lu %lu\n", seg_id_high, seg_id_low);
printf("first seg id not used %lu %lu\n", (ulong) seg_id_high,
(ulong) seg_id_low);
mtr_commit(&mtr);
@ -3931,5 +3937,5 @@ fsp_print(
mtr_commit(&mtr2);
printf("NUMBER of file segments: %lu\n", n_segs);
printf("NUMBER of file segments: %lu\n", (ulong) n_segs);
}

5
innobase/fut/fut0lst.c
View file

@ -511,6 +511,7 @@ flst_print(
printf("FILE-BASED LIST:\n");
printf("Base node in space %lu page %lu byte offset %lu; len %lu\n",
buf_frame_get_space_id(frame), buf_frame_get_page_no(frame),
(ulint) (base - frame), len);
(ulong) buf_frame_get_space_id(frame),
(ulong) buf_frame_get_page_no(frame),
(ulong) (base - frame), (ulong) len);
}

7
innobase/ha/ha0ha.c
View file

@ -323,7 +323,7 @@ ha_validate(
fprintf(stderr,
"InnoDB: Error: hash table node fold value %lu does not\n"
"InnoDB: match with the cell number %lu.\n",
node->fold, i);
(ulong) node->fold, (ulong) i);
ok = FALSE;
}
@ -390,7 +390,8 @@ ha_print_info(
}
buf += sprintf(buf,
"Hash table size %lu, used cells %lu", hash_get_n_cells(table), cells);
"Hash table size %lu, used cells %lu", (ulong) hash_get_n_cells(table),
(ulong) cells);
if (table->heaps == NULL && table->heap != NULL) {
@ -403,6 +404,6 @@ ha_print_info(
n_bufs++;
}
buf += sprintf(buf, ", node heap has %lu buffer(s)\n", n_bufs);
buf += sprintf(buf, ", node heap has %lu buffer(s)\n", (ulong) n_bufs);
}
}

30
innobase/ibuf/ibuf0ibuf.c
View file

@ -509,7 +509,7 @@ ibuf_data_init_for_space(
ibuf_exit();
sprintf(buf, "SYS_IBUF_TABLE_%lu", space);
sprintf(buf, "SYS_IBUF_TABLE_%lu", (ulong) space);
table = dict_mem_table_create(buf, space, 2);
@ -1694,7 +1694,7 @@ ibuf_free_excess_pages(
if (space != 0) {
fprintf(stderr,
"InnoDB: Error: calling ibuf_free_excess_pages for space %lu\n", space);
"InnoDB: Error: calling ibuf_free_excess_pages for space %lu\n", (ulong) space);
return;
}
@ -2714,8 +2714,8 @@ ibuf_insert_to_index_page(
fprintf(stderr,
"InnoDB: Error: Insert buffer insert fails; page free %lu, dtuple size %lu\n",
page_get_max_insert_size(page, 1),
rec_get_converted_size(entry));
(ulong) page_get_max_insert_size(page, 1),
(ulong) rec_get_converted_size(entry));
dtuple_sprintf(errbuf, 900, entry);
@ -2733,7 +2733,7 @@ ibuf_insert_to_index_page(
buf_frame_get_page_no(page),
IBUF_BITMAP_FREE, mtr);
fprintf(stderr, "Bitmap bits %lu\n", old_bits);
fprintf(stderr, "Bitmap bits %lu\n", (ulong) old_bits);
fprintf(stderr,
"InnoDB: Send a detailed bug report to mysql@lists.mysql.com!\n");
@ -2801,7 +2801,8 @@ ibuf_delete_rec(
fprintf(stderr,
"InnoDB: ERROR: Send the output to mysql@lists.mysql.com\n"
"InnoDB: ibuf cursor restoration fails!\n"
"InnoDB: ibuf record inserted to space %lu page %lu\n", space, page_no);
"InnoDB: ibuf record inserted to space %lu page %lu\n", (ulong) space,
(ulong) page_no);
fflush(stderr);
rec_print(btr_pcur_get_rec(pcur));
@ -2998,7 +2999,8 @@ ibuf_merge_or_delete_for_page(
"InnoDB: to determine if they are corrupt after this.\n\n"
"InnoDB: Please make a detailed bug report and send it to\n"
"InnoDB: mysql@lists.mysql.com\n\n",
page_no, fil_page_get_type(page));
(ulong) page_no,
(ulong) fil_page_get_type(page));
}
}
@ -3237,7 +3239,8 @@ leave_loop:
mutex_exit(&ibuf_mutex);
printf("Discarded %lu ibuf entries for space %lu\n", n_inserts, space);
printf("Discarded %lu ibuf entries for space %lu\n", (ulong) n_inserts,
(ulong) space);
ibuf_exit();
@ -3346,7 +3349,9 @@ ibuf_print(
while (data) {
buf += sprintf(buf,
"Ibuf for space %lu: size %lu, free list len %lu, seg size %lu,",
data->space, data->size, data->free_list_len, data->seg_size);
(ulong) data->space, (ulong) data->size,
(ulong) data->free_list_len,
(ulong) data->seg_size);
if (data->empty) {
buf += sprintf(buf, " is empty\n");
@ -3356,13 +3361,16 @@ ibuf_print(
buf += sprintf(buf,
"%lu inserts, %lu merged recs, %lu merges\n",
data->n_inserts, data->n_merged_recs, data->n_merges);
(ulong) data->n_inserts,
(ulong) data->n_merged_recs,
(ulong) data->n_merges);
#ifdef UNIV_IBUF_DEBUG
for (i = 0; i < IBUF_COUNT_N_PAGES; i++) {
if (ibuf_count_get(data->space, i) > 0) {
printf("Ibuf count for page %lu is %lu\n",
i, ibuf_count_get(data->space, i));
(ulong) i,
(ulong) ibuf_count_get(data->space, i));
}
}
#endif

3
innobase/include/univ.i
View file

@ -67,6 +67,7 @@ Microsoft Visual C++ */
#endif /* #if (defined(WIN32) || ... */
#ifdef NOT_USED
/* On the 64-bit Windows we replace printf with ut_printf, etc. so that
we can use the %lu format string to print a 64-bit ulint */
#if defined(__WIN__) && (defined(WIN64) || defined(_WIN64))
@ -74,7 +75,7 @@ we can use the %lu format string to print a 64-bit ulint */
#define sprintf ut_sprintf
#define fprintf ut_fprintf
#endif
#endif
/* DEBUG VERSION CONTROL
===================== */

55
innobase/lock/lock0lock.c
View file

@ -548,10 +548,10 @@ lock_check_trx_id_sanity(
"InnoDB: is %lu %lu which is higher than the global trx id counter %lu %lu!\n"
"InnoDB: The table is corrupt. You have to do dump + drop + reimport.\n",
err_buf, index->table_name, index->name,
ut_dulint_get_high(trx_id),
ut_dulint_get_low(trx_id),
ut_dulint_get_high(trx_sys->max_trx_id),
ut_dulint_get_low(trx_sys->max_trx_id));
(ulong) ut_dulint_get_high(trx_id),
(ulong) ut_dulint_get_low(trx_id),
(ulong) ut_dulint_get_high(trx_sys->max_trx_id),
(ulong) ut_dulint_get_low(trx_sys->max_trx_id));
is_ok = FALSE;
}
@ -1802,7 +1802,8 @@ index->table_name);
if (lock_print_waits) {
printf("Lock wait for trx %lu in index %s\n",
ut_dulint_get_low(trx->id), index->name);
(ulong) ut_dulint_get_low(trx->id),
index->name);
}
return(DB_LOCK_WAIT);
@ -2129,7 +2130,7 @@ lock_grant(
if (lock_print_waits) {
printf("Lock wait for trx %lu ends\n",
ut_dulint_get_low(lock->trx->id));
(ulong) ut_dulint_get_low(lock->trx->id));
}
/* If we are resolving a deadlock by choosing another transaction
@ -3814,7 +3815,7 @@ lock_table_print(
buf += sprintf(buf, "TABLE LOCK table %s trx id %lu %lu",
lock->un_member.tab_lock.table->name,
(lock->trx)->id.high, (lock->trx)->id.low);
(ulong) (lock->trx)->id.high, (ulong) (lock->trx)->id.low);
if (lock_get_mode(lock) == LOCK_S) {
buf += sprintf(buf, " lock mode S");
@ -3828,7 +3829,7 @@ lock_table_print(
buf += sprintf(buf, " lock_mode AUTO-INC");
} else {
buf += sprintf(buf,
" unknown lock_mode %lu", lock_get_mode(lock));
" unknown lock_mode %lu", (ulong) lock_get_mode(lock));
}
if (lock_get_wait(lock)) {
@ -3863,11 +3864,13 @@ lock_rec_print(
page_no = lock->un_member.rec_lock.page_no;
buf += sprintf(buf, "RECORD LOCKS space id %lu page no %lu n bits %lu",
space, page_no, lock_rec_get_n_bits(lock));
(ulong) space, (ulong) page_no,
(ulong) lock_rec_get_n_bits(lock));
buf += sprintf(buf, " table %s index %s trx id %lu %lu",
lock->index->table->name, lock->index->name,
(lock->trx)->id.high, (lock->trx)->id.low);
lock->index->table->name, lock->index->name,
(ulong) (lock->trx)->id.high,
(ulong) (lock->trx)->id.low);
if (lock_get_mode(lock) == LOCK_S) {
buf += sprintf(buf, " lock mode S");
@ -3935,7 +3938,8 @@ lock_rec_print(
if (lock_rec_get_nth_bit(lock, i)) {
buf += sprintf(buf, "Record lock, heap no %lu ", i);
buf += sprintf(buf, "Record lock, heap no %lu ",
(ulong) i);
if (page) {
buf += rec_sprintf(buf, 120,
@ -4038,19 +4042,19 @@ lock_print_info(
"------------\n");
buf += sprintf(buf, "Trx id counter %lu %lu\n",
ut_dulint_get_high(trx_sys->max_trx_id),
ut_dulint_get_low(trx_sys->max_trx_id));
(ulong) ut_dulint_get_high(trx_sys->max_trx_id),
(ulong) ut_dulint_get_low(trx_sys->max_trx_id));
buf += sprintf(buf,
"Purge done for trx's n:o < %lu %lu undo n:o < %lu %lu\n",
ut_dulint_get_high(purge_sys->purge_trx_no),
ut_dulint_get_low(purge_sys->purge_trx_no),
ut_dulint_get_high(purge_sys->purge_undo_no),
ut_dulint_get_low(purge_sys->purge_undo_no));
(ulong) ut_dulint_get_high(purge_sys->purge_trx_no),
(ulong) ut_dulint_get_low(purge_sys->purge_trx_no),
(ulong) ut_dulint_get_high(purge_sys->purge_undo_no),
(ulong) ut_dulint_get_low(purge_sys->purge_undo_no));
buf += sprintf(buf,
"Total number of lock structs in row lock hash table %lu\n",
lock_get_n_rec_locks());
(ulong) lock_get_n_rec_locks());
buf += sprintf(buf, "LIST OF TRANSACTIONS FOR EACH SESSION:\n");
@ -4122,16 +4126,16 @@ loop:
if (trx->read_view) {
buf += sprintf(buf,
"Trx read view will not see trx with id >= %lu %lu, sees < %lu %lu\n",
ut_dulint_get_high(trx->read_view->low_limit_id),
ut_dulint_get_low(trx->read_view->low_limit_id),
ut_dulint_get_high(trx->read_view->up_limit_id),
ut_dulint_get_low(trx->read_view->up_limit_id));
(ulong) ut_dulint_get_high(trx->read_view->low_limit_id),
(ulong) ut_dulint_get_low(trx->read_view->low_limit_id),
(ulong) ut_dulint_get_high(trx->read_view->up_limit_id),
(ulong) ut_dulint_get_low(trx->read_view->up_limit_id));
}
if (trx->que_state == TRX_QUE_LOCK_WAIT) {
buf += sprintf(buf,
"------- TRX HAS BEEN WAITING %lu SEC FOR THIS LOCK TO BE GRANTED:\n",
(ulint)difftime(time(NULL), trx->wait_started));
(ulong)difftime(time(NULL), trx->wait_started));
if (lock_get_type(trx->wait_lock) == LOCK_REC) {
lock_rec_print(buf, trx->wait_lock);
@ -4422,7 +4426,8 @@ loop:
index = lock->index;
rec = page_find_rec_with_heap_no(page, i);
printf("Validating %lu %lu\n", space, page_no);
printf("Validating %lu %lu\n", (ulong) space,
(ulong) page_no);
lock_mutex_exit_kernel();

89
innobase/log/log0log.c
View file

@ -342,7 +342,8 @@ log_close(void)
"InnoDB: If you are using big BLOB or TEXT rows, you must set the\n"
"InnoDB: combined size of log files at least 10 times bigger than the\n"
"InnoDB: largest such row.\n",
checkpoint_age, log->log_group_capacity);
(ulong) checkpoint_age,
(ulong) log->log_group_capacity);
}
}
@ -898,7 +899,8 @@ log_group_check_flush_completion(
if (!log_sys->one_flushed && group->n_pending_writes == 0) {
if (log_debug_writes) {
printf("Log flushed first to group %lu\n", group->id);
printf("Log flushed first to group %lu\n",
(ulong) group->id);
}
log_sys->written_to_some_lsn = log_sys->write_lsn;
@ -909,7 +911,7 @@ log_group_check_flush_completion(
if (log_debug_writes && (group->n_pending_writes == 0)) {
printf("Log flushed to group %lu\n", group->id);
printf("Log flushed to group %lu\n", (ulong) group->id);
}
return(0);
@ -1049,8 +1051,8 @@ log_group_file_header_flush(
if (log_debug_writes) {
printf(
"Writing log file header to group %lu file %lu\n", group->id,
nth_file);
"Writing log file header to group %lu file %lu\n",
(ulong) group->id, (ulong) nth_file);
}
if (log_do_write) {
@ -1139,13 +1141,14 @@ loop:
printf(
"Writing log file segment to group %lu offset %lu len %lu\n"
"start lsn %lu %lu\n",
group->id, next_offset, write_len,
ut_dulint_get_high(start_lsn),
ut_dulint_get_low(start_lsn));
(ulong) group->id, (ulong) next_offset,
(ulong) write_len,
(ulong) ut_dulint_get_high(start_lsn),
(ulong) ut_dulint_get_low(start_lsn));
printf(
"First block n:o %lu last block n:o %lu\n",
log_block_get_hdr_no(buf),
log_block_get_hdr_no(
(ulong) log_block_get_hdr_no(buf),
(ulong) log_block_get_hdr_no(
buf + write_len - OS_FILE_LOG_BLOCK_SIZE));
ut_a(log_block_get_hdr_no(buf)
== log_block_convert_lsn_to_no(start_lsn));
@ -1286,10 +1289,10 @@ loop:
if (log_debug_writes) {
printf("Writing log from %lu %lu up to lsn %lu %lu\n",
ut_dulint_get_high(log_sys->written_to_all_lsn),
ut_dulint_get_low(log_sys->written_to_all_lsn),
ut_dulint_get_high(log_sys->lsn),
ut_dulint_get_low(log_sys->lsn));
(ulong) ut_dulint_get_high(log_sys->written_to_all_lsn),
(ulong) ut_dulint_get_low(log_sys->written_to_all_lsn),
(ulong) ut_dulint_get_high(log_sys->lsn),
(ulong) ut_dulint_get_low(log_sys->lsn));
}
log_sys->n_pending_writes++;
@ -1525,7 +1528,8 @@ log_io_complete_checkpoint(
log_sys->n_pending_checkpoint_writes--;
if (log_debug_writes) {
printf("Checkpoint info written to group %lu\n", group->id);
printf("Checkpoint info written to group %lu\n",
(ulong) group->id);
}
if (log_sys->n_pending_checkpoint_writes == 0) {
@ -1848,9 +1852,9 @@ log_checkpoint(
if (log_debug_writes) {
printf("Making checkpoint no %lu at lsn %lu %lu\n",
ut_dulint_get_low(log_sys->next_checkpoint_no),
ut_dulint_get_high(oldest_lsn),
ut_dulint_get_low(oldest_lsn));
(ulong) ut_dulint_get_low(log_sys->next_checkpoint_no),
(ulong) ut_dulint_get_high(oldest_lsn),
(ulong) ut_dulint_get_low(oldest_lsn));
}
log_groups_write_checkpoint_info();
@ -2079,7 +2083,7 @@ log_archived_file_name_gen(
UT_NOT_USED(id); /* Currently we only archive the first group */
sprintf(buf, "%sib_arch_log_%010lu", srv_arch_dir, file_no);
sprintf(buf, "%sib_arch_log_%010lu", srv_arch_dir, (ulong) file_no);
}
/**********************************************************
@ -2262,9 +2266,9 @@ loop:
if (log_debug_writes) {
printf(
"Archiving starting at lsn %lu %lu, len %lu to group %lu\n",
ut_dulint_get_high(start_lsn),
ut_dulint_get_low(start_lsn),
len, group->id);
(ulong) ut_dulint_get_high(start_lsn),
(ulong) ut_dulint_get_low(start_lsn),
(ulong) len, (ulong) group->id);
}
log_sys->n_pending_archive_ios++;
@ -2358,7 +2362,7 @@ log_archive_write_complete_groups(void)
if (log_debug_writes && trunc_files) {
printf("Complete file(s) archived to group %lu\n",
group->id);
(ulong) group->id);
}
/* Calculate the archive file space start lsn */
@ -2554,10 +2558,10 @@ loop:
if (log_debug_writes) {
printf("Archiving from lsn %lu %lu to lsn %lu %lu\n",
ut_dulint_get_high(log_sys->archived_lsn),
ut_dulint_get_low(log_sys->archived_lsn),
ut_dulint_get_high(limit_lsn),
ut_dulint_get_low(limit_lsn));
(ulong) ut_dulint_get_high(log_sys->archived_lsn),
(ulong) ut_dulint_get_low(log_sys->archived_lsn),
(ulong) ut_dulint_get_high(limit_lsn),
(ulong) ut_dulint_get_low(limit_lsn));
}
/* Read the log segment to the archive buffer */
@ -2666,7 +2670,8 @@ log_archive_close_groups(
if (log_debug_writes) {
printf(
"Incrementing arch file no to %lu in log group %lu\n",
group->archived_file_no + 2, group->id);
(ulong) group->archived_file_no + 2,
(ulong) group->id);
}
}
}
@ -3117,10 +3122,10 @@ loop:
fprintf(stderr,
"InnoDB: Error: log sequence number at shutdown %lu %lu\n"
"InnoDB: is lower than at startup %lu %lu!\n",
ut_dulint_get_high(lsn),
ut_dulint_get_low(lsn),
ut_dulint_get_high(srv_start_lsn),
ut_dulint_get_low(srv_start_lsn));
(ulong) ut_dulint_get_high(lsn),
(ulong) ut_dulint_get_low(lsn),
(ulong) ut_dulint_get_high(srv_start_lsn),
(ulong) ut_dulint_get_low(srv_start_lsn));
}
srv_shutdown_lsn = lsn;
@ -3232,12 +3237,12 @@ log_print(
buf += sprintf(buf, "Log sequence number %lu %lu\n"
"Log flushed up to %lu %lu\n"
"Last checkpoint at %lu %lu\n",
ut_dulint_get_high(log_sys->lsn),
ut_dulint_get_low(log_sys->lsn),
ut_dulint_get_high(log_sys->flushed_to_disk_lsn),
ut_dulint_get_low(log_sys->flushed_to_disk_lsn),
ut_dulint_get_high(log_sys->last_checkpoint_lsn),
ut_dulint_get_low(log_sys->last_checkpoint_lsn));
(ulong) ut_dulint_get_high(log_sys->lsn),
(ulong) ut_dulint_get_low(log_sys->lsn),
(ulong) ut_dulint_get_high(log_sys->flushed_to_disk_lsn),
(ulong) ut_dulint_get_low(log_sys->flushed_to_disk_lsn),
(ulong) ut_dulint_get_high(log_sys->last_checkpoint_lsn),
(ulong) ut_dulint_get_low(log_sys->last_checkpoint_lsn));
current_time = time(NULL);
@ -3246,10 +3251,10 @@ log_print(
buf += sprintf(buf,
"%lu pending log writes, %lu pending chkp writes\n"
"%lu log i/o's done, %.2f log i/o's/second\n",
log_sys->n_pending_writes,
log_sys->n_pending_checkpoint_writes,
log_sys->n_log_ios,
(log_sys->n_log_ios - log_sys->n_log_ios_old) / time_elapsed);
(ulong) log_sys->n_pending_writes,
(ulong) log_sys->n_pending_checkpoint_writes,
(ulong) log_sys->n_log_ios,
((log_sys->n_log_ios - log_sys->n_log_ios_old) / time_elapsed));
log_sys->n_log_ios_old = log_sys->n_log_ios;
log_sys->last_printout_time = current_time;

118
innobase/log/log0recv.c
View file

@ -165,7 +165,8 @@ recv_sys_empty_hash(void)
fprintf(stderr,
"InnoDB: Error: %lu pages with log records were left unprocessed!\n"
"InnoDB: Maximum page number with log records on it %lu\n",
recv_sys->n_addrs, recv_max_parsed_page_no);
(ulong) recv_sys->n_addrs,
(ulong) recv_max_parsed_page_no);
ut_a(0);
}
@ -480,8 +481,9 @@ recv_find_max_checkpoint(
if (log_debug_writes) {
fprintf(stderr,
"InnoDB: Checkpoint in group %lu at %lu invalid, %lu\n",
group->id, field,
mach_read_from_4(buf
(ulong) group->id,
(ulong) field,
(ulong) mach_read_from_4(buf
+ LOG_CHECKPOINT_CHECKSUM_1));
}
@ -501,7 +503,8 @@ recv_find_max_checkpoint(
if (log_debug_writes) {
fprintf(stderr,
"InnoDB: Checkpoint number %lu found in group %lu\n",
ut_dulint_get_low(checkpoint_no), group->id);
(ulong) ut_dulint_get_low(checkpoint_no),
(ulong) group->id);
}
if (ut_dulint_cmp(checkpoint_no, max_no) >= 0) {
@ -1136,8 +1139,9 @@ recv_recover_page(
if (log_debug_writes) {
fprintf(stderr,
"InnoDB: Applying log rec type %lu len %lu to space %lu page no %lu\n",
(ulint)recv->type, recv->len, recv_addr->space,
recv_addr->page_no);
(ulong) recv->type, (ulong) recv->len,
(ulong) recv_addr->space,
(ulong) recv_addr->page_no);
}
recv_parse_or_apply_log_rec_body(recv->type, buf,
@ -1327,7 +1331,7 @@ loop:
/ hash_get_n_cells(recv_sys->addr_hash)) {
fprintf(stderr, "%lu ",
(i * 100) / hash_get_n_cells(recv_sys->addr_hash));
(ulong) ((i * 100) / hash_get_n_cells(recv_sys->addr_hash)));
}
}
@ -1833,19 +1837,19 @@ recv_report_corrupt_log(
"InnoDB: ############### CORRUPT LOG RECORD FOUND\n"
"InnoDB: Log record type %lu, space id %lu, page number %lu\n"
"InnoDB: Log parsing proceeded successfully up to %lu %lu\n",
(ulint)type, space, page_no,
ut_dulint_get_high(recv_sys->recovered_lsn),
ut_dulint_get_low(recv_sys->recovered_lsn));
(ulong) type, (ulong) space, (ulong) page_no,
(ulong) ut_dulint_get_high(recv_sys->recovered_lsn),
(ulong) ut_dulint_get_low(recv_sys->recovered_lsn));
err_buf = ut_malloc(1000000);
fprintf(stderr,
"InnoDB: Previous log record type %lu, is multi %lu\n"
"InnoDB: Recv offset %lu, prev %lu\n",
recv_previous_parsed_rec_type,
recv_previous_parsed_rec_is_multi,
(ulint)(ptr - recv_sys->buf),
recv_previous_parsed_rec_offset);
(ulong) recv_previous_parsed_rec_type,
(ulong) recv_previous_parsed_rec_is_multi,
(ulong) (ptr - recv_sys->buf),
(ulong) recv_previous_parsed_rec_offset);
if ((ulint)(ptr - recv_sys->buf + 100)
> recv_previous_parsed_rec_offset
@ -1959,7 +1963,8 @@ loop:
if (log_debug_writes) {
fprintf(stderr,
"InnoDB: Parsed a single log rec type %lu len %lu space %lu page no %lu\n",
(ulint)type, len, space, page_no);
(ulong) type, (ulong) len, (ulong) space,
(ulong) page_no);
}
if (type == MLOG_DUMMY_RECORD) {
@ -2042,7 +2047,8 @@ loop:
if (log_debug_writes) {
fprintf(stderr,
"InnoDB: Parsed a multi log rec type %lu len %lu space %lu page no %lu\n",
(ulint)type, len, space, page_no);
(ulong) type, (ulong) len, (ulong) space,
(ulong) page_no);
}
total_len += len;
@ -2272,10 +2278,11 @@ recv_scan_log_recs(
fprintf(stderr,
"InnoDB: Log block no %lu at lsn %lu %lu has\n"
"InnoDB: ok header, but checksum field contains %lu, should be %lu\n",
no, ut_dulint_get_high(scanned_lsn),
ut_dulint_get_low(scanned_lsn),
log_block_get_checksum(log_block),
log_block_calc_checksum(log_block));
(ulong) no,
(ulong) ut_dulint_get_high(scanned_lsn),
(ulong) ut_dulint_get_low(scanned_lsn),
(ulong) log_block_get_checksum(log_block),
(ulong) log_block_calc_checksum(log_block));
}
/* Garbage or an incompletely written log block */
@ -2380,8 +2387,8 @@ recv_scan_log_recs(
fprintf(stderr,
"InnoDB: Doing recovery: scanned up to log sequence number %lu %lu\n",
ut_dulint_get_high(*group_scanned_lsn),
ut_dulint_get_low(*group_scanned_lsn));
(ulong) ut_dulint_get_high(*group_scanned_lsn),
(ulong) ut_dulint_get_low(*group_scanned_lsn));
}
}
@ -2451,9 +2458,9 @@ recv_group_scan_log_recs(
if (log_debug_writes) {
fprintf(stderr,
"InnoDB: Scanned group %lu up to log sequence number %lu %lu\n",
group->id,
ut_dulint_get_high(*group_scanned_lsn),
ut_dulint_get_low(*group_scanned_lsn));
(ulong) group->id,
(ulong) ut_dulint_get_high(*group_scanned_lsn),
(ulong) ut_dulint_get_low(*group_scanned_lsn));
}
}
@ -2597,12 +2604,12 @@ recv_recovery_from_checkpoint_start(
"InnoDB: sequence numbers stamped to ibdata file headers are between\n"
"InnoDB: %lu %lu and %lu %lu.\n"
"InnoDB: ##########################################################\n",
ut_dulint_get_high(checkpoint_lsn),
ut_dulint_get_low(checkpoint_lsn),
ut_dulint_get_high(min_flushed_lsn),
ut_dulint_get_low(min_flushed_lsn),
ut_dulint_get_high(max_flushed_lsn),
ut_dulint_get_low(max_flushed_lsn));
(ulong) ut_dulint_get_high(checkpoint_lsn),
(ulong) ut_dulint_get_low(checkpoint_lsn),
(ulong) ut_dulint_get_high(min_flushed_lsn),
(ulong) ut_dulint_get_low(min_flushed_lsn),
(ulong) ut_dulint_get_high(max_flushed_lsn),
(ulong) ut_dulint_get_low(max_flushed_lsn));
}
recv_needed_recovery = TRUE;
@ -2637,8 +2644,8 @@ recv_recovery_from_checkpoint_start(
fprintf(stderr,
" InnoDB: Starting log scan based on checkpoint at\n"
"InnoDB: log sequence number %lu %lu.\n",
ut_dulint_get_high(checkpoint_lsn),
ut_dulint_get_low(checkpoint_lsn));
(ulong) ut_dulint_get_high(checkpoint_lsn),
(ulong) ut_dulint_get_low(checkpoint_lsn));
} else {
/* Init the doublewrite buffer memory structure */
trx_sys_doublewrite_init_or_restore_pages(FALSE);
@ -2722,10 +2729,10 @@ recv_recovery_from_checkpoint_start(
" InnoDB: ERROR: We were only able to scan the log up to\n"
"InnoDB: %lu %lu, but a checkpoint was at %lu %lu.\n"
"InnoDB: It is possible that the database is now corrupt!\n",
ut_dulint_get_high(group_scanned_lsn),
ut_dulint_get_low(group_scanned_lsn),
ut_dulint_get_high(checkpoint_lsn),
ut_dulint_get_low(checkpoint_lsn));
(ulong) ut_dulint_get_high(group_scanned_lsn),
(ulong) ut_dulint_get_low(group_scanned_lsn),
(ulong) ut_dulint_get_high(checkpoint_lsn),
(ulong) ut_dulint_get_low(checkpoint_lsn));
}
if (ut_dulint_cmp(group_scanned_lsn, recv_max_page_lsn) < 0) {
@ -2734,10 +2741,10 @@ recv_recovery_from_checkpoint_start(
" InnoDB: ERROR: We were only able to scan the log up to %lu %lu\n"
"InnoDB: but a database page a had an lsn %lu %lu. It is possible that the\n"
"InnoDB: database is now corrupt!\n",
ut_dulint_get_high(group_scanned_lsn),
ut_dulint_get_low(group_scanned_lsn),
ut_dulint_get_high(recv_max_page_lsn),
ut_dulint_get_low(recv_max_page_lsn));
(ulong) ut_dulint_get_high(group_scanned_lsn),
(ulong) ut_dulint_get_low(group_scanned_lsn),
(ulong) ut_dulint_get_high(recv_max_page_lsn),
(ulong) ut_dulint_get_low(recv_max_page_lsn));
}
if (ut_dulint_cmp(recv_sys->recovered_lsn, checkpoint_lsn) < 0) {
@ -2770,10 +2777,10 @@ recv_recovery_from_checkpoint_start(
fprintf(stderr,
"InnoDB: Warning: we did not need to do crash recovery, but log scan\n"
"InnoDB: progressed past the checkpoint lsn %lu %lu up to lsn %lu %lu\n",
ut_dulint_get_high(checkpoint_lsn),
ut_dulint_get_low(checkpoint_lsn),
ut_dulint_get_high(recv_sys->recovered_lsn),
ut_dulint_get_low(recv_sys->recovered_lsn));
(ulong) ut_dulint_get_high(checkpoint_lsn),
(ulong) ut_dulint_get_low(checkpoint_lsn),
(ulong) ut_dulint_get_high(recv_sys->recovered_lsn),
(ulong) ut_dulint_get_low(recv_sys->recovered_lsn));
}
} else {
srv_start_lsn = recv_sys->recovered_lsn;
@ -2950,7 +2957,7 @@ recv_reset_log_files_for_backup(
for (i = 0; i < n_log_files; i++) {
sprintf(name, "%sib_logfile%lu", log_dir, i);
sprintf(name, "%sib_logfile%lu", log_dir, (ulong) i);
log_file = os_file_create_simple(name, OS_FILE_CREATE,
OS_FILE_READ_WRITE, &success);
@ -2962,8 +2969,8 @@ recv_reset_log_files_for_backup(
}
printf(
"Setting log file size to %lu %lu\n", ut_get_high32(log_file_size),
log_file_size & 0xFFFFFFFFUL);
"Setting log file size to %lu %lu\n", (ulong) ut_get_high32(log_file_size),
(ulong) (log_file_size & 0xFFFFFFFFUL));
success = os_file_set_size(name, log_file,
log_file_size & 0xFFFFFFFFUL,
@ -2971,8 +2978,9 @@ recv_reset_log_files_for_backup(
if (!success) {
printf(
"InnoDB: Cannot set %s size to %lu %lu\n", name, ut_get_high32(log_file_size),
log_file_size & 0xFFFFFFFFUL);
"InnoDB: Cannot set %s size to %lu %lu\n", name,
(ulong) ut_get_high32(log_file_size),
(ulong) (log_file_size & 0xFFFFFFFFUL));
exit(1);
}
@ -2987,7 +2995,7 @@ recv_reset_log_files_for_backup(
log_block_init_in_old_format(buf + LOG_FILE_HDR_SIZE, lsn);
log_block_set_first_rec_group(buf + LOG_FILE_HDR_SIZE,
LOG_BLOCK_HDR_SIZE);
sprintf(name, "%sib_logfile%lu", log_dir, 0UL);
sprintf(name, "%sib_logfile%lu", log_dir, (ulong) 0);
log_file = os_file_create_simple(name, OS_FILE_OPEN,
OS_FILE_READ_WRITE, &success);
@ -3151,9 +3159,9 @@ ask_again:
if (log_debug_writes) {
fprintf(stderr,
"InnoDB: Archive read starting at lsn %lu %lu, len %lu from file %s\n",
ut_dulint_get_high(start_lsn),
ut_dulint_get_low(start_lsn),
len, name);
(ulong) ut_dulint_get_high(start_lsn),
(ulong) ut_dulint_get_low(start_lsn),
(ulong) len, name);
}
fil_io(OS_FILE_READ | OS_FILE_LOG, TRUE,
@ -3234,7 +3242,7 @@ recv_recovery_from_archive_start(
if (!group) {
fprintf(stderr,
"InnoDB: There is no log group defined with id %lu!\n",
group_id);
(ulong) group_id);
return(DB_ERROR);
}

30
innobase/mem/mem0dbg.c
View file

@ -333,7 +333,7 @@ mem_hash_remove(
if (node == NULL) {
printf(
"Memory heap or buffer freed in %s line %lu did not exist.\n",
file_name, line);
file_name, (ulong) line);
ut_error;
}
@ -348,9 +348,10 @@ mem_hash_remove(
if (error) {
printf(
"Inconsistency in memory heap or buffer n:o %lu created\n",
node->nth_heap);
(ulong) node->nth_heap);
printf("in %s line %lu and tried to free in %s line %lu.\n",
node->file_name, node->line, file_name, line);
node->file_name, (ulong) node->line,
file_name, (ulong) line);
printf(
"Hex dump of 400 bytes around memory heap first block start:\n");
@ -443,8 +444,8 @@ mem_heap_validate_or_print(
&& (mem_block_get_len(block) > UNIV_PAGE_SIZE)) {
fprintf(stderr,
"InnoDB: Error: mem block %lx length %lu > UNIV_PAGE_SIZE\n", (ulint)block,
mem_block_get_len(block));
"InnoDB: Error: mem block %lx length %lu > UNIV_PAGE_SIZE\n", (ulong) block,
(ulong) mem_block_get_len(block));
/* error */
return;
@ -556,7 +557,8 @@ mem_heap_print(
&us_size, &phys_size, &n_blocks);
printf(
"\nheap type: %lu; size: user size %lu; physical size %lu; blocks %lu.\n",
heap->type, us_size, phys_size, n_blocks);
(ulong) heap->type, (ulong) us_size,
(ulong) phys_size, (ulong) n_blocks);
ut_a(!error);
}
@ -894,8 +896,8 @@ mem_analyze_corruption(
if (*((ulint*)p) == MEM_BLOCK_MAGIC_N) {
fprintf(stderr,
"Mem block at - %lu, file %s, line %lu\n",
dist, p + sizeof(ulint),
*(ulint*)(p + 8 + sizeof(ulint)));
(ulong) dist, (p + sizeof(ulint)),
(ulong) (*(ulint*)(p + 8 + sizeof(ulint))));
break;
}
@ -903,8 +905,8 @@ mem_analyze_corruption(
if (*((ulint*)p) == MEM_FREED_BLOCK_MAGIC_N) {
fprintf(stderr,
"Freed mem block at - %lu, file %s, line %lu\n",
dist, p + sizeof(ulint),
*(ulint*)(p + 8 + sizeof(ulint)));
(ulong) dist, (p + sizeof(ulint)),
(ulong) (*(ulint*)(p + 8 + sizeof(ulint))));
break;
}
@ -931,8 +933,8 @@ mem_analyze_corruption(
if (*((ulint*)p) == MEM_BLOCK_MAGIC_N) {
fprintf(stderr,
"Mem block at + %lu, file %s, line %lu\n",
dist, p + sizeof(ulint),
*(ulint*)(p + 8 + sizeof(ulint)));
(ulong) dist, (p + sizeof(ulint)),
(ulong) (*(ulint*)(p + 8 + sizeof(ulint))));
break;
}
@ -940,8 +942,8 @@ mem_analyze_corruption(
if (*((ulint*)p) == MEM_FREED_BLOCK_MAGIC_N) {
fprintf(stderr,
"Freed mem block at + %lu, file %s, line %lu\n",
dist, p + sizeof(ulint),
*(ulint*)(p + 8 + sizeof(ulint)));
(ulong) dist, (p + sizeof(ulint)),
(ulong) (*(ulint*)(p + 8 + sizeof(ulint))));
break;
}

17
innobase/mem/mem0pool.c
View file

@ -279,7 +279,8 @@ mem_pool_fill_free_list(
fprintf(stderr,
" InnoDB: Error: mem pool free list %lu length is %lu\n"
"InnoDB: though the list is empty!\n",
i + 1, UT_LIST_GET_LEN(pool->free_list[i + 1]));
(ulong) i + 1,
(ulong) UT_LIST_GET_LEN(pool->free_list[i + 1]));
}
ret = mem_pool_fill_free_list(i + 1, pool);
@ -360,7 +361,7 @@ mem_area_alloc(
fprintf(stderr,
"InnoDB: Error: Removing element from mem pool free list %lu though the\n"
"InnoDB: element is not marked free!\n",
n);
(ulong) n);
mem_analyze_corruption((byte*)area);
@ -380,7 +381,7 @@ mem_area_alloc(
fprintf(stderr,
"InnoDB: Error: Removing element from mem pool free list %lu\n"
"InnoDB: though the list length is 0!\n",
n);
(ulong) n);
mem_analyze_corruption((byte*)area);
ut_a(0);
@ -504,7 +505,7 @@ mem_area_free(
fprintf(stderr,
"InnoDB: Error: Memory area size %lu, next area size %lu not a power of 2!\n"
"InnoDB: Possibly a memory overrun of the buffer being freed here.\n",
size, next_size);
(ulong) size, (ulong) next_size);
mem_analyze_corruption((byte*)area);
ut_a(0);
@ -632,13 +633,13 @@ mem_pool_print_info(
fprintf(outfile,
"Free list length %lu for blocks of size %lu\n",
UT_LIST_GET_LEN(pool->free_list[i]),
ut_2_exp(i));
(ulong) UT_LIST_GET_LEN(pool->free_list[i]),
(ulong) ut_2_exp(i));
}
}
fprintf(outfile, "Pool size %lu, reserved %lu.\n", pool->size,
pool->reserved);
fprintf(outfile, "Pool size %lu, reserved %lu.\n", (ulong) pool->size,
(ulong) pool->reserved);
mutex_exit(&(pool->mutex));
}

8
innobase/mtr/mtr0log.c
View file

@ -58,7 +58,7 @@ mlog_write_initial_log_record(
if (ptr < buf_pool->frame_zero || ptr >= buf_pool->high_end) {
fprintf(stderr,
"InnoDB: Error: trying to write to a stray memory location %lx\n",
(ulint)ptr);
(ulong) ptr);
ut_a(0);
}
@ -221,7 +221,7 @@ mlog_write_ulint(
if (ptr < buf_pool->frame_zero || ptr >= buf_pool->high_end) {
fprintf(stderr,
"InnoDB: Error: trying to write to a stray memory location %lx\n",
(ulint)ptr);
(ulong) ptr);
ut_a(0);
}
@ -269,7 +269,7 @@ mlog_write_dulint(
if (ptr < buf_pool->frame_zero || ptr >= buf_pool->high_end) {
fprintf(stderr,
"InnoDB: Error: trying to write to a stray memory location %lx\n",
(ulint)ptr);
(ulong) ptr);
ut_a(0);
}
@ -313,7 +313,7 @@ mlog_write_string(
if (ptr < buf_pool->frame_zero || ptr >= buf_pool->high_end) {
fprintf(stderr,
"InnoDB: Error: trying to write to a stray memory location %lx\n",
(ulint)ptr);
(ulong) ptr);
ut_a(0);
}
ut_ad(ptr && mtr);

10
innobase/mtr/mtr0mtr.c
View file

@ -263,11 +263,11 @@ mtr_first_to_modify_page_after_backup(
backup_lsn) <= 0) {
printf("Page %lu newest %lu backup %lu\n",
block->offset,
ut_dulint_get_low(
(ulong) block->offset,
(ulong) ut_dulint_get_low(
buf_frame_get_newest_modification(
block->frame)),
ut_dulint_get_low(backup_lsn));
(ulong) ut_dulint_get_low(backup_lsn));
ret = TRUE;
}
@ -519,6 +519,6 @@ mtr_print(
{
printf(
"Mini-transaction handle: memo size %lu bytes log size %lu bytes\n",
dyn_array_get_data_size(&(mtr->memo)),
dyn_array_get_data_size(&(mtr->log)));
(ulong) dyn_array_get_data_size(&(mtr->memo)),
(ulong) dyn_array_get_data_size(&(mtr->log)));
}

47
innobase/os/os0file.c
View file

@ -216,7 +216,7 @@ os_file_get_last_error(
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Operating system error number %lu in a file operation.\n", err);
" InnoDB: Operating system error number %lu in a file operation.\n", (ulong) err);
if (err == ERROR_PATH_NOT_FOUND) {
fprintf(stderr,
@ -1499,7 +1499,7 @@ os_file_set_size(
!= offset / (ib_longlong)(100 * 1024 * 1024)) {
fprintf(stderr, " %lu00",
(ulint)((offset + n_bytes)
(ulong) ((offset + n_bytes)
/ (ib_longlong)(100 * 1024 * 1024)));
}
@ -1858,9 +1858,9 @@ error_handling:
fprintf(stderr,
"InnoDB: Fatal error: cannot read from file. OS error number %lu.\n",
#ifdef __WIN__
(ulint)GetLastError()
(ulong) GetLastError()
#else
(ulint)errno
(ulong) errno
#endif
);
fflush(stderr);
@ -2013,8 +2013,8 @@ retry:
"InnoDB: offset %lu %lu. Operating system error number %lu.\n"
"InnoDB: Look from section 13.2 at http://www.innodb.com/ibman.html\n"
"InnoDB: what the error number means.\n",
name, offset_high, offset,
(ulint)GetLastError());
name, (ulong) offset_high, (ulong) offset,
(ulong) GetLastError());
return(FALSE);
}
@ -2060,12 +2060,12 @@ retry:
"InnoDB: Operating system error number %lu.\n"
"InnoDB: Check that your OS and file system support files of this size.\n"
"InnoDB: Check also that the disk is not full or a disk quota exceeded.\n",
name, offset_high, offset, n, (ulint)len,
err);
name, (ulong) offset_high, (ulong) offset,
(ulong) n, (ulong) len, (ulong) err);
if (strerror((int)err) != NULL) {
fprintf(stderr,
"InnoDB: Error number %lu means '%s'.\n", err, strerror((int)err));
"InnoDB: Error number %lu means '%s'.\n", (ulong) err, strerror((int)err));
}
fprintf(stderr,
@ -3151,7 +3151,7 @@ restart:
if (os_aio_print_debug) {
fprintf(stderr,
"InnoDB: i/o for slot %lu already done, returning\n", i);
"InnoDB: i/o for slot %lu already done, returning\n", (ulong) i);
}
ret = TRUE;
@ -3298,8 +3298,8 @@ consecutive_loop:
if (os_aio_print_debug) {
fprintf(stderr,
"InnoDB: doing i/o of type %lu at offset %lu %lu, length %lu\n",
slot->type, slot->offset_high, slot->offset,
total_len);
(ulong) slot->type, (ulong) slot->offset_high,
(ulong) slot->offset, (ulong) total_len);
}
/* Do the i/o with ordinary, synchronous i/o functions: */
@ -3309,8 +3309,9 @@ consecutive_loop:
|| (slot->offset % UNIV_PAGE_SIZE != 0)) {
fprintf(stderr,
"InnoDB: Error: trying a displaced write to %s %lu %lu, len %lu\n",
slot->name, slot->offset_high,
slot->offset, total_len);
slot->name, (ulong) slot->offset_high,
(ulong) slot->offset,
(ulong) total_len);
ut_a(0);
}
@ -3409,7 +3410,7 @@ recommended_sleep:
if (os_aio_print_debug) {
fprintf(stderr,
"InnoDB: i/o handler thread for i/o segment %lu wakes up\n",
global_segment);
(ulong) global_segment);
}
goto restart;
@ -3491,7 +3492,8 @@ os_aio_print(
}
for (i = 0; i < srv_n_file_io_threads; i++) {
buf += sprintf(buf, "I/O thread %lu state: %s (%s)\n", i,
buf += sprintf(buf, "I/O thread %lu state: %s (%s)\n",
(ulong) i,
srv_io_thread_op_info[i],
srv_io_thread_function[i]);
}
@ -3523,7 +3525,7 @@ loop:
ut_a(array->n_reserved == n_reserved);
buf += sprintf(buf, " %lu", n_reserved);
buf += sprintf(buf, " %lu", (ulong) n_reserved);
os_mutex_exit(array->mutex);
@ -3563,15 +3565,18 @@ loop:
buf += sprintf(buf,
"Pending flushes (fsync) log: %lu; buffer pool: %lu\n",
fil_n_pending_log_flushes, fil_n_pending_tablespace_flushes);
(ulong) fil_n_pending_log_flushes,
(ulong) fil_n_pending_tablespace_flushes);
buf += sprintf(buf,
"%lu OS file reads, %lu OS file writes, %lu OS fsyncs\n",
os_n_file_reads, os_n_file_writes, os_n_fsyncs);
(ulong) os_n_file_reads, (ulong) os_n_file_writes,
(ulong) os_n_fsyncs);
if (os_file_n_pending_preads != 0 || os_file_n_pending_pwrites != 0) {
buf += sprintf(buf,
"%lu pending preads, %lu pending pwrites\n",
os_file_n_pending_preads, os_file_n_pending_pwrites);
(ulong) os_file_n_pending_preads,
(ulong) os_file_n_pending_pwrites);
}
if (os_n_file_reads == os_n_file_reads_old) {
@ -3585,7 +3590,7 @@ loop:
"%.2f reads/s, %lu avg bytes/read, %.2f writes/s, %.2f fsyncs/s\n",
(os_n_file_reads - os_n_file_reads_old)
/ time_elapsed,
(ulint)avg_bytes_read,
(ulong)avg_bytes_read,
(os_n_file_writes - os_n_file_writes_old)
/ time_elapsed,
(os_n_fsyncs - os_n_fsyncs_old)

6
innobase/os/os0sync.c
View file

@ -125,7 +125,7 @@ os_event_create(
if (!event->handle) {
fprintf(stderr,
"InnoDB: Could not create a Windows event semaphore; Windows error %lu\n",
(ulint)GetLastError());
(ulong) GetLastError());
}
#else /* Unix */
os_event_t event;
@ -182,7 +182,7 @@ os_event_create_auto(
if (!event->handle) {
fprintf(stderr,
"InnoDB: Could not create a Windows auto event semaphore; Windows error %lu\n",
(ulint)GetLastError());
(ulong) GetLastError());
}
/* Put to the list of events */
@ -412,7 +412,7 @@ os_event_wait_multiple(
FALSE, /* Wait for any 1 event */
INFINITE); /* Infinite wait time
limit */
ut_a(index >= WAIT_OBJECT_0);
ut_a(index >= WAIT_OBJECT_0); /* NOTE: Pointless comparision */
ut_a(index < WAIT_OBJECT_0 + n);
if (srv_shutdown_state == SRV_SHUTDOWN_EXIT_THREADS) {

6
innobase/page/page0cur.c
View file

@ -706,8 +706,10 @@ page_cur_parse_insert_rec(
"Is short %lu, info_bits %lu, offset %lu, o_offset %lu\n"
"mismatch index %lu, end_seg_len %lu\n"
"parsed len %lu\n",
is_short, info_bits, offset, origin_offset,
mismatch_index, end_seg_len, (ulint)(ptr - ptr2));
(ulong) is_short, (ulong) info_bits, (ulong) offset,
(ulong) origin_offset,
(ulong) mismatch_index, (ulong) end_seg_len,
(ulong) (ptr - ptr2));
printf("Dump of 300 bytes of log:\n");
ut_print_buf(ptr2, 300);

118
innobase/page/page0page.c
View file

@ -97,13 +97,13 @@ page_dir_find_owner_slot(
if (i == 0) {
fprintf(stderr,
"InnoDB: Probable data corruption on page %lu\n",
buf_frame_get_page_no(page));
(ulong) buf_frame_get_page_no(page));
rec_sprintf(err_buf, 900, original_rec);
fprintf(stderr,
"InnoDB: Original record %s\n"
"InnoDB: on that page. Steps %lu.\n", err_buf, steps);
"InnoDB: on that page. Steps %lu.\n", err_buf, (ulong) steps);
rec_sprintf(err_buf, 900, rec);
@ -466,9 +466,9 @@ page_copy_rec_list_end_no_locks(
fprintf(stderr,
"InnoDB: rec offset %lu, cur1 offset %lu, cur2 offset %lu\n",
(ulint)(rec - page),
(ulint)(page_cur_get_rec(&cur1) - page),
(ulint)(page_cur_get_rec(&cur2) - new_page));
(ulong)(rec - page),
(ulong)(page_cur_get_rec(&cur1) - page),
(ulong)(page_cur_get_rec(&cur2) - new_page));
ut_a(0);
}
@ -1152,9 +1152,9 @@ page_rec_print(
rec_print(rec);
printf(
" n_owned: %lu; heap_no: %lu; next rec: %lu\n",
rec_get_n_owned(rec),
rec_get_heap_no(rec),
rec_get_next_offs(rec));
(ulong) rec_get_n_owned(rec),
(ulong) rec_get_heap_no(rec),
(ulong) rec_get_next_offs(rec));
page_rec_check(rec);
rec_validate(rec);
@ -1178,9 +1178,9 @@ page_dir_print(
printf("--------------------------------\n");
printf("PAGE DIRECTORY\n");
printf("Page address %lx\n", (ulint)page);
printf("Page address %lx\n", (ulong)page);
printf("Directory stack top at offs: %lu; number of slots: %lu\n",
(ulint)(page_dir_get_nth_slot(page, n - 1) - page), n);
(ulong)(page_dir_get_nth_slot(page, n - 1) - page), (ulong) n);
for (i = 0; i < n; i++) {
slot = page_dir_get_nth_slot(page, i);
if ((i == pr_n) && (i < n - pr_n)) {
@ -1189,11 +1189,11 @@ page_dir_print(
if ((i < pr_n) || (i >= n - pr_n)) {
printf(
"Contents of slot: %lu: n_owned: %lu, rec offs: %lu\n",
i, page_dir_slot_get_n_owned(slot),
(ulint)(page_dir_slot_get_rec(slot) - page));
(ulong) i, (ulong) page_dir_slot_get_n_owned(slot),
(ulong)(page_dir_slot_get_rec(slot) - page));
}
}
printf("Total of %lu records\n", 2 + page_get_n_recs(page));
printf("Total of %lu records\n", (ulong) (2 + page_get_n_recs(page)));
printf("--------------------------------\n");
}
@ -1214,7 +1214,7 @@ page_print_list(
printf("--------------------------------\n");
printf("PAGE RECORD LIST\n");
printf("Page address %lu\n", (ulint)page);
printf("Page address %lu\n", (ulong) page);
n_recs = page_get_n_recs(page);
@ -1251,7 +1251,7 @@ page_print_list(
count++;
}
printf("Total of %lu records \n", count + 1);
printf("Total of %lu records \n", (ulong) (count + 1));
printf("--------------------------------\n");
}
@ -1265,22 +1265,22 @@ page_header_print(
{
printf("--------------------------------\n");
printf("PAGE HEADER INFO\n");
printf("Page address %lx, n records %lu\n", (ulint)page,
page_header_get_field(page, PAGE_N_RECS));
printf("Page address %lx, n records %lu\n", (ulong) page,
(ulong) page_header_get_field(page, PAGE_N_RECS));
printf("n dir slots %lu, heap top %lu\n",
page_header_get_field(page, PAGE_N_DIR_SLOTS),
page_header_get_field(page, PAGE_HEAP_TOP));
(ulong) page_header_get_field(page, PAGE_N_DIR_SLOTS),
(ulong) page_header_get_field(page, PAGE_HEAP_TOP));
printf("Page n heap %lu, free %lu, garbage %lu\n",
page_header_get_field(page, PAGE_N_HEAP),
page_header_get_field(page, PAGE_FREE),
page_header_get_field(page, PAGE_GARBAGE));
(ulong) page_header_get_field(page, PAGE_N_HEAP),
(ulong) page_header_get_field(page, PAGE_FREE),
(ulong) page_header_get_field(page, PAGE_GARBAGE));
printf("Page last insert %lu, direction %lu, n direction %lu\n",
page_header_get_field(page, PAGE_LAST_INSERT),
page_header_get_field(page, PAGE_DIRECTION),
page_header_get_field(page, PAGE_N_DIRECTION));
(ulong) page_header_get_field(page, PAGE_LAST_INSERT),
(ulong) page_header_get_field(page, PAGE_DIRECTION),
(ulong) page_header_get_field(page, PAGE_N_DIRECTION));
}
/*******************************************************************
@ -1325,15 +1325,15 @@ page_rec_validate(
if (!(n_owned <= PAGE_DIR_SLOT_MAX_N_OWNED)) {
fprintf(stderr,
"InnoDB: Dir slot of rec %lu, n owned too big %lu\n",
(ulint)(rec - page), n_owned);
(ulong)(rec - page), (ulong) n_owned);
return(FALSE);
}
if (!(heap_no < page_header_get_field(page, PAGE_N_HEAP))) {
fprintf(stderr,
"InnoDB: Heap no of rec %lu too big %lu %lu\n",
(ulint)(rec - page), heap_no,
page_header_get_field(page, PAGE_N_HEAP));
(ulong)(rec - page), (ulong) heap_no,
(ulong) page_header_get_field(page, PAGE_N_HEAP));
return(FALSE);
}
@ -1399,7 +1399,7 @@ page_simple_validate(
if (n_slots > UNIV_PAGE_SIZE / 4) {
fprintf(stderr,
"InnoDB: Nonsensical number %lu of page dir slots\n", n_slots);
"InnoDB: Nonsensical number %lu of page dir slots\n", (ulong) n_slots);
goto func_exit;
}
@ -1410,8 +1410,8 @@ page_simple_validate(
fprintf(stderr,
"InnoDB: Record heap and dir overlap on a page, heap top %lu, dir %lu\n",
(ulint)(page_header_get_ptr(page, PAGE_HEAP_TOP) - page),
(ulint)(page_dir_get_nth_slot(page, n_slots - 1) - page));
(ulong)(page_header_get_ptr(page, PAGE_HEAP_TOP) - page),
(ulong)(page_dir_get_nth_slot(page, n_slots - 1) - page));
goto func_exit;
}
@ -1432,7 +1432,7 @@ page_simple_validate(
if (rec > rec_heap_top) {
fprintf(stderr,
"InnoDB: Record %lu is above rec heap top %lu\n",
(ulint)(rec - page), (ulint)(rec_heap_top - page));
(ulong)(rec - page), (ulong)(rec_heap_top - page));
goto func_exit;
}
@ -1443,8 +1443,9 @@ page_simple_validate(
fprintf(stderr,
"InnoDB: Wrong owned count %lu, %lu, rec %lu\n",
rec_get_n_owned(rec), own_count,
(ulint)(rec - page));
(ulong) rec_get_n_owned(rec),
(ulong) own_count,
(ulong)(rec - page));
goto func_exit;
}
@ -1452,7 +1453,7 @@ page_simple_validate(
if (page_dir_slot_get_rec(slot) != rec) {
fprintf(stderr,
"InnoDB: Dir slot does not point to right rec %lu\n",
(ulint)(rec - page));
(ulong)(rec - page));
goto func_exit;
}
@ -1474,8 +1475,8 @@ page_simple_validate(
|| rec_get_next_offs(rec) >= UNIV_PAGE_SIZE) {
fprintf(stderr,
"InnoDB: Next record offset nonsensical %lu for rec %lu\n",
rec_get_next_offs(rec),
(ulint)(rec - page));
(ulong) rec_get_next_offs(rec),
(ulong)(rec - page));
goto func_exit;
}
@ -1485,7 +1486,7 @@ page_simple_validate(
if (count > UNIV_PAGE_SIZE) {
fprintf(stderr,
"InnoDB: Page record list appears to be circular %lu\n",
count);
(ulong) count);
goto func_exit;
}
@ -1501,13 +1502,14 @@ page_simple_validate(
if (slot_no != n_slots - 1) {
fprintf(stderr, "InnoDB: n slots wrong %lu, %lu\n",
slot_no, n_slots - 1);
(ulong) slot_no, (ulong) (n_slots - 1));
goto func_exit;
}
if (page_header_get_field(page, PAGE_N_RECS) + 2 != count + 1) {
fprintf(stderr, "InnoDB: n recs wrong %lu %lu\n",
page_header_get_field(page, PAGE_N_RECS) + 2, count + 1);
(ulong) page_header_get_field(page, PAGE_N_RECS) + 2,
(ulong) (count + 1));
goto func_exit;
}
@ -1520,7 +1522,7 @@ page_simple_validate(
|| rec >= page + UNIV_PAGE_SIZE) {
fprintf(stderr,
"InnoDB: Free list record has a nonsensical offset %lu\n",
(ulint)(rec - page));
(ulong)(rec - page));
goto func_exit;
}
@ -1528,7 +1530,7 @@ page_simple_validate(
if (rec > rec_heap_top) {
fprintf(stderr,
"InnoDB: Free list record %lu is above rec heap top %lu\n",
(ulint)(rec - page), (ulint)(rec_heap_top - page));
(ulong)(rec - page), (ulong)(rec_heap_top - page));
goto func_exit;
}
@ -1538,7 +1540,7 @@ page_simple_validate(
if (count > UNIV_PAGE_SIZE) {
fprintf(stderr,
"InnoDB: Page free list appears to be circular %lu\n",
count);
(ulong) count);
goto func_exit;
}
@ -1548,7 +1550,8 @@ page_simple_validate(
if (page_header_get_field(page, PAGE_N_HEAP) != count + 1) {
fprintf(stderr, "InnoDB: N heap is wrong %lu, %lu\n",
page_header_get_field(page, PAGE_N_HEAP), count + 1);
(ulong) page_header_get_field(page, PAGE_N_HEAP),
(ulong) (count + 1));
goto func_exit;
}
@ -1589,7 +1592,7 @@ page_validate(
if (!page_simple_validate(page)) {
fprintf(stderr,
"InnoDB: Apparent corruption in page %lu in index %s in table %s\n",
buf_frame_get_page_no(page), index->name,
(ulong) buf_frame_get_page_no(page), index->name,
index->table_name);
buf_page_print(page);
@ -1616,8 +1619,8 @@ page_validate(
page_dir_get_nth_slot(page, n_slots - 1))) {
fprintf(stderr,
"InnoDB: Record heap and dir overlap on a page in index %s, %lu, %lu\n",
index->name, (ulint)page_header_get_ptr(page, PAGE_HEAP_TOP),
(ulint)page_dir_get_nth_slot(page, n_slots - 1));
index->name, (ulong)page_header_get_ptr(page, PAGE_HEAP_TOP),
(ulong)page_dir_get_nth_slot(page, n_slots - 1));
goto func_exit;
}
@ -1644,7 +1647,7 @@ page_validate(
if (!(1 == cmp_rec_rec(rec, old_rec, index))) {
fprintf(stderr,
"InnoDB: Records in wrong order on page %lu index %s table %s\n",
buf_frame_get_page_no(page),
(ulong) buf_frame_get_page_no(page),
index->name,
index->table_name);
@ -1687,7 +1690,8 @@ page_validate(
if (rec_get_n_owned(rec) != own_count) {
fprintf(stderr,
"InnoDB: Wrong owned count %lu, %lu, in index %s\n",
rec_get_n_owned(rec), own_count,
(ulong) rec_get_n_owned(rec),
(ulong) own_count,
index->name);
goto func_exit;
@ -1718,7 +1722,7 @@ page_validate(
|| rec_get_next_offs(rec) >= UNIV_PAGE_SIZE) {
fprintf(stderr,
"InnoDB: Next record offset wrong %lu in index %s\n",
rec_get_next_offs(rec), index->name);
(ulong) rec_get_next_offs(rec), index->name);
goto func_exit;
}
@ -1738,13 +1742,14 @@ page_validate(
if (slot_no != n_slots - 1) {
fprintf(stderr, "InnoDB: n slots wrong %lu %lu in index %s\n",
slot_no, n_slots - 1, index->name);
(ulong) slot_no, (ulong) (n_slots - 1), index->name);
goto func_exit;
}
if (page_header_get_field(page, PAGE_N_RECS) + 2 != count + 1) {
fprintf(stderr, "InnoDB: n recs wrong %lu %lu in index %s\n",
page_header_get_field(page, PAGE_N_RECS) + 2, count + 1,
(ulong) page_header_get_field(page, PAGE_N_RECS) + 2,
(ulong) (count + 1),
index->name);
goto func_exit;
@ -1753,7 +1758,7 @@ page_validate(
if (data_size != page_get_data_size(page)) {
fprintf(stderr,
"InnoDB: Summed data size %lu, returned by func %lu\n",
data_size, page_get_data_size(page));
(ulong) data_size, (ulong) page_get_data_size(page));
goto func_exit;
}
@ -1789,8 +1794,9 @@ page_validate(
fprintf(stderr,
"InnoDB: N heap is wrong %lu %lu in index %s\n",
page_header_get_field(page, PAGE_N_HEAP), count + 1,
index->name);
(ulong) page_header_get_field(page, PAGE_N_HEAP),
(ulong) count + 1,
index->name);
goto func_exit;
}
@ -1802,7 +1808,7 @@ func_exit:
if (ret == FALSE) {
fprintf(stderr,
"InnoDB: Apparent corruption in page %lu in index %s in table %s\n",
buf_frame_get_page_no(page), index->name,
(ulong) buf_frame_get_page_no(page), index->name,
index->table_name);
buf_page_print(page);

16
innobase/read/read0read.c
View file

@ -234,16 +234,16 @@ read_view_print(
ulint i;
fprintf(stderr, "Read view low limit trx n:o %lu %lu\n",
ut_dulint_get_high(view->low_limit_no),
ut_dulint_get_low(view->low_limit_no));
(ulong) ut_dulint_get_high(view->low_limit_no),
(ulong) ut_dulint_get_low(view->low_limit_no));
fprintf(stderr, "Read view up limit trx id %lu %lu\n",
ut_dulint_get_high(view->up_limit_id),
ut_dulint_get_low(view->up_limit_id));
(ulong) ut_dulint_get_high(view->up_limit_id),
(ulong) ut_dulint_get_low(view->up_limit_id));
fprintf(stderr, "Read view low limit trx id %lu %lu\n",
ut_dulint_get_high(view->low_limit_id),
ut_dulint_get_low(view->low_limit_id));
(ulong) ut_dulint_get_high(view->low_limit_id),
(ulong) ut_dulint_get_low(view->low_limit_id));
fprintf(stderr, "Read view individually stored trx ids:\n");
@ -251,7 +251,7 @@ read_view_print(
for (i = 0; i < n_ids; i++) {
fprintf(stderr, "Read view trx id %lu %lu\n",
ut_dulint_get_high(read_view_get_nth_trx_id(view, i)),
ut_dulint_get_low(read_view_get_nth_trx_id(view, i)));
(ulong) ut_dulint_get_high(read_view_get_nth_trx_id(view, i)),
(ulong) ut_dulint_get_low(read_view_get_nth_trx_id(view, i)));
}
}

3
innobase/rem/rem0cmp.c
View file

@ -272,7 +272,8 @@ cmp_whole_field(
a, a_length, b, b_length));
default:
fprintf(stderr,
"InnoDB: unknown type number %lu\n", data_type);
"InnoDB: unknown type number %lu\n",
(ulong) data_type);
ut_a(0);
}

22
innobase/rem/rem0rec.c
View file

@ -107,7 +107,7 @@ rec_get_nth_field(
if (n > 1024) {
fprintf(stderr, "Error: trying to access field %lu in rec\n",
n);
(ulong) n);
ut_a(0);
}
@ -474,7 +474,7 @@ rec_validate(
if ((n_fields == 0) || (n_fields > REC_MAX_N_FIELDS)) {
fprintf(stderr, "InnoDB: Error: record has %lu fields\n",
n_fields);
(ulong) n_fields);
return(FALSE);
}
@ -483,8 +483,8 @@ rec_validate(
if (!((len < UNIV_PAGE_SIZE) || (len == UNIV_SQL_NULL))) {
fprintf(stderr,
"InnoDB: Error: record field %lu len %lu\n", i,
len);
"InnoDB: Error: record field %lu len %lu\n", (ulong) i,
(ulong) len);
return(FALSE);
}
@ -502,7 +502,8 @@ rec_validate(
if (len_sum != (ulint)(rec_get_end(rec) - rec)) {
fprintf(stderr,
"InnoDB: Error: record len should be %lu, len %lu\n",
len_sum, (ulint)(rec_get_end(rec) - rec));
(ulong) len_sum,
(ulong) (rec_get_end(rec) - rec));
return(FALSE);
}
@ -537,13 +538,13 @@ rec_print(
printf(
"PHYSICAL RECORD: n_fields %lu; 1-byte offs %s; info bits %lu\n",
n, offs, rec_get_info_bits(rec));
(ulong) n, offs, (ulong) rec_get_info_bits(rec));
for (i = 0; i < n; i++) {
data = rec_get_nth_field(rec, i, &len);
printf(" %lu:", i);
printf(" %lu:", (ulong) i);
if (len != UNIV_SQL_NULL) {
if (len <= 30) {
@ -556,7 +557,7 @@ rec_print(
}
} else {
printf(" SQL NULL, size %lu ",
rec_get_nth_field_size(rec, i));
(ulong) rec_get_nth_field_size(rec, i));
}
printf(";");
@ -594,7 +595,8 @@ rec_sprintf(
return(k);
}
k += sprintf(buf + k, "RECORD: info bits %lu", rec_get_info_bits(rec));
k += sprintf(buf + k, "RECORD: info bits %lu",
(ulong) rec_get_info_bits(rec));
for (i = 0; i < n; i++) {
@ -605,7 +607,7 @@ rec_sprintf(
data = rec_get_nth_field(rec, i, &len);
k += sprintf(buf + k, " %lu:", i);
k += sprintf(buf + k, " %lu:", (ulong) i);
if (len != UNIV_SQL_NULL) {
if (k + 30 + 5 * len > buf_len) {

29
innobase/row/row0mysql.c
View file

@ -285,7 +285,8 @@ handle_new_error:
"InnoDB: http://www.innodb.com/ibman.html for help.\n");
} else {
fprintf(stderr, "InnoDB: unknown error code %lu\n", err);
fprintf(stderr, "InnoDB: unknown error code %lu\n",
(ulong) err);
ut_a(0);
}
@ -395,7 +396,9 @@ row_prebuilt_free(
fprintf(stderr,
"InnoDB: Error: trying to free a corrupt\n"
"InnoDB: table handle. Magic n %lu, magic n2 %lu, table name %s\n",
prebuilt->magic_n, prebuilt->magic_n2, prebuilt->table->name);
(ulong) prebuilt->magic_n,
(ulong) prebuilt->magic_n2,
prebuilt->table->name);
mem_analyze_corruption((byte*)prebuilt);
@ -475,7 +478,7 @@ row_update_prebuilt_trx(
fprintf(stderr,
"InnoDB: Error: trying to use a corrupt\n"
"InnoDB: trx handle. Magic n %lu\n",
trx->magic_n);
(ulong) trx->magic_n);
mem_analyze_corruption((byte*)trx);
@ -486,7 +489,7 @@ row_update_prebuilt_trx(
fprintf(stderr,
"InnoDB: Error: trying to use a corrupt\n"
"InnoDB: table handle. Magic n %lu, table name %s\n",
prebuilt->magic_n, prebuilt->table->name);
(ulong) prebuilt->magic_n, prebuilt->table->name);
mem_analyze_corruption((byte*)prebuilt);
@ -713,7 +716,7 @@ row_insert_for_mysql(
fprintf(stderr,
"InnoDB: Error: trying to free a corrupt\n"
"InnoDB: table handle. Magic n %lu, table name %s\n",
prebuilt->magic_n, prebuilt->table->name);
(ulong) prebuilt->magic_n, prebuilt->table->name);
mem_analyze_corruption((byte*)prebuilt);
@ -929,7 +932,7 @@ row_update_for_mysql(
fprintf(stderr,
"InnoDB: Error: trying to free a corrupt\n"
"InnoDB: table handle. Magic n %lu, table name %s\n",
prebuilt->magic_n, prebuilt->table->name);
(ulong) prebuilt->magic_n, prebuilt->table->name);
mem_analyze_corruption((byte*)prebuilt);
@ -1898,7 +1901,7 @@ row_discard_tablespace_for_mysql(
"SELECT ID INTO old_id\n"
"FROM SYS_TABLES\n"
"WHERE NAME = table_name;\n"
"IF (SQL % NOTFOUND) THEN\n"
"IF (SQL %% NOTFOUND) THEN\n"
" COMMIT WORK;\n"
" RETURN;\n"
"END IF;\n"
@ -1909,7 +1912,8 @@ row_discard_tablespace_for_mysql(
"UPDATE SYS_INDEXES SET TABLE_ID = new_id\n"
"WHERE TABLE_ID = old_id;\n"
"COMMIT WORK;\n"
"END;\n", name, ut_dulint_get_high(new_id), ut_dulint_get_low(new_id));
"END;\n", name, (ulong) ut_dulint_get_high(new_id),
(ulong) ut_dulint_get_low(new_id));
ut_a(strlen(buf) < 2 * OS_FILE_MAX_PATH);
@ -2359,8 +2363,8 @@ row_drop_table_for_mysql(
if (!success) {
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Error: not able to delete tablespace %lu of table %s!\n", space_id,
name);
" InnoDB: Error: not able to delete tablespace %lu of table %s!\n",
(ulong) space_id, name);
err = DB_ERROR;
}
}
@ -2439,7 +2443,7 @@ loop:
if (err != DB_SUCCESS) {
fprintf(stderr,
"InnoDB: DROP DATABASE %s failed with error %lu for table %s\n",
name, (ulint)err, table_name);
name, (ulong) err, table_name);
break;
}
}
@ -2947,7 +2951,8 @@ row_check_table_for_mysql(
fprintf(stderr,
"Error: index %s contains %lu entries, should be %lu\n",
index->name, n_rows, n_rows_in_table);
index->name, (ulong) n_rows,
(ulong) n_rows_in_table);
}
}

31
innobase/row/row0sel.c
View file

@ -1754,7 +1754,7 @@ row_sel_step(
return(NULL);
} else {
/* SQL error detected */
printf("SQL error %lu\n", err);
printf("SQL error %lu\n", (ulong) err);
que_thr_handle_error(thr, DB_ERROR, NULL, 0);
@ -1804,7 +1804,7 @@ fetch_step(
if (sel_node->state == SEL_NODE_CLOSED) {
/* SQL error detected */
printf("SQL error %lu\n", (ulint)DB_ERROR);
printf("SQL error %lu\n", (ulong) DB_ERROR);
que_thr_handle_error(thr, DB_ERROR, NULL, 0);
@ -2029,8 +2029,8 @@ row_sel_convert_mysql_key_to_innobase(
"InnoDB: Table name %s, index name %s. Last data field length %lu bytes,\n"
"InnoDB: key ptr now exceeds key end by %lu bytes.\n"
"InnoDB: Key value in the MySQL format:\n", index->table_name, index->name,
data_field_len,
(ulint)(key_ptr - key_end));
(ulong) data_field_len,
(ulong) (key_ptr - key_end));
fflush(stderr);
ut_print_buf(original_key_ptr, key_len);
fflush(stdout);
@ -2077,8 +2077,8 @@ row_sel_store_row_id_to_prebuilt(
fprintf(stderr,
"InnoDB: Error: Row id field is wrong length %lu in table %s index %s\n"
"InnoDB: Field number %lu, record:\n%s\n",
len, index->table_name, index->name,
dict_index_get_sys_col_pos(index, DATA_ROW_ID),
(ulong) len, index->table_name, index->name,
(ulong) dict_index_get_sys_col_pos(index, DATA_ROW_ID),
err_buf);
ut_a(0);
}
@ -2233,7 +2233,7 @@ row_sel_store_mysql_rec(
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Warning: could not allocate %lu + 1000000 bytes to retrieve\n"
"InnoDB: a big column. Table name %s\n", len, prebuilt->table->name);
"InnoDB: a big column. Table name %s\n", (ulong) len, prebuilt->table->name);
if (extern_field_heap) {
mem_heap_free(
@ -2766,7 +2766,7 @@ row_search_for_mysql(
fprintf(stderr,
"InnoDB: Error: trying to free a corrupt\n"
"InnoDB: table handle. Magic n %lu, table name %s\n",
prebuilt->magic_n, prebuilt->table->name);
(ulong) prebuilt->magic_n, prebuilt->table->name);
mem_analyze_corruption((byte*)prebuilt);
@ -3147,8 +3147,9 @@ rec_loop:
" InnoDB: Index corruption: rec offs %lu next offs %lu, page no %lu,\n"
"InnoDB: index %s, table %s. Run CHECK TABLE to table. You may need to\n"
"InnoDB: restore from a backup, or dump + drop + reimport the table.\n",
(ulint)(rec - buf_frame_align(rec)), next_offs,
buf_frame_get_page_no(rec), index->name,
(ulong) (rec - buf_frame_align(rec)),
(ulong) next_offs,
(ulong) buf_frame_get_page_no(rec), index->name,
index->table_name);
err = DB_CORRUPTION;
@ -3161,8 +3162,9 @@ rec_loop:
fprintf(stderr,
"InnoDB: Index corruption: rec offs %lu next offs %lu, page no %lu,\n"
"InnoDB: index %s, table %s. We try to skip the rest of the page.\n",
(ulint)(rec - buf_frame_align(rec)), next_offs,
buf_frame_get_page_no(rec), index->name,
(ulong) (rec - buf_frame_align(rec)),
(ulong) next_offs,
(ulong) buf_frame_get_page_no(rec), index->name,
index->table_name);
btr_pcur_move_to_last_on_page(pcur, &mtr);
@ -3177,8 +3179,9 @@ rec_loop:
fprintf(stderr,
"InnoDB: Index record corruption: rec offs %lu next offs %lu, page no %lu,\n"
"InnoDB: index %s, table %s. We try to skip the record.\n",
(ulint)(rec - buf_frame_align(rec)), next_offs,
buf_frame_get_page_no(rec), index->name,
(ulong) (rec - buf_frame_align(rec)),
(ulong) next_offs,
(ulong) buf_frame_get_page_no(rec), index->name,
index->table_name);
goto next_rec;

3
innobase/row/row0undo.c
View file

@ -323,7 +323,8 @@ row_undo_step(
if (err != DB_SUCCESS) {
/* SQL error detected */
fprintf(stderr, "InnoDB: Fatal error %lu in rollback.\n", err);
fprintf(stderr, "InnoDB: Fatal error %lu in rollback.\n",
(ulong) err);
if (err == DB_OUT_OF_FILE_SPACE) {
fprintf(stderr,

59
innobase/srv/srv0srv.c
View file

@ -637,7 +637,8 @@ srv_suspend_thread(void)
if (srv_print_thread_releases) {
printf("Suspending thread %lu to slot %lu meter %lu\n",
os_thread_get_curr_id(), slot_no, srv_meter[SRV_RECOVERY]);
(ulong) os_thread_get_curr_id(), (ulong) slot_no,
(ulong) srv_meter[SRV_RECOVERY]);
}
slot = srv_table_get_nth_slot(slot_no);
@ -697,7 +698,8 @@ srv_release_threads(
if (srv_print_thread_releases) {
printf(
"Releasing thread %lu type %lu from slot %lu meter %lu\n",
slot->id, type, i, srv_meter[SRV_RECOVERY]);
(ulong) slot->id, (ulong) type, (ulong) i,
(ulong) srv_meter[SRV_RECOVERY]);
}
count++;
@ -776,7 +778,7 @@ srv_dec_thread_count(
/* FIXME: the following assertion sometimes fails: */
if (srv_n_threads_active[type] == 0) {
printf("Error: thread type %lu\n", type);
printf("Error: thread type %lu\n", (ulong) type);
ut_ad(0);
}
@ -987,7 +989,7 @@ srv_console(
printf(
"Starting disk access simulation with pct %lu\n",
srv_sim_disk_wait_pct);
(ulong) srv_sim_disk_wait_pct);
} else {
printf("\nNot supported!\n");
}
@ -2114,7 +2116,7 @@ srv_table_reserve_slot_for_mysql(void)
" InnoDB: There appear to be %lu MySQL threads currently waiting\n"
"InnoDB: inside InnoDB, which is the upper limit. Cannot continue operation.\n"
"InnoDB: We intentionally generate a seg fault to print a stack trace\n"
"InnoDB: on Linux. But first we print a list of waiting threads.\n", i);
"InnoDB: on Linux. But first we print a list of waiting threads.\n", (ulong) i);
for (i = 0; i < OS_THREAD_MAX_N; i++) {
@ -2122,10 +2124,10 @@ srv_table_reserve_slot_for_mysql(void)
fprintf(stderr,
"Slot %lu: thread id %lu, type %lu, in use %lu, susp %lu, time %lu\n",
i, os_thread_pf(slot->id),
slot->type, slot->in_use,
slot->suspended,
(ulint)difftime(ut_time(), slot->suspend_time));
(ulong) i, (ulong) os_thread_pf(slot->id),
(ulong) slot->type, (ulong) slot->in_use,
(ulong) slot->suspended,
(ulong) difftime(ut_time(), slot->suspend_time));
}
ut_a(0);
@ -2368,7 +2370,7 @@ srv_sprintf_innodb_monitor(
buf += sprintf(buf,
"Per second averages calculated from the last %lu seconds\n",
(ulint)time_elapsed);
(ulong) time_elapsed);
buf += sprintf(buf, "----------\n"
"SEMAPHORES\n"
@ -2446,19 +2448,19 @@ srv_sprintf_innodb_monitor(
"----------------------\n");
buf += sprintf(buf,
"Total memory allocated %lu; in additional pool allocated %lu\n",
ut_total_allocated_memory,
mem_pool_get_reserved(mem_comm_pool));
(ulong) ut_total_allocated_memory,
(ulong) mem_pool_get_reserved(mem_comm_pool));
if (mem_out_of_mem_err_msg_count > 0) {
buf += sprintf(buf,
"Mem allocation has spilled out of additional mem pool %lu times\n",
mem_out_of_mem_err_msg_count);
(ulong) mem_out_of_mem_err_msg_count);
}
if (srv_use_awe) {
buf += sprintf(buf,
"In addition to that %lu MB of AWE memory allocated\n",
srv_pool_size / ((1024 * 1024) / UNIV_PAGE_SIZE));
(ulong) (srv_pool_size / ((1024 * 1024) / UNIV_PAGE_SIZE)));
}
buf_print_io(buf, buf_end);
@ -2470,33 +2472,34 @@ srv_sprintf_innodb_monitor(
"--------------\n");
buf += sprintf(buf,
"%ld queries inside InnoDB, %lu queries in queue\n",
srv_conc_n_threads, srv_conc_n_waiting_threads);
(ulong) srv_conc_n_threads,
(ulong) srv_conc_n_waiting_threads);
n_reserved = fil_space_get_n_reserved_extents(0);
if (n_reserved > 0) {
buf += sprintf(buf,
"%lu tablespace extents now reserved for B-tree split operations\n",
n_reserved);
(ulong) n_reserved);
}
#ifdef UNIV_LINUX
buf += sprintf(buf,
"Main thread process no. %lu, id %lu, state: %s\n",
srv_main_thread_process_no,
srv_main_thread_id,
srv_main_thread_op_info);
(ulong) srv_main_thread_process_no,
(ulong) srv_main_thread_id,
srv_main_thread_op_info);
#else
buf += sprintf(buf,
"Main thread id %lu, state: %s\n",
srv_main_thread_id,
(ulong) srv_main_thread_id,
srv_main_thread_op_info);
#endif
buf += sprintf(buf,
"Number of rows inserted %lu, updated %lu, deleted %lu, read %lu\n",
srv_n_rows_inserted,
srv_n_rows_updated,
srv_n_rows_deleted,
srv_n_rows_read);
(ulong) srv_n_rows_inserted,
(ulong) srv_n_rows_updated,
(ulong) srv_n_rows_deleted,
(ulong) srv_n_rows_read);
buf += sprintf(buf,
"%.2f inserts/s, %.2f updates/s, %.2f deletes/s, %.2f reads/s\n",
(srv_n_rows_inserted - srv_n_rows_inserted_old)
@ -2746,10 +2749,10 @@ loop:
" InnoDB: Error: old log sequence number %lu %lu was greater\n"
"InnoDB: than the new log sequence number %lu %lu!\n"
"InnoDB: Please send a bug report to mysql@lists.mysql.com\n",
ut_dulint_get_high(old_lsn),
ut_dulint_get_low(old_lsn),
ut_dulint_get_high(new_lsn),
ut_dulint_get_low(new_lsn));
(ulong) ut_dulint_get_high(old_lsn),
(ulong) ut_dulint_get_low(old_lsn),
(ulong) ut_dulint_get_high(new_lsn),
(ulong) ut_dulint_get_low(new_lsn));
}
old_lsn = new_lsn;

52
innobase/srv/srv0start.c
View file

@ -565,7 +565,7 @@ open_or_create_log_file(
srv_log_group_home_dirs[k] = srv_add_path_separator_if_needed(
srv_log_group_home_dirs[k]);
sprintf(name, "%s%s%lu", srv_log_group_home_dirs[k], "ib_logfile", i);
sprintf(name, "%s%s%lu", srv_log_group_home_dirs[k], "ib_logfile", (ulong) i);
files[i] = os_file_create(name, OS_FILE_CREATE, OS_FILE_NORMAL,
OS_LOG_FILE, &ret);
@ -595,9 +595,9 @@ open_or_create_log_file(
fprintf(stderr,
"InnoDB: Error: log file %s is of different size %lu %lu bytes\n"
"InnoDB: than specified in the .cnf file %lu %lu bytes!\n",
name, size_high, size,
srv_calc_high32(srv_log_file_size),
srv_calc_low32(srv_log_file_size));
name, (ulong) size_high, (ulong) size,
(ulong) srv_calc_high32(srv_log_file_size),
(ulong) srv_calc_low32(srv_log_file_size));
return(DB_ERROR);
}
@ -615,7 +615,7 @@ open_or_create_log_file(
}
fprintf(stderr, "InnoDB: Setting log file %s size to %lu MB\n",
name, srv_log_file_size
name, (ulong) srv_log_file_size
>> (20 - UNIV_PAGE_SIZE_SHIFT));
fprintf(stderr,
@ -702,7 +702,7 @@ open_or_create_data_files(
if (srv_n_data_files >= 1000) {
fprintf(stderr, "InnoDB: can only have < 1000 data files\n"
"InnoDB: you have defined %lu\n",
srv_n_data_files);
(ulong) srv_n_data_files);
return(DB_ERROR);
}
@ -814,8 +814,9 @@ open_or_create_data_files(
"InnoDB: Error: auto-extending data file %s is of a different size\n"
"InnoDB: %lu pages (rounded down to MB) than specified in the .cnf file:\n"
"InnoDB: initial %lu pages, max %lu (relevant if non-zero) pages!\n",
name, rounded_size_pages,
srv_data_file_sizes[i], srv_last_file_size_max);
name, (ulong) rounded_size_pages,
(ulong) srv_data_file_sizes[i],
(ulong) srv_last_file_size_max);
return(DB_ERROR);
}
@ -829,8 +830,8 @@ open_or_create_data_files(
"InnoDB: Error: data file %s is of a different size\n"
"InnoDB: %lu pages (rounded down to MB)\n"
"InnoDB: than specified in the .cnf file %lu pages!\n", name,
rounded_size_pages,
srv_data_file_sizes[i]);
(ulong) rounded_size_pages,
(ulong) srv_data_file_sizes[i]);
return(DB_ERROR);
}
@ -861,7 +862,7 @@ skip_size_check:
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Setting file %s size to %lu MB\n",
name, (srv_data_file_sizes[i]
name, (ulong) (srv_data_file_sizes[i]
>> (20 - UNIV_PAGE_SIZE_SHIFT)));
fprintf(stderr,
@ -1040,7 +1041,8 @@ innobase_start_or_create_for_mysql(void)
"InnoDB: Error: trx_t size is %lu in ha_innodb.cc but %lu in srv0start.c\n"
"InnoDB: Check that pthread_mutex_t is defined in the same way in these\n"
"InnoDB: compilation modules. Cannot continue.\n",
srv_sizeof_trx_t_in_ha_innodb_cc, (ulint)sizeof(trx_t));
(ulong) srv_sizeof_trx_t_in_ha_innodb_cc,
(ulong) sizeof(trx_t));
return(DB_ERROR);
}
@ -1219,8 +1221,8 @@ NetWare. */
if (srv_use_awe) {
fprintf(stderr,
"InnoDB: Using AWE: Memory window is %lu MB and AWE memory is %lu MB\n",
srv_awe_window_size / ((1024 * 1024) / UNIV_PAGE_SIZE),
srv_pool_size / ((1024 * 1024) / UNIV_PAGE_SIZE));
(ulong) (srv_awe_window_size / ((1024 * 1024) / UNIV_PAGE_SIZE)),
(ulong) (srv_pool_size / ((1024 * 1024) / UNIV_PAGE_SIZE)));
/* We must disable adaptive hash indexes because they do not
tolerate remapping of pages in AWE */
@ -1545,7 +1547,8 @@ NetWare. */
fprintf(stderr,
"InnoDB: Error: tablespace size stored in header is %lu pages, but\n"
"InnoDB: the sum of data file sizes is %lu pages\n",
tablespace_size_in_header, sum_of_data_file_sizes);
(ulong) tablespace_size_in_header,
(ulong) sum_of_data_file_sizes);
}
if (srv_auto_extend_last_data_file
@ -1554,7 +1557,8 @@ NetWare. */
fprintf(stderr,
"InnoDB: Error: tablespace size stored in header is %lu pages, but\n"
"InnoDB: the sum of data file sizes is only %lu pages\n",
tablespace_size_in_header, sum_of_data_file_sizes);
(ulong) tablespace_size_in_header,
(ulong) sum_of_data_file_sizes);
}
/* Check that os_fast_mutexes work as expected */
@ -1579,14 +1583,14 @@ NetWare. */
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Started; log sequence number %lu %lu\n",
ut_dulint_get_high(srv_start_lsn),
ut_dulint_get_low(srv_start_lsn));
(ulong) ut_dulint_get_high(srv_start_lsn),
(ulong) ut_dulint_get_low(srv_start_lsn));
}
if (srv_force_recovery > 0) {
fprintf(stderr,
"InnoDB: !!! innodb_force_recovery is set to %lu !!!\n",
srv_force_recovery);
(ulong) srv_force_recovery);
}
fflush(stderr);
@ -1716,7 +1720,7 @@ innobase_shutdown_for_mysql(void)
if (i == 1000) {
fprintf(stderr,
"InnoDB: Warning: %lu threads created by InnoDB had not exited at shutdown!\n",
os_thread_count);
(ulong) os_thread_count);
}
/* 3. Free all InnoDB's own mutexes and the os_fast_mutexes inside
@ -1741,16 +1745,16 @@ innobase_shutdown_for_mysql(void)
fprintf(stderr,
"InnoDB: Warning: some resources were not cleaned up in shutdown:\n"
"InnoDB: threads %lu, events %lu, os_mutexes %lu, os_fast_mutexes %lu\n",
os_thread_count, os_event_count, os_mutex_count,
os_fast_mutex_count);
(ulong) os_thread_count, (ulong) os_event_count,
(ulong) os_mutex_count, (ulong) os_fast_mutex_count);
}
if (srv_print_verbose_log) {
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Shutdown completed; log sequence number %lu %lu\n",
ut_dulint_get_high(srv_shutdown_lsn),
ut_dulint_get_low(srv_shutdown_lsn));
(ulong) ut_dulint_get_high(srv_shutdown_lsn),
(ulong) ut_dulint_get_low(srv_shutdown_lsn));
}
return((int) DB_SUCCESS);

35
innobase/sync/sync0arr.c
View file

@ -454,8 +454,9 @@ sync_array_cell_print(
buf += sprintf(buf,
"--Thread %lu has waited at %s line %lu for %.2f seconds the semaphore:\n",
os_thread_pf(cell->thread), cell->file, cell->line,
difftime(time(NULL), cell->reservation_time));
(ulong) os_thread_pf(cell->thread), cell->file,
(ulong) cell->line,
difftime(time(NULL), cell->reservation_time));
if (type == SYNC_MUTEX) {
/* We use old_wait_mutex in case the cell has already
@ -464,11 +465,12 @@ sync_array_cell_print(
buf += sprintf(buf,
"Mutex at %lx created file %s line %lu, lock var %lu\n",
(ulint)mutex, mutex->cfile_name, mutex->cline,
mutex->lock_word);
(ulong) mutex, mutex->cfile_name,
(ulong) mutex->cline, (ulong) mutex->lock_word);
buf += sprintf(buf,
"Last time reserved in file %s line %lu, waiters flag %lu\n",
mutex->file_name, mutex->line, mutex->waiters);
mutex->file_name, (ulong) mutex->line,
(ulong) mutex->waiters);
} else if (type == RW_LOCK_EX || type == RW_LOCK_SHARED) {
@ -482,11 +484,12 @@ sync_array_cell_print(
buf += sprintf(buf,
" RW-latch at %lx created in file %s line %lu\n",
(ulint)rwlock, rwlock->cfile_name, rwlock->cline);
(ulong) rwlock, rwlock->cfile_name,
(ulong) rwlock->cline);
if (rwlock->writer != RW_LOCK_NOT_LOCKED) {
buf += sprintf(buf,
"a writer (thread id %lu) has reserved it in mode",
os_thread_pf(rwlock->writer_thread));
(ulong) os_thread_pf(rwlock->writer_thread));
if (rwlock->writer == RW_LOCK_EX) {
buf += sprintf(buf, " exclusive\n");
} else {
@ -496,14 +499,16 @@ sync_array_cell_print(
buf += sprintf(buf,
"number of readers %lu, waiters flag %lu\n",
rwlock->reader_count, rwlock->waiters);
(ulong) rwlock->reader_count,
(ulong) rwlock->waiters);
buf += sprintf(buf,
"Last time read locked in file %s line %lu\n",
rwlock->last_s_file_name, rwlock->last_s_line);
rwlock->last_s_file_name,
(ulong) rwlock->last_s_line);
buf += sprintf(buf,
"Last time write locked in file %s line %lu\n",
rwlock->last_x_file_name, rwlock->last_x_line);
rwlock->last_x_file_name, (ulong) rwlock->last_x_line);
} else {
ut_error;
}
@ -651,8 +656,8 @@ sync_array_detect_deadlock(
sync_array_cell_print(buf, cell);
printf(
"Mutex %lx owned by thread %lu file %s line %lu\n%s",
(ulint)mutex, os_thread_pf(mutex->thread_id),
mutex->file_name, mutex->line, buf);
(ulong) mutex, (ulong) os_thread_pf(mutex->thread_id),
mutex->file_name, (ulong) mutex->line, buf);
return(TRUE);
}
@ -686,7 +691,7 @@ sync_array_detect_deadlock(
depth);
if (ret) {
sync_array_cell_print(buf, cell);
printf("rw-lock %lx %s ", (ulint) lock, buf);
printf("rw-lock %lx %s ", (ulong) lock, buf);
rw_lock_debug_print(debug);
return(TRUE);
@ -719,7 +724,7 @@ sync_array_detect_deadlock(
depth);
if (ret) {
sync_array_cell_print(buf, cell);
printf("rw-lock %lx %s ", (ulint) lock, buf);
printf("rw-lock %lx %s ", (ulong) lock, buf);
rw_lock_debug_print(debug);
return(TRUE);
@ -972,7 +977,7 @@ sync_array_output_info(
buf += sprintf(buf,
"OS WAIT ARRAY INFO: reservation count %ld, signal count %ld\n",
arr->res_count, arr->sg_count);
(long) arr->res_count, (long) arr->sg_count);
i = 0;
count = 0;

21
innobase/sync/sync0rw.c
View file

@ -235,8 +235,8 @@ lock_loop:
if (srv_print_latch_waits) {
printf(
"Thread %lu spin wait rw-s-lock at %lx cfile %s cline %lu rnds %lu\n",
os_thread_pf(os_thread_get_curr_id()), (ulint)lock,
lock->cfile_name, lock->cline, i);
(ulong) os_thread_pf(os_thread_get_curr_id()), (ulong) lock,
lock->cfile_name, (ulong) lock->cline, (ulong) i);
}
mutex_enter(rw_lock_get_mutex(lock));
@ -265,8 +265,8 @@ lock_loop:
if (srv_print_latch_waits) {
printf(
"Thread %lu OS wait rw-s-lock at %lx cfile %s cline %lu\n",
os_thread_pf(os_thread_get_curr_id()), (ulint)lock,
lock->cfile_name, lock->cline);
(ulong) os_thread_pf(os_thread_get_curr_id()),
(ulong) lock, lock->cfile_name, (ulong) lock->cline);
}
rw_s_system_call_count++;
@ -483,8 +483,8 @@ lock_loop:
if (srv_print_latch_waits) {
printf(
"Thread %lu spin wait rw-x-lock at %lx cfile %s cline %lu rnds %lu\n",
os_thread_pf(os_thread_get_curr_id()), (ulint)lock,
lock->cfile_name, lock->cline, i);
(ulong) os_thread_pf(os_thread_get_curr_id()), (ulong) lock,
lock->cfile_name, (ulong) lock->cline, (ulong) i);
}
rw_x_spin_wait_count++;
@ -516,8 +516,8 @@ lock_loop:
if (srv_print_latch_waits) {
printf(
"Thread %lu OS wait for rw-x-lock at %lx cfile %s cline %lu\n",
os_thread_pf(os_thread_get_curr_id()), (ulint)lock,
lock->cfile_name, lock->cline);
(ulong) os_thread_pf(os_thread_get_curr_id()), (ulong) lock,
lock->cfile_name, (ulong) lock->cline);
}
rw_x_system_call_count++;
@ -850,7 +850,8 @@ rw_lock_debug_print(
rwt = info->lock_type;
printf("Locked: thread %ld file %s line %ld ",
os_thread_pf(info->thread_id), info->file_name, info->line);
(ulong) os_thread_pf(info->thread_id), info->file_name,
(ulong) info->line);
if (rwt == RW_LOCK_SHARED) {
printf("S-LOCK");
} else if (rwt == RW_LOCK_EX) {
@ -861,7 +862,7 @@ rw_lock_debug_print(
ut_error;
}
if (info->pass != 0) {
printf(" pass value %lu", info->pass);
printf(" pass value %lu", (ulong) info->pass);
}
printf("\n");
}

30
innobase/sync/sync0sync.c
View file

@ -406,8 +406,8 @@ spin_loop:
if (srv_print_latch_waits) {
printf(
"Thread %lu spin wait mutex at %lx cfile %s cline %lu rnds %lu\n",
os_thread_pf(os_thread_get_curr_id()), (ulint)mutex,
mutex->cfile_name, mutex->cline, i);
(ulong) os_thread_pf(os_thread_get_curr_id()), (ulong) mutex,
mutex->cfile_name, (ulong) mutex->cline, (ulong) i);
}
mutex_spin_round_count += i;
@ -472,7 +472,8 @@ spin_loop:
if (srv_print_latch_waits) {
printf(
"Thread %lu spin wait succeeds at 2: mutex at %lx\n",
os_thread_pf(os_thread_get_curr_id()), (ulint)mutex);
(ulong) os_thread_pf(os_thread_get_curr_id()),
(ulong) mutex);
}
return;
@ -490,8 +491,8 @@ spin_loop:
if (srv_print_latch_waits) {
printf(
"Thread %lu OS wait mutex at %lx cfile %s cline %lu rnds %lu\n",
os_thread_pf(os_thread_get_curr_id()), (ulint)mutex,
mutex->cfile_name, mutex->cline, i);
(ulong) os_thread_pf(os_thread_get_curr_id()), (ulong) mutex,
mutex->cfile_name, (ulong) mutex->cline, (ulong) i);
}
mutex_system_call_count++;
@ -813,11 +814,11 @@ sync_thread_levels_g(
printf(
"InnoDB error: sync levels should be > %lu but a level is %lu\n",
limit, slot->level);
(ulong) limit, (ulong) slot->level);
if (mutex->magic_n == MUTEX_MAGIC_N) {
printf("Mutex created at %s %lu\n", mutex->cfile_name,
mutex->cline);
(ulong) mutex->cline);
if (mutex_get_lock_word(mutex) != 0) {
@ -825,8 +826,8 @@ sync_thread_levels_g(
&file_name, &line, &thread_id);
printf("InnoDB: Locked mutex: addr %lx thread %ld file %s line %ld\n",
(ulint)mutex, os_thread_pf(thread_id),
file_name, line);
(ulong) mutex, (ulong) os_thread_pf(thread_id),
file_name, (ulong) line);
} else {
printf("Not locked\n");
}
@ -1288,10 +1289,13 @@ sync_print_wait_info(
sprintf(buf,
"Mutex spin waits %lu, rounds %lu, OS waits %lu\n"
"RW-shared spins %lu, OS waits %lu; RW-excl spins %lu, OS waits %lu\n",
mutex_spin_wait_count, mutex_spin_round_count,
mutex_os_wait_count,
rw_s_spin_wait_count, rw_s_os_wait_count,
rw_x_spin_wait_count, rw_x_os_wait_count);
(ulong) mutex_spin_wait_count,
(ulong) mutex_spin_round_count,
(ulong) mutex_os_wait_count,
(ulong) rw_s_spin_wait_count,
(ulong) rw_s_os_wait_count,
(ulong) rw_x_spin_wait_count,
(ulong) rw_x_os_wait_count);
}
/***********************************************************************

25
innobase/trx/trx0purge.c
View file

@ -275,7 +275,7 @@ trx_purge_add_update_undo_to_history(
if (undo->id >= TRX_RSEG_N_SLOTS) {
fprintf(stderr,
"InnoDB: Error: undo->id is %lu\n", undo->id);
"InnoDB: Error: undo->id is %lu\n", (ulong) undo->id);
ut_a(0);
}
@ -905,7 +905,7 @@ trx_purge_fetch_next_rec(
if (srv_print_thread_releases) {
printf(
"Purge: No logs left in the history list; pages handled %lu\n",
purge_sys->n_pages_handled);
(ulong) purge_sys->n_pages_handled);
}
mutex_exit(&(purge_sys->mutex));
@ -1057,7 +1057,8 @@ trx_purge(void)
if (srv_print_thread_releases) {
printf(
"Purge ends; pages handled %lu\n", purge_sys->n_pages_handled);
"Purge ends; pages handled %lu\n",
(ulong) purge_sys->n_pages_handled);
}
return(purge_sys->n_pages_handled - old_pages_handled);
@ -1074,16 +1075,16 @@ trx_purge_sys_print(void)
read_view_print(purge_sys->view);
fprintf(stderr, "InnoDB: Purge trx n:o %lu %lu, undo n_o %lu %lu\n",
ut_dulint_get_high(purge_sys->purge_trx_no),
ut_dulint_get_low(purge_sys->purge_trx_no),
ut_dulint_get_high(purge_sys->purge_undo_no),
ut_dulint_get_low(purge_sys->purge_undo_no));
(ulong) ut_dulint_get_high(purge_sys->purge_trx_no),
(ulong) ut_dulint_get_low(purge_sys->purge_trx_no),
(ulong) ut_dulint_get_high(purge_sys->purge_undo_no),
(ulong) ut_dulint_get_low(purge_sys->purge_undo_no));
fprintf(stderr,
"InnoDB: Purge next stored %lu, page_no %lu, offset %lu,\n"
"InnoDB: Purge hdr_page_no %lu, hdr_offset %lu\n",
purge_sys->next_stored,
purge_sys->page_no,
purge_sys->offset,
purge_sys->hdr_page_no,
purge_sys->hdr_offset);
(ulong) purge_sys->next_stored,
(ulong) purge_sys->page_no,
(ulong) purge_sys->offset,
(ulong) purge_sys->hdr_page_no,
(ulong) purge_sys->hdr_offset);
}

36
innobase/trx/trx0rec.c
View file

@ -866,15 +866,16 @@ trx_undo_update_rec_get_update(
fprintf(stderr,
"InnoDB: Error: trying to access update undo rec field %lu in table %s\n"
"InnoDB: index %s, but index has only %lu fields\n",
field_no, index->table_name, index->name,
dict_index_get_n_fields(index));
(ulong) field_no, index->table_name, index->name,
(ulong) dict_index_get_n_fields(index));
fprintf(stderr,
"InnoDB: Send a detailed bug report to mysql@lists.mysql.com");
fprintf(stderr,
"InnoDB: Run also CHECK TABLE on table %s\n", index->table_name);
fprintf(stderr,
"InnoDB: n_fields = %lu, i = %lu, ptr %lx\n", n_fields, i, (ulint)ptr);
"InnoDB: n_fields = %lu, i = %lu, ptr %lx\n", (ulong) n_fields, (ulong) i,
(ulong) ptr);
return(NULL);
}
@ -1371,17 +1372,18 @@ trx_undo_prev_version_build(
fprintf(stderr,
"InnoDB: Table name %s, index name %s, n_uniq %lu\n",
index->table_name, index->name,
dict_index_get_n_unique(index));
(ulong) dict_index_get_n_unique(index));
fprintf(stderr,
"InnoDB: undo rec address %lx, type %lu cmpl_info %lu\n",
(ulint)undo_rec, type, cmpl_info);
(ulong) undo_rec, (ulong) type,
(ulong) cmpl_info);
fprintf(stderr,
"InnoDB: undo rec table id %lu %lu, index table id %lu %lu\n",
ut_dulint_get_high(table_id),
ut_dulint_get_low(table_id),
ut_dulint_get_high(index->table->id),
ut_dulint_get_low(index->table->id));
(ulong) ut_dulint_get_high(table_id),
(ulong) ut_dulint_get_low(table_id),
(ulong) ut_dulint_get_high(index->table->id),
(ulong) ut_dulint_get_low(index->table->id));
ut_sprintf_buf(err_buf, undo_rec, 150);
@ -1395,17 +1397,17 @@ trx_undo_prev_version_build(
fprintf(stderr,
"InnoDB: Record trx id %lu %lu, update rec trx id %lu %lu\n",
ut_dulint_get_high(rec_trx_id),
ut_dulint_get_low(rec_trx_id),
ut_dulint_get_high(trx_id),
ut_dulint_get_low(trx_id));
(ulong) ut_dulint_get_high(rec_trx_id),
(ulong) ut_dulint_get_low(rec_trx_id),
(ulong) ut_dulint_get_high(trx_id),
(ulong) ut_dulint_get_low(trx_id));
fprintf(stderr,
"InnoDB: Roll ptr in rec %lu %lu, in update rec %lu %lu\n",
ut_dulint_get_high(old_roll_ptr),
ut_dulint_get_low(old_roll_ptr),
ut_dulint_get_high(roll_ptr),
ut_dulint_get_low(roll_ptr));
(ulong) ut_dulint_get_high(old_roll_ptr),
(ulong) ut_dulint_get_low(old_roll_ptr),
(ulong) ut_dulint_get_high(roll_ptr),
(ulong) ut_dulint_get_low(roll_ptr));
trx_purge_sys_print();

26
innobase/trx/trx0roll.c
View file

@ -394,8 +394,8 @@ loop:
if (trx->conc_state == TRX_COMMITTED_IN_MEMORY) {
fprintf(stderr, "InnoDB: Cleaning up trx with id %lu %lu\n",
ut_dulint_get_high(trx->id),
ut_dulint_get_low(trx->id));
(ulong) ut_dulint_get_high(trx->id),
(ulong) ut_dulint_get_low(trx->id));
trx_cleanup_at_db_startup(trx);
@ -430,9 +430,9 @@ loop:
fprintf(stderr,
"InnoDB: Rolling back trx with id %lu %lu, %lu%s rows to undo",
ut_dulint_get_high(trx->id),
ut_dulint_get_low(trx->id),
(ulint)rows_to_undo, unit);
(ulong) ut_dulint_get_high(trx->id),
(ulong) ut_dulint_get_low(trx->id),
(ulong) rows_to_undo, unit);
mutex_exit(&kernel_mutex);
if (trx->dict_operation) {
@ -449,7 +449,7 @@ loop:
fprintf(stderr,
"InnoDB: Waiting for rollback of trx id %lu to end\n",
ut_dulint_get_low(trx->id));
(ulong) ut_dulint_get_low(trx->id));
os_thread_sleep(100000);
mutex_enter(&kernel_mutex);
@ -463,8 +463,8 @@ loop:
fprintf(stderr,
"InnoDB: Dropping table with id %lu %lu in recovery if it exists\n",
ut_dulint_get_high(trx->table_id),
ut_dulint_get_low(trx->table_id));
(ulong) ut_dulint_get_high(trx->table_id),
(ulong) ut_dulint_get_low(trx->table_id));
table = dict_table_get_on_id_low(trx->table_id, trx);
@ -483,8 +483,8 @@ loop:
}
fprintf(stderr, "\nInnoDB: Rolling back of trx id %lu %lu completed\n",
ut_dulint_get_high(trx->id),
ut_dulint_get_low(trx->id));
(ulong) ut_dulint_get_high(trx->id),
(ulong) ut_dulint_get_low(trx->id));
mem_heap_free(heap);
goto loop;
@ -853,10 +853,10 @@ try_again:
if (progress_pct != trx_roll_progress_printed_pct) {
if (trx_roll_progress_printed_pct == 0) {
fprintf(stderr,
"\nInnoDB: Progress in percents: %lu", progress_pct);
"\nInnoDB: Progress in percents: %lu", (ulong) progress_pct);
} else {
fprintf(stderr,
" %lu", progress_pct);
" %lu", (ulong) progress_pct);
}
fflush(stderr);
trx_roll_progress_printed_pct = progress_pct;
@ -1130,7 +1130,7 @@ trx_finish_rollback_off_kernel(
if (lock_print_waits) {
printf("Trx %lu rollback finished\n",
ut_dulint_get_low(trx->id));
(ulong) ut_dulint_get_low(trx->id));
}
trx_commit_off_kernel(trx);

24
innobase/trx/trx0sys.c
View file

@ -434,7 +434,7 @@ trx_sys_doublewrite_init_or_restore_pages(
fprintf(stderr,
"InnoDB: Warning: a page in the doublewrite buffer is not within space\n"
"InnoDB: bounds; space id %lu page number %lu, page %lu in doublewrite buf.\n",
space_id, page_no, i);
(ulong) space_id, (ulong) page_no, (ulong) i);
} else if (space_id == TRX_SYS_SPACE
&& ( (page_no >= block1
@ -457,7 +457,7 @@ trx_sys_doublewrite_init_or_restore_pages(
fprintf(stderr,
"InnoDB: Warning: database page corruption or a failed\n"
"InnoDB: file read of page %lu.\n", page_no);
"InnoDB: file read of page %lu.\n", (ulong) page_no);
fprintf(stderr,
"InnoDB: Trying to recover it from the doublewrite buffer.\n");
@ -628,9 +628,9 @@ trx_sys_print_mysql_binlog_offset_from_page(
printf(
"ibbackup: Last MySQL binlog file position %lu %lu, file name %s\n",
mach_read_from_4(sys_header + TRX_SYS_MYSQL_LOG_INFO
(ulong) mach_read_from_4(sys_header + TRX_SYS_MYSQL_LOG_INFO
+ TRX_SYS_MYSQL_LOG_OFFSET_HIGH),
mach_read_from_4(sys_header + TRX_SYS_MYSQL_LOG_INFO
(ulong) mach_read_from_4(sys_header + TRX_SYS_MYSQL_LOG_INFO
+ TRX_SYS_MYSQL_LOG_OFFSET_LOW),
sys_header + TRX_SYS_MYSQL_LOG_INFO + TRX_SYS_MYSQL_LOG_NAME);
}
@ -662,9 +662,9 @@ trx_sys_print_mysql_binlog_offset(void)
fprintf(stderr,
"InnoDB: Last MySQL binlog file position %lu %lu, file name %s\n",
mach_read_from_4(sys_header + TRX_SYS_MYSQL_LOG_INFO
(ulong) mach_read_from_4(sys_header + TRX_SYS_MYSQL_LOG_INFO
+ TRX_SYS_MYSQL_LOG_OFFSET_HIGH),
mach_read_from_4(sys_header + TRX_SYS_MYSQL_LOG_INFO
(ulong) mach_read_from_4(sys_header + TRX_SYS_MYSQL_LOG_INFO
+ TRX_SYS_MYSQL_LOG_OFFSET_LOW),
sys_header + TRX_SYS_MYSQL_LOG_INFO + TRX_SYS_MYSQL_LOG_NAME);
@ -698,9 +698,9 @@ trx_sys_print_mysql_master_log_pos(void)
fprintf(stderr,
"InnoDB: In a MySQL replication slave the last master binlog file\n"
"InnoDB: position %lu %lu, file name %s\n",
mach_read_from_4(sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
(ulong) mach_read_from_4(sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
+ TRX_SYS_MYSQL_LOG_OFFSET_HIGH),
mach_read_from_4(sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
(ulong) mach_read_from_4(sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
+ TRX_SYS_MYSQL_LOG_OFFSET_LOW),
sys_header + TRX_SYS_MYSQL_MASTER_LOG_INFO
+ TRX_SYS_MYSQL_LOG_NAME);
@ -872,12 +872,12 @@ trx_sys_init_at_db_start(void)
fprintf(stderr,
"InnoDB: %lu transaction(s) which must be rolled back or cleaned up\n"
"InnoDB: in total %lu%s row operations to undo\n",
UT_LIST_GET_LEN(trx_sys->trx_list),
(ulint)rows_to_undo, unit);
(ulong) UT_LIST_GET_LEN(trx_sys->trx_list),
(ulong) rows_to_undo, unit);
fprintf(stderr, "InnoDB: Trx id counter is %lu %lu\n",
ut_dulint_get_high(trx_sys->max_trx_id),
ut_dulint_get_low(trx_sys->max_trx_id));
(ulong) ut_dulint_get_high(trx_sys->max_trx_id),
(ulong) ut_dulint_get_low(trx_sys->max_trx_id));
}
UT_LIST_INIT(trx_sys->view_list);

24
innobase/trx/trx0trx.c
View file

@ -1589,26 +1589,26 @@ trx_print(
char* start_of_line;
buf += sprintf(buf, "TRANSACTION %lu %lu",
ut_dulint_get_high(trx->id),
ut_dulint_get_low(trx->id));
(ulong) ut_dulint_get_high(trx->id),
(ulong) ut_dulint_get_low(trx->id));
switch (trx->conc_state) {
case TRX_NOT_STARTED: buf += sprintf(buf,
", not started"); break;
case TRX_ACTIVE: buf += sprintf(buf,
", ACTIVE %lu sec",
(ulint)difftime(time(NULL), trx->start_time)); break;
(ulong) difftime(time(NULL), trx->start_time)); break;
case TRX_COMMITTED_IN_MEMORY: buf += sprintf(buf,
", COMMITTED IN MEMORY");
break;
default: buf += sprintf(buf, " state %lu", trx->conc_state);
default: buf += sprintf(buf, " state %lu", (ulong) trx->conc_state);
}
#ifdef UNIV_LINUX
buf += sprintf(buf, ", process no %lu", trx->mysql_process_no);
#endif
buf += sprintf(buf, ", OS thread id %lu",
os_thread_pf(trx->mysql_thread_id));
(ulong) os_thread_pf(trx->mysql_thread_id));
if (ut_strlen(trx->op_info) > 0) {
buf += sprintf(buf, " %s", trx->op_info);
@ -1620,7 +1620,7 @@ trx_print(
if (trx->declared_to_be_inside_innodb) {
buf += sprintf(buf, ", thread declared inside InnoDB %lu",
trx->n_tickets_to_enter_innodb);
(ulong) trx->n_tickets_to_enter_innodb);
}
buf += sprintf(buf, "\n");
@ -1628,8 +1628,8 @@ trx_print(
if (trx->n_mysql_tables_in_use > 0 || trx->mysql_n_tables_locked > 0) {
buf += sprintf(buf, "mysql tables in use %lu, locked %lu\n",
trx->n_mysql_tables_in_use,
trx->mysql_n_tables_locked);
(ulong) trx->n_mysql_tables_in_use,
(ulong) trx->mysql_n_tables_locked);
}
start_of_line = buf;
@ -1642,7 +1642,7 @@ trx_print(
"ROLLING BACK "); break;
case TRX_QUE_COMMITTING: buf += sprintf(buf,
"COMMITTING "); break;
default: buf += sprintf(buf, "que state %lu", trx->que_state);
default: buf += sprintf(buf, "que state %lu", (ulong) trx->que_state);
}
if (0 < UT_LIST_GET_LEN(trx->trx_locks) ||
@ -1650,8 +1650,8 @@ trx_print(
buf += sprintf(buf,
"%lu lock struct(s), heap size %lu",
UT_LIST_GET_LEN(trx->trx_locks),
mem_heap_get_size(trx->lock_heap));
(ulong) UT_LIST_GET_LEN(trx->trx_locks),
(ulong) mem_heap_get_size(trx->lock_heap));
}
if (trx->has_search_latch) {
@ -1660,7 +1660,7 @@ trx_print(
if (ut_dulint_cmp(trx->undo_no, ut_dulint_zero) != 0) {
buf += sprintf(buf, ", undo log entries %lu",
ut_dulint_get_low(trx->undo_no));
(ulong) ut_dulint_get_low(trx->undo_no));
}
if (buf != start_of_line) {

15
innobase/trx/trx0undo.c
View file

@ -1116,7 +1116,7 @@ trx_undo_mem_create_at_db_start(
if (id >= TRX_RSEG_N_SLOTS) {
fprintf(stderr,
"InnoDB: Error: undo->id is %lu\n", id);
"InnoDB: Error: undo->id is %lu\n", (ulong) id);
ut_a(0);
}
@ -1274,7 +1274,7 @@ trx_undo_mem_create(
if (id >= TRX_RSEG_N_SLOTS) {
fprintf(stderr,
"InnoDB: Error: undo->id is %lu\n", id);
"InnoDB: Error: undo->id is %lu\n", (ulong) id);
ut_a(0);
}
@ -1317,7 +1317,8 @@ trx_undo_mem_init_for_reuse(
ut_ad(mutex_own(&((undo->rseg)->mutex)));
if (undo->id >= TRX_RSEG_N_SLOTS) {
fprintf(stderr, "InnoDB: Error: undo->id is %lu\n", undo->id);
fprintf(stderr, "InnoDB: Error: undo->id is %lu\n",
(ulong) undo->id);
mem_analyze_corruption((byte*)undo);
ut_a(0);
@ -1343,7 +1344,7 @@ trx_undo_mem_free(
{
if (undo->id >= TRX_RSEG_N_SLOTS) {
fprintf(stderr,
"InnoDB: Error: undo->id is %lu\n", undo->id);
"InnoDB: Error: undo->id is %lu\n", (ulong) undo->id);
ut_a(0);
}
@ -1450,7 +1451,8 @@ trx_undo_reuse_cached(
ut_ad(undo->hdr_page_no == undo->top_page_no);
if (undo->id >= TRX_RSEG_N_SLOTS) {
fprintf(stderr, "InnoDB: Error: undo->id is %lu\n", undo->id);
fprintf(stderr, "InnoDB: Error: undo->id is %lu\n",
(ulong) undo->id);
mem_analyze_corruption((byte*)undo);
ut_a(0);
}
@ -1582,7 +1584,8 @@ trx_undo_set_state_at_finish(
ut_ad(trx && undo && mtr);
if (undo->id >= TRX_RSEG_N_SLOTS) {
fprintf(stderr, "InnoDB: Error: undo->id is %lu\n", undo->id);
fprintf(stderr, "InnoDB: Error: undo->id is %lu\n",
(ulong) undo->id);
mem_analyze_corruption((byte*)undo);
ut_a(0);
}

4
innobase/usr/usr0sess.c
View file

@ -620,10 +620,10 @@ sess_raise_error_low(
len = 0;
len += sprintf(str + len, "Error number: %lu", err_no);
len += sprintf(str + len, "Error number: %lu", (ulong) err_no);
if (type) {
len += sprintf(str + len, ", type: %lu", type);
len += sprintf(str + len, ", type: %lu", (ulong) type);
}
if (table) {

14
innobase/ut/ut0mem.c
View file

@ -89,11 +89,11 @@ ut_malloc_low(
"InnoDB: a big enough maximum process size.\n"
"InnoDB: We now intentionally generate a seg fault so that\n"
"InnoDB: on Linux we get a stack trace.\n",
n, ut_total_allocated_memory,
(ulong) n, (ulong) ut_total_allocated_memory,
#ifdef __WIN__
(ulint)GetLastError()
(ulong) GetLastError()
#else
(ulint)errno
(ulong) errno
#endif
);
@ -107,7 +107,7 @@ ut_malloc_low(
/* Make an intentional seg fault so that we get a stack
trace */
printf("%lu\n", *ut_mem_null_ptr);
printf("%lu\n", (ulong) *ut_mem_null_ptr);
}
if (set_to_zero) {
@ -166,7 +166,9 @@ ut_test_malloc(
"InnoDB: ulimits of your operating system.\n"
"InnoDB: On FreeBSD check you have compiled the OS with\n"
"InnoDB: a big enough maximum process size.\n",
n, ut_total_allocated_memory, errno);
(ulong) n,
(ulong) ut_total_allocated_memory,
(int) errno);
return(FALSE);
}
@ -225,7 +227,7 @@ ut_free_all_mem(void)
if (ut_total_allocated_memory != 0) {
fprintf(stderr,
"InnoDB: Warning: after shutdown total allocated memory is %lu\n",
ut_total_allocated_memory);
(ulong) ut_total_allocated_memory);
}
}

10
innobase/ut/ut0ut.c
View file

@ -474,7 +474,7 @@ ut_delay(
}
if (ut_always_false) {
printf("%lu", j);
printf("%lu", (ulong) j);
}
return(j);
@ -492,12 +492,12 @@ ut_print_buf(
byte* data;
ulint i;
printf(" len %lu; hex ", len);
printf(" len %lu; hex ", (ulong) len);
data = buf;
for (i = 0; i < len; i++) {
printf("%02lx", (ulint)*data);
printf("%02lx", (ulong) *data);
data++;
}
@ -532,12 +532,12 @@ ut_sprintf_buf(
n = 0;
n += sprintf(str + n, " len %lu; hex ", len);
n += sprintf(str + n, " len %lu; hex ", (ulong) len);
data = buf;
for (i = 0; i < len; i++) {
n += sprintf(str + n, "%02lx", (ulint)*data);
n += sprintf(str + n, "%02lx", (ulong) *data);
data++;
}

1
sql/sql_delete.cc
View file

@ -131,6 +131,7 @@ int mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds, SQL_LIST *order,
table->sort.io_cache = (IO_CACHE *) my_malloc(sizeof(IO_CACHE),
MYF(MY_FAE | MY_ZEROFILL));
if (thd->lex->select_lex.setup_ref_array(thd, order->elements) ||
setup_order(thd, thd->lex->select_lex.ref_pointer_array, &tables,
fields, all_fields, (ORDER*) order->first) ||
!(sortorder=make_unireg_sortorder((ORDER*) order->first, &length)) ||
(table->sort.found_records = filesort(thd, table, sortorder, length,