#At file:///usr/local/devel/bzrroot/server/mysql-trunk/ based on revid:serge.kozlov@stripped
3772 Vasil Dimov 2011-03-16 [merge]
Merge mysql-trunk-innodb -> mysql-trunk
added:
mysql-test/suite/innodb/r/innodb_bug11789106.result
mysql-test/suite/innodb/r/innodb_bug60196.result
mysql-test/suite/innodb/t/innodb_bug11789106.test
mysql-test/suite/innodb/t/innodb_bug60196-master.opt
mysql-test/suite/innodb/t/innodb_bug60196.test
modified:
mysql-test/suite/innodb/include/innodb_stats_bootstrap.inc
mysql-test/suite/innodb/r/innodb_monitor.result
mysql-test/suite/innodb/t/innodb_monitor.test
storage/innobase/CMakeLists.txt
storage/innobase/btr/btr0cur.c
storage/innobase/btr/btr0sea.c
storage/innobase/buf/buf0buf.c
storage/innobase/buf/buf0flu.c
storage/innobase/buf/buf0lru.c
storage/innobase/dict/dict0load.c
storage/innobase/dict/dict0stats.c
storage/innobase/fil/fil0fil.c
storage/innobase/handler/ha_innodb.cc
storage/innobase/handler/i_s.cc
storage/innobase/handler/i_s.h
storage/innobase/include/buf0buf.h
storage/innobase/include/buf0buf.ic
storage/innobase/include/buf0flu.h
storage/innobase/include/buf0flu.ic
storage/innobase/include/data0type.ic
storage/innobase/include/fil0fil.h
storage/innobase/include/ha_prototypes.h
storage/innobase/include/log0log.h
storage/innobase/include/log0log.ic
storage/innobase/include/log0recv.h
storage/innobase/include/mtr0mtr.h
storage/innobase/include/srv0mon.h
storage/innobase/include/srv0srv.h
storage/innobase/include/srv0start.h
storage/innobase/include/trx0trx.h
storage/innobase/include/univ.i
storage/innobase/lock/lock0lock.c
storage/innobase/log/log0log.c
storage/innobase/log/log0recv.c
storage/innobase/mem/mem0dbg.c
storage/innobase/mtr/mtr0mtr.c
storage/innobase/page/page0zip.c
storage/innobase/row/row0mysql.c
storage/innobase/row/row0sel.c
storage/innobase/scripts/persistent_storage.sql
storage/innobase/srv/srv0mon.c
storage/innobase/srv/srv0srv.c
storage/innobase/srv/srv0start.c
storage/innobase/sync/sync0arr.c
storage/innobase/sync/sync0rw.c
storage/innobase/sync/sync0sync.c
storage/innobase/trx/trx0sys.c
storage/innobase/trx/trx0trx.c
storage/innobase/ut/ut0dbg.c
=== modified file 'mysql-test/suite/innodb/include/innodb_stats_bootstrap.inc'
--- a/mysql-test/suite/innodb/include/innodb_stats_bootstrap.inc revid:serge.kozlov@stripped
+++ b/mysql-test/suite/innodb/include/innodb_stats_bootstrap.inc revid:vasil.dimov@stripped
@@ -4,22 +4,22 @@ DROP DATABASE IF EXISTS innodb;
CREATE DATABASE innodb;
CREATE TABLE innodb.table_stats (
- database_name VARCHAR(512) NOT NULL,
- table_name VARCHAR(512) NOT NULL,
+ database_name VARCHAR(64) NOT NULL,
+ table_name VARCHAR(64) NOT NULL,
stats_timestamp TIMESTAMP NOT NULL,
n_rows BIGINT UNSIGNED NOT NULL,
clustered_index_size BIGINT UNSIGNED NOT NULL,
sum_of_other_index_sizes BIGINT UNSIGNED NOT NULL,
PRIMARY KEY (database_name, table_name)
-) ENGINE=INNODB;
+) ENGINE=INNODB DEFAULT CHARSET=utf8;
CREATE TABLE innodb.index_stats (
- database_name VARCHAR(512) NOT NULL,
- table_name VARCHAR(512) NOT NULL,
- index_name VARCHAR(512) NOT NULL,
+ database_name VARCHAR(64) NOT NULL,
+ table_name VARCHAR(64) NOT NULL,
+ index_name VARCHAR(64) NOT NULL,
stat_timestamp TIMESTAMP NOT NULL,
/* there are at least:
- stat_name='index_size'
+ stat_name='size'
stat_name='n_leaf_pages'
stat_name='n_diff_pfx%' */
stat_name VARCHAR(64) NOT NULL,
@@ -29,7 +29,7 @@ CREATE TABLE innodb.index_stats (
PRIMARY KEY (database_name, table_name, index_name, stat_name),
FOREIGN KEY (database_name, table_name)
REFERENCES table_stats (database_name, table_name)
-) ENGINE=INNODB;
+) ENGINE=INNODB DEFAULT CHARSET=utf8;
-- enable_warnings
-- enable_query_log
=== added file 'mysql-test/suite/innodb/r/innodb_bug11789106.result'
Files a/mysql-test/suite/innodb/r/innodb_bug11789106.result 1970-01-01 00:00:00 +0000 and b/mysql-test/suite/innodb/r/innodb_bug11789106.result revid:vasil.dimov@stripped differ
=== added file 'mysql-test/suite/innodb/r/innodb_bug60196.result'
--- a/mysql-test/suite/innodb/r/innodb_bug60196.result 1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/innodb/r/innodb_bug60196.result revid:vasil.dimov@stripped
@@ -0,0 +1,73 @@
+CREATE TABLE Bug_60196_FK1 (Primary_Key INT PRIMARY KEY) ENGINE=InnoDB;
+CREATE TABLE Bug_60196_FK2 (Primary_Key INT PRIMARY KEY) ENGINE=InnoDB;
+CREATE TABLE Bug_60196 (
+FK1_Key INT NOT NULL,
+FK2_Key INT NOT NULL,
+PRIMARY KEY (FK2_Key, FK1_Key),
+KEY FK1_Key (FK1_Key),
+KEY FK2_Key (FK2_Key),
+CONSTRAINT FK_FK1 FOREIGN KEY (FK1_Key)
+REFERENCES Bug_60196_FK1 (Primary_Key)
+ON DELETE CASCADE
+ON UPDATE CASCADE,
+CONSTRAINT FK_FK2 FOREIGN KEY (FK2_Key)
+REFERENCES Bug_60196_FK2 (Primary_Key)
+ON DELETE CASCADE
+ON UPDATE CASCADE
+) ENGINE=InnoDB;
+INSERT INTO Bug_60196_FK1 VALUES (1), (2), (3), (4), (5);
+INSERT INTO Bug_60196_FK2 VALUES (1), (2), (3), (4), (5);
+INSERT INTO Bug_60196 VALUES (1, 1);
+INSERT INTO Bug_60196 VALUES (1, 2);
+INSERT INTO Bug_60196 VALUES (1, 3);
+INSERT INTO Bug_60196 VALUES (1, 99);
+ERROR 23000: Cannot add or update a child row: a foreign key constraint fails (`test`.`bug_60196`, CONSTRAINT `FK_FK2` FOREIGN KEY (`FK2_Key`) REFERENCES `Bug_60196_FK2` (`Primary_Key`) ON DELETE CASCADE ON UPDATE CASCADE)
+INSERT INTO Bug_60196 VALUES (99, 1);
+ERROR 23000: Cannot add or update a child row: a foreign key constraint fails (`test`.`bug_60196`, CONSTRAINT `FK_FK1` FOREIGN KEY (`FK1_Key`) REFERENCES `Bug_60196_FK1` (`Primary_Key`) ON DELETE CASCADE ON UPDATE CASCADE)
+SELECT * FROM bug_60196_FK1;
+Primary_Key
+1
+2
+3
+4
+5
+SELECT * FROM bug_60196_FK2;
+Primary_Key
+1
+2
+3
+4
+5
+SELECT * FROM bug_60196;
+FK1_Key FK2_Key
+1 1
+1 2
+1 3
+# Stop server
+# Restart server.
+#
+# Try to insert more to the example table with foreign keys.
+# Bug60196 causes the foreign key file not to be found after
+# the resstart above.
+#
+SELECT * FROM Bug_60196;
+FK1_Key FK2_Key
+1 1
+1 2
+1 3
+INSERT INTO Bug_60196 VALUES (2, 1);
+INSERT INTO Bug_60196 VALUES (2, 2);
+INSERT INTO Bug_60196 VALUES (2, 3);
+SELECT * FROM Bug_60196;
+FK1_Key FK2_Key
+1 1
+1 2
+1 3
+2 1
+2 2
+2 3
+
+# Clean up.
+DROP TABLE Bug_60196;
+DROP TABLE Bug_60196_FK1;
+DROP TABLE Bug_60196_FK2;
=== modified file 'mysql-test/suite/innodb/r/innodb_monitor.result'
--- a/mysql-test/suite/innodb/r/innodb_monitor.result revid:serge.kozlov@stripped
+++ b/mysql-test/suite/innodb/r/innodb_monitor.result revid:vasil.dimov@stripped
@@ -172,6 +172,10 @@ dml_inserts enabled
dml_deletes enabled
dml_updates enabled
ddl_background_drop_tables disabled
+icp_attempts disabled
+icp_no_match disabled
+icp_out_of_range disabled
+icp_match disabled
set global innodb_monitor_enable = all;
select name, status from information_schema.innodb_metrics;
name status
@@ -347,6 +351,10 @@ dml_inserts enabled
dml_deletes enabled
dml_updates enabled
ddl_background_drop_tables enabled
+icp_attempts enabled
+icp_no_match enabled
+icp_out_of_range enabled
+icp_match enabled
set global innodb_monitor_enable = aaa;
ERROR 42000: Variable 'innodb_monitor_enable' can't be set to the value of 'aaa'
set global innodb_monitor_disable = All;
@@ -524,6 +532,10 @@ dml_inserts disabled
dml_deletes disabled
dml_updates disabled
ddl_background_drop_tables disabled
+icp_attempts disabled
+icp_no_match disabled
+icp_out_of_range disabled
+icp_match disabled
set global innodb_monitor_reset_all = all;
select name, count, status from information_schema.innodb_metrics;
name count status
@@ -699,6 +711,10 @@ dml_inserts 0 disabled
dml_deletes 0 disabled
dml_updates 0 disabled
ddl_background_drop_tables 0 disabled
+icp_attempts 0 disabled
+icp_no_match 0 disabled
+icp_out_of_range 0 disabled
+icp_match 0 disabled
set global innodb_monitor_enable = "%lock%";
select name, status from information_schema.innodb_metrics
where name like "%lock%";
@@ -928,6 +944,10 @@ dml_inserts enabled
dml_deletes enabled
dml_updates enabled
ddl_background_drop_tables enabled
+icp_attempts enabled
+icp_no_match enabled
+icp_out_of_range enabled
+icp_match enabled
set global innodb_monitor_disable="%%%%%";
select name, status from information_schema.innodb_metrics;
name status
@@ -1103,6 +1123,10 @@ dml_inserts disabled
dml_deletes disabled
dml_updates disabled
ddl_background_drop_tables disabled
+icp_attempts disabled
+icp_no_match disabled
+icp_out_of_range disabled
+icp_match disabled
set global innodb_monitor_enable="%";
select name, status from information_schema.innodb_metrics;
name status
@@ -1278,6 +1302,10 @@ dml_inserts enabled
dml_deletes enabled
dml_updates enabled
ddl_background_drop_tables enabled
+icp_attempts enabled
+icp_no_match enabled
+icp_out_of_range enabled
+icp_match enabled
set global innodb_monitor_disable="%_%";
select name, status from information_schema.innodb_metrics;
name status
@@ -1453,6 +1481,10 @@ dml_inserts disabled
dml_deletes disabled
dml_updates disabled
ddl_background_drop_tables disabled
+icp_attempts disabled
+icp_no_match disabled
+icp_out_of_range disabled
+icp_match disabled
set global innodb_monitor_enable="log%%%%";
select name, status from information_schema.innodb_metrics;
name status
@@ -1628,6 +1660,10 @@ dml_inserts disabled
dml_deletes disabled
dml_updates disabled
ddl_background_drop_tables disabled
+icp_attempts disabled
+icp_no_match disabled
+icp_out_of_range disabled
+icp_match disabled
set global innodb_monitor_enable="os_%a_fs_ncs";
set global innodb_monitor_enable="os%pending%";
select name, status from information_schema.innodb_metrics
@@ -1866,6 +1902,30 @@ where name like "file_num_open_files";
name max_count min_count count max_count_reset min_count_reset count_reset status
file_num_open_files 3 3 3 3 3 3 enabled
set global innodb_monitor_disable = file_num_open_files;
+set global innodb_monitor_enable = "icp%";
+create table monitor_test(a char(3), b int, c char(2),
+primary key (a(1), c(1)), key(b)) engine = innodb;
+insert into monitor_test values("13", 2, "aa");
+select a from monitor_test where b < 1 for update;
+a
+select name, count from information_schema.innodb_metrics
+where name like "icp%";
+name count
+icp_attempts 1
+icp_no_match 0
+icp_out_of_range 1
+icp_match 0
+select a from monitor_test where b < 3 for update;
+a
+13
+select name, count from information_schema.innodb_metrics
+where name like "icp%";
+name count
+icp_attempts 2
+icp_no_match 0
+icp_out_of_range 1
+icp_match 1
+drop table monitor_test;
set global innodb_monitor_enable = default;
set global innodb_monitor_disable = default;
set global innodb_monitor_reset = default;
=== added file 'mysql-test/suite/innodb/t/innodb_bug11789106.test'
--- a/mysql-test/suite/innodb/t/innodb_bug11789106.test 1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/innodb/t/innodb_bug11789106.test revid:vasil.dimov@stripped
@@ -0,0 +1,17 @@
+# Test for bug #11789106: FAILING ASSERTION: templ->mbmaxlen > templ->mbminlen
+# templ->mysql_col_len == len
+
+-- source include/have_innodb.inc
+
+create table table_11789106(`a` point,`b` int,`c` char(2),
+ primary key (`a`(1),`c`(1)), key (`b`))
+character set latin2 engine=innodb;
+
+insert into table_11789106 values (geomfromtext('point(1 1)'),'','');
+
+# This will trigger the assertion failure in
+# row_sel_field_store_in_mysql_format_func()
+select `a` from table_11789106 where `b` < '1' for update;
+
+drop table table_11789106;
+
=== added file 'mysql-test/suite/innodb/t/innodb_bug60196-master.opt'
--- a/mysql-test/suite/innodb/t/innodb_bug60196-master.opt 1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/innodb/t/innodb_bug60196-master.opt revid:vasil.dimov@stripped
@@ -0,0 +1 @@
+--lower-case-table-names=2
=== added file 'mysql-test/suite/innodb/t/innodb_bug60196.test'
--- a/mysql-test/suite/innodb/t/innodb_bug60196.test 1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/innodb/t/innodb_bug60196.test revid:vasil.dimov@stripped
@@ -0,0 +1,87 @@
+# Bug#60196 - Setting lowercase_table_names to 2 on Windows causing
+# Foreign Key problems after an engine is restarted.
+
+# This test case needs InnoDB, a lowercase file system,
+# lower-case-table-names=2, and cannot use the embedded server
+# because it restarts the server.
+--source include/not_embedded.inc
+--source include/have_lowercase2.inc
+--source include/have_case_insensitive_file_system.inc
+--source include/have_innodb.inc
+
+#
+# Create test data.
+#
+CREATE TABLE Bug_60196_FK1 (Primary_Key INT PRIMARY KEY) ENGINE=InnoDB;
+CREATE TABLE Bug_60196_FK2 (Primary_Key INT PRIMARY KEY) ENGINE=InnoDB;
+CREATE TABLE Bug_60196 (
+ FK1_Key INT NOT NULL,
+ FK2_Key INT NOT NULL,
+ PRIMARY KEY (FK2_Key, FK1_Key),
+ KEY FK1_Key (FK1_Key),
+ KEY FK2_Key (FK2_Key),
+ CONSTRAINT FK_FK1 FOREIGN KEY (FK1_Key)
+ REFERENCES Bug_60196_FK1 (Primary_Key)
+ ON DELETE CASCADE
+ ON UPDATE CASCADE,
+ CONSTRAINT FK_FK2 FOREIGN KEY (FK2_Key)
+ REFERENCES Bug_60196_FK2 (Primary_Key)
+ ON DELETE CASCADE
+ ON UPDATE CASCADE
+) ENGINE=InnoDB;
+INSERT INTO Bug_60196_FK1 VALUES (1), (2), (3), (4), (5);
+INSERT INTO Bug_60196_FK2 VALUES (1), (2), (3), (4), (5);
+INSERT INTO Bug_60196 VALUES (1, 1);
+INSERT INTO Bug_60196 VALUES (1, 2);
+INSERT INTO Bug_60196 VALUES (1, 3);
+--error ER_NO_REFERENCED_ROW_2
+INSERT INTO Bug_60196 VALUES (1, 99);
+--error ER_NO_REFERENCED_ROW_2
+INSERT INTO Bug_60196 VALUES (99, 1);
+
+SELECT * FROM bug_60196_FK1;
+SELECT * FROM bug_60196_FK2;
+SELECT * FROM bug_60196;
+
+--echo # Stop server
+
+# Write file to make mysql-test-run.pl wait for the server to stop
+-- exec echo "wait" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
+
+# Send a shutdown request to the server
+-- shutdown_server 10
+
+# Call script that will poll the server waiting for it to disapear
+-- source include/wait_until_disconnected.inc
+
+--echo # Restart server.
+
+# Write file to make mysql-test-run.pl start up the server again
+--exec echo "restart" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
+
+# Turn on reconnect
+--enable_reconnect
+
+# Call script that will poll the server waiting for it to be back online again
+--source include/wait_until_connected_again.inc
+
+# Turn off reconnect again
+--disable_reconnect
+
+--echo #
+--echo # Try to insert more to the example table with foreign keys.
+--echo # Bug60196 causes the foreign key file not to be found after
+--echo # the resstart above.
+--echo #
+SELECT * FROM Bug_60196;
+INSERT INTO Bug_60196 VALUES (2, 1);
+INSERT INTO Bug_60196 VALUES (2, 2);
+INSERT INTO Bug_60196 VALUES (2, 3);
+SELECT * FROM Bug_60196;
+
+--echo
+--echo # Clean up.
+DROP TABLE Bug_60196;
+DROP TABLE Bug_60196_FK1;
+DROP TABLE Bug_60196_FK2;
+
=== modified file 'mysql-test/suite/innodb/t/innodb_monitor.test'
--- a/mysql-test/suite/innodb/t/innodb_monitor.test revid:serge.kozlov@stripped
+++ b/mysql-test/suite/innodb/t/innodb_monitor.test revid:vasil.dimov@stripped
@@ -340,6 +340,28 @@ where name like "file_num_open_files";
set global innodb_monitor_disable = file_num_open_files;
+# Test ICP module counters
+set global innodb_monitor_enable = "icp%";
+
+create table monitor_test(a char(3), b int, c char(2),
+primary key (a(1), c(1)), key(b)) engine = innodb;
+
+insert into monitor_test values("13", 2, "aa");
+
+select a from monitor_test where b < 1 for update;
+
+# should have icp_attempts = 1 and icp_out_of_range = 1
+select name, count from information_schema.innodb_metrics
+where name like "icp%";
+
+# should have icp_attempts = 2 and icp_match = 1
+select a from monitor_test where b < 3 for update;
+
+select name, count from information_schema.innodb_metrics
+where name like "icp%";
+
+drop table monitor_test;
+
-- disable_warnings
set global innodb_monitor_enable = default;
set global innodb_monitor_disable = default;
=== modified file 'storage/innobase/CMakeLists.txt'
--- a/storage/innobase/CMakeLists.txt revid:serge.kozlov@stripped
+++ b/storage/innobase/CMakeLists.txt revid:vasil.dimov@stripped
@@ -42,6 +42,14 @@ ENDIF()
SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DUNIV_DEBUG")
SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DUNIV_DEBUG")
+# Add -Wconversion if compiling with GCC
+## As of Mar 15 2011 this flag causes 3573+ warnings. If you are reading this
+## please fix them and enable the following code:
+#IF(CMAKE_C_COMPILER_ID MATCHES "GNU")
+# SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wconversion")
+# SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wconversion")
+#ENDIF()
+
IF(NOT MSVC)
# either define HAVE_IB_GCC_ATOMIC_BUILTINS or not
IF(NOT CMAKE_CROSSCOMPILING)
=== modified file 'storage/innobase/btr/btr0cur.c'
--- a/storage/innobase/btr/btr0cur.c revid:serge.kozlov@stripped
+++ b/storage/innobase/btr/btr0cur.c revid:vasil.dimov@stripped
@@ -4905,27 +4905,45 @@ btr_copy_blob_prefix(
/*******************************************************************//**
Copies the prefix of a compressed BLOB. The clustered index record
-that points to this BLOB must be protected by a lock or a page latch. */
+that points to this BLOB must be protected by a lock or a page latch.
+@return number of bytes written to buf */
static
-void
+ulint
btr_copy_zblob_prefix(
/*==================*/
- z_stream* d_stream,/*!< in/out: the decompressing stream */
+ byte* buf, /*!< out: the externally stored part of
+ the field, or a prefix of it */
+ ulint len, /*!< in: length of buf, in bytes */
ulint zip_size,/*!< in: compressed BLOB page size */
ulint space_id,/*!< in: space id of the BLOB pages */
ulint page_no,/*!< in: page number of the first BLOB page */
ulint offset) /*!< in: offset on the first BLOB page */
{
- ulint page_type = FIL_PAGE_TYPE_ZBLOB;
+ ulint page_type = FIL_PAGE_TYPE_ZBLOB;
+ mem_heap_t* heap;
+ int err;
+ z_stream d_stream;
+
+ d_stream.next_out = buf;
+ d_stream.avail_out = len;
+ d_stream.next_in = Z_NULL;
+ d_stream.avail_in = 0;
+
+ /* Zlib inflate needs 32 kilobytes for the default
+ window size, plus a few kilobytes for small objects. */
+ heap = mem_heap_create(40000);
+ page_zip_set_alloc(&d_stream, heap);
ut_ad(ut_is_2pow(zip_size));
ut_ad(zip_size >= PAGE_ZIP_MIN_SIZE);
ut_ad(zip_size <= UNIV_PAGE_SIZE);
ut_ad(space_id);
+ err = inflateInit(&d_stream);
+ ut_a(err == Z_OK);
+
for (;;) {
buf_page_t* bpage;
- int err;
ulint next_page_no;
/* There is no latch on bpage directly. Instead,
@@ -4941,7 +4959,7 @@ btr_copy_zblob_prefix(
" compressed BLOB"
" page %lu space %lu\n",
(ulong) page_no, (ulong) space_id);
- return;
+ goto func_exit;
}
if (UNIV_UNLIKELY
@@ -4967,13 +4985,13 @@ btr_copy_zblob_prefix(
offset += 4;
}
- d_stream->next_in = bpage->zip.data + offset;
- d_stream->avail_in = zip_size - offset;
+ d_stream.next_in = bpage->zip.data + offset;
+ d_stream.avail_in = zip_size - offset;
- err = inflate(d_stream, Z_NO_FLUSH);
+ err = inflate(&d_stream, Z_NO_FLUSH);
switch (err) {
case Z_OK:
- if (!d_stream->avail_out) {
+ if (!d_stream.avail_out) {
goto end_of_blob;
}
break;
@@ -4990,13 +5008,13 @@ inflate_error:
" compressed BLOB"
" page %lu space %lu returned %d (%s)\n",
(ulong) page_no, (ulong) space_id,
- err, d_stream->msg);
+ err, d_stream.msg);
case Z_BUF_ERROR:
goto end_of_blob;
}
if (next_page_no == FIL_NULL) {
- if (!d_stream->avail_in) {
+ if (!d_stream.avail_in) {
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: unexpected end of"
@@ -5005,7 +5023,7 @@ inflate_error:
(ulong) page_no,
(ulong) space_id);
} else {
- err = inflate(d_stream, Z_FINISH);
+ err = inflate(&d_stream, Z_FINISH);
switch (err) {
case Z_STREAM_END:
case Z_BUF_ERROR:
@@ -5017,7 +5035,7 @@ inflate_error:
end_of_blob:
buf_page_release_zip(bpage);
- return;
+ goto func_exit;
}
buf_page_release_zip(bpage);
@@ -5029,6 +5047,12 @@ end_of_blob:
offset = FIL_PAGE_NEXT;
page_type = FIL_PAGE_TYPE_ZBLOB2;
}
+
+func_exit:
+ inflateEnd(&d_stream);
+ mem_heap_free(heap);
+ UNIV_MEM_ASSERT_RW(buf, d_stream.total_out);
+ return(d_stream.total_out);
}
/*******************************************************************//**
@@ -5054,28 +5078,8 @@ btr_copy_externally_stored_field_prefix_
}
if (UNIV_UNLIKELY(zip_size)) {
- int err;
- z_stream d_stream;
- mem_heap_t* heap;
-
- /* Zlib inflate needs 32 kilobytes for the default
- window size, plus a few kilobytes for small objects. */
- heap = mem_heap_create(40000);
- page_zip_set_alloc(&d_stream, heap);
-
- err = inflateInit(&d_stream);
- ut_a(err == Z_OK);
-
- d_stream.next_out = buf;
- d_stream.avail_out = len;
- d_stream.avail_in = 0;
-
- btr_copy_zblob_prefix(&d_stream, zip_size,
- space_id, page_no, offset);
- inflateEnd(&d_stream);
- mem_heap_free(heap);
- UNIV_MEM_ASSERT_RW(buf, d_stream.total_out);
- return(d_stream.total_out);
+ return(btr_copy_zblob_prefix(buf, len, zip_size,
+ space_id, page_no, offset));
} else {
return(btr_copy_blob_prefix(buf, len, space_id,
page_no, offset));
=== modified file 'storage/innobase/btr/btr0sea.c'
--- a/storage/innobase/btr/btr0sea.c revid:serge.kozlov@stripped
+++ b/storage/innobase/btr/btr0sea.c revid:vasil.dimov@stripped
@@ -1232,8 +1232,8 @@ btr_search_drop_page_hash_when_freed(
having to fear a deadlock. */
block = buf_page_get_gen(space, zip_size, page_no, RW_S_LATCH, NULL,
- BUF_GET_IF_IN_POOL, __FILE__, __LINE__,
- &mtr);
+ BUF_PEEK_IF_IN_POOL, __FILE__, __LINE__,
+ &mtr);
/* Because the buffer pool mutex was released by
buf_page_peek_if_search_hashed(), it is possible that the
block was removed from the buffer pool by another thread
=== modified file 'storage/innobase/buf/buf0buf.c'
--- a/storage/innobase/buf/buf0buf.c revid:serge.kozlov@stripped
+++ b/storage/innobase/buf/buf0buf.c revid:vasil.dimov@stripped
@@ -308,14 +308,14 @@ Gets the smallest oldest_modification ls
zero if all modified pages have been flushed to disk.
@return oldest modification in pool, zero if none */
UNIV_INTERN
-ib_uint64_t
+lsn_t
buf_pool_get_oldest_modification(void)
/*==================================*/
{
ulint i;
buf_page_t* bpage;
- ib_uint64_t lsn = 0;
- ib_uint64_t oldest_lsn = 0;
+ lsn_t lsn = 0;
+ lsn_t oldest_lsn = 0;
/* When we traverse all the flush lists we don't want another
thread to add a dirty page to any flush list. */
@@ -527,7 +527,7 @@ buf_page_is_corrupted(
#ifndef UNIV_HOTBACKUP
if (recv_lsn_checks_on) {
- ib_uint64_t current_lsn;
+ lsn_t current_lsn;
if (log_peek_lsn(¤t_lsn)
&& UNIV_UNLIKELY
@@ -539,7 +539,7 @@ buf_page_is_corrupted(
" InnoDB: Error: page %lu log sequence number"
" %llu\n"
"InnoDB: is in the future! Current system "
- "log sequence number %llu.\n"
+ "log sequence number " LSN_PF ".\n"
"InnoDB: Your database may be corrupt or "
"you may have copied the InnoDB\n"
"InnoDB: tablespace but not the InnoDB "
@@ -1385,11 +1385,11 @@ buf_pool_drop_hash_index_instance(
/* block->is_hashed cannot be modified
when we have an x-latch on btr_search_latch;
see the comment in buf0buf.h */
-
+
if (!block->is_hashed) {
continue;
}
-
+
/* To follow the latching order, we
have to release btr_search_latch
before acquiring block->latch. */
@@ -1398,14 +1398,14 @@ buf_pool_drop_hash_index_instance(
we must rescan all blocks, because
some may become hashed again. */
*released_search_latch = TRUE;
-
+
rw_lock_x_lock(&block->lock);
-
+
/* This should be guaranteed by the
callers, which will be holding
btr_search_enabled_mutex. */
ut_ad(!btr_search_enabled);
-
+
/* Because we did not buffer-fix the
block by calling buf_block_get_gen(),
it is possible that the block has been
@@ -1415,7 +1415,7 @@ buf_pool_drop_hash_index_instance(
block is mapped to. All we want to do
is to drop any hash entries referring
to the page. */
-
+
/* It is possible that
block->page.state != BUF_FILE_PAGE.
Even that does not matter, because
@@ -1423,18 +1423,18 @@ buf_pool_drop_hash_index_instance(
check block->is_hashed before doing
anything. block->is_hashed can only
be set on uncompressed file pages. */
-
+
btr_search_drop_page_hash_index(block);
-
+
rw_lock_x_unlock(&block->lock);
-
+
rw_lock_x_lock(&btr_search_latch);
-
+
ut_ad(!btr_search_enabled);
}
}
}
-
+
/********************************************************************//**
Drops the adaptive hash index. To prevent a livelock, this function
is only to be called while holding btr_search_latch and while
@@ -2081,30 +2081,30 @@ buf_pool_resize(void)
ulint min_change_size = 1048576 * srv_buf_pool_instances;
buf_pool_mutex_enter_all();
-
+
if (srv_buf_pool_old_size == srv_buf_pool_size) {
-
+
buf_pool_mutex_exit_all();
return;
} else if (srv_buf_pool_curr_size + min_change_size
> srv_buf_pool_size) {
-
+
change_size = (srv_buf_pool_curr_size - srv_buf_pool_size)
/ UNIV_PAGE_SIZE;
buf_pool_mutex_exit_all();
-
+
/* Disable adaptive hash indexes and empty the index
in order to free up memory in the buffer pool chunks. */
buf_pool_shrink(change_size);
} else if (srv_buf_pool_curr_size + min_change_size
< srv_buf_pool_size) {
-
+
/* Enlarge the buffer pool by at least one megabyte */
-
+
change_size = srv_buf_pool_size - srv_buf_pool_curr_size;
buf_pool_mutex_exit_all();
@@ -2117,10 +2117,10 @@ buf_pool_resize(void)
return;
}
-
+
buf_pool_page_hash_rebuild();
}
-
+
/****************************************************************//**
Remove the sentinel block for the watch before replacing it with a real block.
buf_page_watch_clear() or buf_page_watch_occurred() will notice that
@@ -2682,16 +2682,19 @@ buf_block_align_instance(
/* TODO: protect buf_pool->chunks with a mutex (it will
currently remain constant after buf_pool_init()) */
for (chunk = buf_pool->chunks, i = buf_pool->n_chunks; i--; chunk++) {
- lint offs = ptr - chunk->blocks->frame;
+ ulint offs;
- if (UNIV_UNLIKELY(offs < 0)) {
+ if (UNIV_UNLIKELY(ptr < chunk->blocks->frame)) {
continue;
}
+ /* else */
+
+ offs = ptr - chunk->blocks->frame;
offs >>= UNIV_PAGE_SIZE_SHIFT;
- if (UNIV_LIKELY((ulint) offs < chunk->size)) {
+ if (UNIV_LIKELY(offs < chunk->size)) {
buf_block_t* block = &chunk->blocks[offs];
/* The function buf_chunk_init() invokes
@@ -2866,7 +2869,7 @@ buf_page_get_gen(
ulint rw_latch,/*!< in: RW_S_LATCH, RW_X_LATCH, RW_NO_LATCH */
buf_block_t* guess, /*!< in: guessed block or NULL */
ulint mode, /*!< in: BUF_GET, BUF_GET_IF_IN_POOL,
- BUF_GET_NO_LATCH, or
+ BUF_PEEK_IF_IN_POOL, BUF_GET_NO_LATCH, or
BUF_GET_IF_IN_POOL_OR_WATCH */
const char* file, /*!< in: file name */
ulint line, /*!< in: line where called */
@@ -2888,11 +2891,20 @@ buf_page_get_gen(
ut_ad((rw_latch == RW_S_LATCH)
|| (rw_latch == RW_X_LATCH)
|| (rw_latch == RW_NO_LATCH));
- ut_ad((mode != BUF_GET_NO_LATCH) || (rw_latch == RW_NO_LATCH));
- ut_ad(mode == BUF_GET
- || mode == BUF_GET_IF_IN_POOL
- || mode == BUF_GET_NO_LATCH
- || mode == BUF_GET_IF_IN_POOL_OR_WATCH);
+#ifdef UNIV_DEBUG
+ switch (mode) {
+ case BUF_GET_NO_LATCH:
+ ut_ad(rw_latch == RW_NO_LATCH);
+ break;
+ case BUF_GET:
+ case BUF_GET_IF_IN_POOL:
+ case BUF_PEEK_IF_IN_POOL:
+ case BUF_GET_IF_IN_POOL_OR_WATCH:
+ break;
+ default:
+ ut_error;
+ }
+#endif /* UNIV_DEBUG */
ut_ad(zip_size == fil_space_get_zip_size(space));
ut_ad(ut_is_2pow(zip_size));
#ifndef UNIV_LOG_DEBUG
@@ -2964,6 +2976,7 @@ loop2:
}
if (mode == BUF_GET_IF_IN_POOL
+ || mode == BUF_PEEK_IF_IN_POOL
|| mode == BUF_GET_IF_IN_POOL_OR_WATCH) {
#ifdef UNIV_SYNC_DEBUG
ut_ad(!rw_lock_own(hash_lock, RW_LOCK_EX));
@@ -3017,7 +3030,8 @@ got_block:
must_read = buf_block_get_io_fix(block) == BUF_IO_READ;
- if (must_read && mode == BUF_GET_IF_IN_POOL) {
+ if (must_read && (mode == BUF_GET_IF_IN_POOL
+ || mode == BUF_PEEK_IF_IN_POOL)) {
/* The page is being read to buffer pool,
but we cannot wait around for the read to
@@ -3148,6 +3162,7 @@ wait_until_unfixed:
mutex_exit(&buf_pool->zip_mutex);
buf_pool->n_pend_unzip++;
+ bpage->state = BUF_BLOCK_ZIP_FREE;
buf_buddy_free(buf_pool, bpage, sizeof *bpage);
buf_pool_mutex_exit(buf_pool);
@@ -3273,7 +3288,9 @@ wait_until_unfixed:
access_time = buf_page_is_accessed(&block->page);
- buf_page_set_accessed_make_young(&block->page, access_time);
+ if (UNIV_LIKELY(mode != BUF_PEEK_IF_IN_POOL)) {
+ buf_page_set_accessed_make_young(&block->page, access_time);
+ }
#if defined UNIV_DEBUG_FILE_ACCESSES || defined UNIV_DEBUG
ut_a(!block->page.file_page_was_freed);
@@ -3326,7 +3343,7 @@ wait_until_unfixed:
mtr_memo_push(mtr, block, fix_type);
- if (!access_time) {
+ if (UNIV_LIKELY(mode != BUF_PEEK_IF_IN_POOL) && !access_time) {
/* In the case of a first access, try to apply linear
read-ahead */
@@ -3938,6 +3955,7 @@ err_exit:
/* The block was added by some other thread. */
rw_lock_x_unlock(hash_lock);
watch_page = NULL;
+ bpage->state = BUF_BLOCK_ZIP_FREE;
buf_buddy_free(buf_pool, bpage, sizeof *bpage);
buf_buddy_free(buf_pool, data, zip_size);
@@ -5149,7 +5167,7 @@ buf_get_modified_ratio_pct(void)
buf_get_total_list_len(&lru_len, &free_len, &flush_list_len);
ratio = (100 * flush_list_len) / (1 + lru_len + free_len);
-
+
/* 1 + is there to avoid division by zero */
return(ratio);
=== modified file 'storage/innobase/buf/buf0flu.c'
--- a/storage/innobase/buf/buf0flu.c revid:serge.kozlov@stripped
+++ b/storage/innobase/buf/buf0flu.c revid:vasil.dimov@stripped
@@ -295,7 +295,7 @@ buf_flush_insert_into_flush_list(
/*=============================*/
buf_pool_t* buf_pool, /*!< buffer pool instance */
buf_block_t* block, /*!< in/out: block which is modified */
- ib_uint64_t lsn) /*!< in: oldest modification */
+ lsn_t lsn) /*!< in: oldest modification */
{
ut_ad(!buf_pool_mutex_own(buf_pool));
ut_ad(log_flush_order_mutex_own());
@@ -350,7 +350,7 @@ buf_flush_insert_sorted_into_flush_list(
/*====================================*/
buf_pool_t* buf_pool, /*!< in: buffer pool instance */
buf_block_t* block, /*!< in/out: block which is modified */
- ib_uint64_t lsn) /*!< in: oldest modification */
+ lsn_t lsn) /*!< in: oldest modification */
{
buf_page_t* prev_b;
buf_page_t* b;
@@ -1009,10 +1009,10 @@ UNIV_INTERN
void
buf_flush_init_for_writing(
/*=======================*/
- byte* page, /*!< in/out: page */
- void* page_zip_, /*!< in/out: compressed page, or NULL */
- ib_uint64_t newest_lsn) /*!< in: newest modification lsn
- to the page */
+ byte* page, /*!< in/out: page */
+ void* page_zip_, /*!< in/out: compressed page, or NULL */
+ lsn_t newest_lsn) /*!< in: newest modification lsn
+ to the page */
{
ut_ad(page);
@@ -1620,7 +1620,7 @@ buf_flush_flush_list_batch(
of blocks flushed (it is not
guaranteed that the actual
number is that big, though) */
- ib_uint64_t lsn_limit) /*!< all blocks whose
+ lsn_t lsn_limit) /*!< all blocks whose
oldest_modification is smaller
than this should be flushed (if
their number does not exceed
@@ -1733,7 +1733,7 @@ buf_flush_batch(
ulint min_n, /*!< in: wished minimum mumber of blocks
flushed (it is not guaranteed that the
actual number is that big, though) */
- ib_uint64_t lsn_limit) /*!< in: in the case of BUF_FLUSH_LIST
+ lsn_t lsn_limit) /*!< in: in the case of BUF_FLUSH_LIST
all blocks whose oldest_modification is
smaller than this should be flushed
(if their number does not exceed
@@ -1940,7 +1940,7 @@ buf_flush_list(
ulint min_n, /*!< in: wished minimum mumber of blocks
flushed (it is not guaranteed that the
actual number is that big, though) */
- ib_uint64_t lsn_limit) /*!< in the case BUF_FLUSH_LIST all
+ lsn_t lsn_limit) /*!< in the case BUF_FLUSH_LIST all
blocks whose oldest_modification is
smaller than this should be flushed
(if their number does not exceed
@@ -1998,7 +1998,7 @@ buf_flush_list(
page_count);
}
- return(lsn_limit != IB_ULONGLONG_MAX && skipped
+ return(lsn_limit != LSN_MAX && skipped
? ULINT_UNDEFINED : total_page_count);
}
@@ -2119,8 +2119,8 @@ buf_flush_stat_update(void)
/*=======================*/
{
buf_flush_stat_t* item;
- ib_uint64_t lsn_diff;
- ib_uint64_t lsn;
+ lsn_t lsn_diff;
+ lsn_t lsn;
ulint n_flushed;
lsn = log_get_lsn();
@@ -2168,14 +2168,13 @@ ulint
buf_flush_get_desired_flush_rate(void)
/*==================================*/
{
- lint rate;
ulint i;
- ulint redo_avg;
+ lsn_t redo_avg;
ulint n_dirty = 0;
- ulint n_flush_req;
- ulint lru_flush_avg;
- ib_uint64_t lsn = log_get_lsn();
- ulint log_capacity = log_get_capacity();
+ ib_uint64_t n_flush_req;
+ ib_uint64_t lru_flush_avg;
+ lsn_t lsn = log_get_lsn();
+ lsn_t log_capacity = log_get_capacity();
/* log_capacity should never be zero after the initialization
of log subsystem. */
@@ -2198,9 +2197,8 @@ buf_flush_get_desired_flush_rate(void)
/* redo_avg below is average at which redo is generated in
past BUF_FLUSH_STAT_N_INTERVAL + redo generated in the current
interval. */
- redo_avg = (ulint) (buf_flush_stat_sum.redo
- / BUF_FLUSH_STAT_N_INTERVAL
- + (lsn - buf_flush_stat_cur.redo));
+ redo_avg = buf_flush_stat_sum.redo / BUF_FLUSH_STAT_N_INTERVAL
+ + (lsn - buf_flush_stat_cur.redo);
/* An overflow can happen possibly if we flush more than 2^32
pages in BUF_FLUSH_STAT_N_INTERVAL. This is a very very
@@ -2221,11 +2219,14 @@ buf_flush_get_desired_flush_rate(void)
list is the difference between the required rate and the
number of pages that we are historically flushing from the
LRU list */
- rate = n_flush_req - lru_flush_avg;
- if (rate <= 0) {
+ if (n_flush_req <= lru_flush_avg) {
return(0);
} else {
- return(ut_min(rate, PCT_IO(100)));
+ ib_uint64_t rate;
+
+ rate = n_flush_req - lru_flush_avg;
+
+ return((ulint) (rate < PCT_IO(100) ? rate : PCT_IO(100)));
}
}
@@ -2241,12 +2242,12 @@ page_cleaner_do_flush_batch(
we should attempt to flush. If
an lsn_limit is provided then
this value will have no affect */
- ib_uint64_t lsn_limit) /*!< in: LSN up to which flushing
+ lsn_t lsn_limit) /*!< in: LSN up to which flushing
must happen */
{
ulint n_flushed;
- ut_ad(n_to_flush == ULINT_MAX || lsn_limit == IB_ULONGLONG_MAX);
+ ut_ad(n_to_flush == ULINT_MAX || lsn_limit == LSN_MAX);
n_flushed = buf_flush_list(n_to_flush, lsn_limit);
if (n_flushed == ULINT_UNDEFINED) {
@@ -2273,8 +2274,8 @@ ulint
page_cleaner_flush_pages_if_needed(void)
/*====================================*/
{
- ulint n_pages_flushed = 0;
- ib_uint64_t lsn_limit = log_async_flush_lsn();
+ ulint n_pages_flushed = 0;
+ lsn_t lsn_limit = log_async_flush_lsn();
/* Currently we decide whether or not to flush and how much to
flush based on three factors.
@@ -2294,7 +2295,7 @@ page_cleaner_flush_pages_if_needed(void)
or 2 has occurred above then we flush a batch based on our
heuristics. */
- if (lsn_limit != IB_ULONGLONG_MAX) {
+ if (lsn_limit != LSN_MAX) {
/* async flushing is requested */
n_pages_flushed = page_cleaner_do_flush_batch(ULINT_MAX,
@@ -2312,7 +2313,7 @@ page_cleaner_flush_pages_if_needed(void)
buffer pool under the limit wished by the user */
n_pages_flushed += page_cleaner_do_flush_batch(PCT_IO(100),
- IB_ULONGLONG_MAX);
+ LSN_MAX);
MONITOR_INC(MONITOR_NUM_MAX_DIRTY_FLUSHES);
MONITOR_SET(MONITOR_FLUSH_MAX_DIRTY_PAGES, n_pages_flushed);
}
@@ -2328,7 +2329,7 @@ page_cleaner_flush_pages_if_needed(void)
if (n_flush) {
n_pages_flushed = page_cleaner_do_flush_batch(
n_flush,
- IB_ULONGLONG_MAX);
+ LSN_MAX);
MONITOR_INC(MONITOR_NUM_ADAPTIVE_FLUSHES);
MONITOR_SET(MONITOR_FLUSH_ADAPTIVE_PAGES,
@@ -2406,7 +2407,7 @@ buf_flush_page_cleaner_thread(
} else {
n_flushed = page_cleaner_do_flush_batch(
PCT_IO(100),
- IB_ULONGLONG_MAX);
+ LSN_MAX);
}
}
@@ -2430,8 +2431,7 @@ buf_flush_page_cleaner_thread(
dirtied until we enter SRV_SHUTDOWN_FLUSH_PHASE phase. */
do {
- n_flushed = page_cleaner_do_flush_batch(PCT_IO(100),
- IB_ULONGLONG_MAX);
+ n_flushed = page_cleaner_do_flush_batch(PCT_IO(100), LSN_MAX);
/* We sleep only if there are no pages to flush */
if (n_flushed == 0) {
@@ -2454,8 +2454,7 @@ buf_flush_page_cleaner_thread(
buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST);
do {
- n_flushed = buf_flush_list(PCT_IO(100),
- IB_ULONGLONG_MAX);
+ n_flushed = buf_flush_list(PCT_IO(100), LSN_MAX);
buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST);
} while (n_flushed > 0);
@@ -2508,7 +2507,7 @@ buf_flush_validate_low(
}
while (bpage != NULL) {
- const ib_uint64_t om = bpage->oldest_modification;
+ const lsn_t om = bpage->oldest_modification;
ut_ad(buf_pool_from_bpage(bpage) == buf_pool);
=== modified file 'storage/innobase/buf/buf0lru.c'
--- a/storage/innobase/buf/buf0lru.c revid:serge.kozlov@stripped
+++ b/storage/innobase/buf/buf0lru.c revid:vasil.dimov@stripped
@@ -251,74 +251,78 @@ buf_LRU_drop_page_hash_for_tablespace(
sizeof(ulint) * BUF_LRU_DROP_SEARCH_HASH_SIZE);
buf_pool_mutex_enter(buf_pool);
+ num_entries = 0;
scan_again:
- num_entries = 0;
bpage = UT_LIST_GET_LAST(buf_pool->LRU);
while (bpage != NULL) {
- mutex_t* block_mutex = buf_page_get_mutex(bpage);
buf_page_t* prev_bpage;
+ ibool is_fixed;
- mutex_enter(block_mutex);
prev_bpage = UT_LIST_GET_PREV(LRU, bpage);
ut_a(buf_page_in_file(bpage));
if (buf_page_get_state(bpage) != BUF_BLOCK_FILE_PAGE
|| bpage->space != id
- || bpage->buf_fix_count > 0
|| bpage->io_fix != BUF_IO_NONE) {
- /* We leave the fixed pages as is in this scan.
- To be dealt with later in the final scan. */
- mutex_exit(block_mutex);
- goto next_page;
+ /* Compressed pages are never hashed.
+ Skip blocks of other tablespaces.
+ Skip I/O-fixed blocks (to be dealt with later). */
+next_page:
+ bpage = prev_bpage;
+ continue;
}
- if (((buf_block_t*) bpage)->is_hashed) {
+ mutex_enter(&((buf_block_t*) bpage)->mutex);
+ is_fixed = bpage->buf_fix_count > 0
+ || !((buf_block_t*) bpage)->is_hashed;
+ mutex_exit(&((buf_block_t*) bpage)->mutex);
- /* Store the offset(i.e.: page_no) in the array
- so that we can drop hash index in a batch
- later. */
- page_arr[num_entries] = bpage->offset;
- mutex_exit(block_mutex);
- ut_a(num_entries < BUF_LRU_DROP_SEARCH_HASH_SIZE);
- ++num_entries;
+ if (is_fixed) {
+ goto next_page;
+ }
- if (num_entries < BUF_LRU_DROP_SEARCH_HASH_SIZE) {
- goto next_page;
- }
+ /* Store the page number so that we can drop the hash
+ index in a batch later. */
+ page_arr[num_entries] = bpage->offset;
+ ut_a(num_entries < BUF_LRU_DROP_SEARCH_HASH_SIZE);
+ ++num_entries;
- /* Array full. We release the buf_pool->mutex to
- obey the latching order. */
- buf_pool_mutex_exit(buf_pool);
+ if (num_entries < BUF_LRU_DROP_SEARCH_HASH_SIZE) {
+ goto next_page;
+ }
- buf_LRU_drop_page_hash_batch(
- id, zip_size, page_arr, num_entries);
+ /* Array full. We release the buf_pool->mutex to obey
+ the latching order. */
+ buf_pool_mutex_exit(buf_pool);
- num_entries = 0;
+ buf_LRU_drop_page_hash_batch(
+ id, zip_size, page_arr, num_entries);
- buf_pool_mutex_enter(buf_pool);
- } else {
- mutex_exit(block_mutex);
- }
+ num_entries = 0;
-next_page:
- /* Note that we may have released the buf_pool mutex
- above after reading the prev_bpage during processing
- of a page_hash_batch (i.e.: when the array was full).
- This means that prev_bpage can change in LRU list.
- This is OK because this function is a 'best effort'
- to drop as many search hash entries as possible and
- it does not guarantee that ALL such entries will be
- dropped. */
- bpage = prev_bpage;
+ buf_pool_mutex_enter(buf_pool);
+
+ /* Note that we released the buf_pool mutex above
+ after reading the prev_bpage during processing of a
+ page_hash_batch (i.e.: when the array was full).
+ Because prev_bpage could belong to a compressed-only
+ block, it may have been relocated, and thus the
+ pointer cannot be trusted. Because bpage is of type
+ buf_block_t, it is safe to dereference.
+
+ bpage can change in the LRU list. This is OK because
+ this function is a 'best effort' to drop as many
+ search hash entries as possible and it does not
+ guarantee that ALL such entries will be dropped. */
/* If, however, bpage has been removed from LRU list
to the free list then we should restart the scan.
bpage->state is protected by buf_pool mutex. */
- if (bpage && !buf_page_in_file(bpage)) {
- ut_a(num_entries == 0);
+ if (bpage
+ && buf_page_get_state(bpage) != BUF_BLOCK_FILE_PAGE) {
goto scan_again;
}
}
@@ -1957,6 +1961,7 @@ buf_LRU_block_remove_hashed_page(
buf_pool, bpage->zip.data,
page_zip_get_size(&bpage->zip));
+ bpage->state = BUF_BLOCK_ZIP_FREE;
buf_buddy_free(buf_pool, bpage, sizeof(*bpage));
buf_pool_mutex_exit_allow(buf_pool);
=== modified file 'storage/innobase/dict/dict0load.c'
--- a/storage/innobase/dict/dict0load.c revid:serge.kozlov@stripped
+++ b/storage/innobase/dict/dict0load.c revid:vasil.dimov@stripped
@@ -2262,10 +2262,12 @@ loop:
/* Since table names in SYS_FOREIGN are stored in a case-insensitive
order, we have to check that the table name matches also in a binary
string comparison. On Unix, MySQL allows table names that only differ
- in character case. */
-
- if (0 != ut_memcmp(field, table_name, len)) {
+ in character case. If lower_case_table_names=2 then what is stored
+ may not be the same case, but the previous comparison showed that they
+ match with no-case. */
+ if ((srv_lower_case_table_names != 2)
+ && (0 != ut_memcmp(field, table_name, len))) {
goto next_rec;
}
=== modified file 'storage/innobase/dict/dict0stats.c'
--- a/storage/innobase/dict/dict0stats.c revid:serge.kozlov@stripped
+++ b/storage/innobase/dict/dict0stats.c revid:vasil.dimov@stripped
@@ -238,11 +238,11 @@ dict_stats_persistent_storage_check(
{
/* definition for the table TABLE_STATS_NAME */
dict_col_meta_t table_stats_columns[] = {
- {"database_name", DATA_VARCHAR,
- DATA_NOT_NULL, 512},
+ {"database_name", DATA_VARMYSQL,
+ DATA_NOT_NULL, 192 /* NAME_LEN from mysql_com.h */},
- {"table_name", DATA_VARCHAR,
- DATA_NOT_NULL, 512},
+ {"table_name", DATA_VARMYSQL,
+ DATA_NOT_NULL, 192 /* NAME_LEN from mysql_com.h */},
{"stats_timestamp", DATA_INT,
DATA_NOT_NULL | DATA_UNSIGNED, 4},
@@ -264,20 +264,20 @@ dict_stats_persistent_storage_check(
/* definition for the table INDEX_STATS_NAME */
dict_col_meta_t index_stats_columns[] = {
- {"database_name", DATA_VARCHAR,
- DATA_NOT_NULL, 512},
+ {"database_name", DATA_VARMYSQL,
+ DATA_NOT_NULL, 192 /* NAME_LEN from mysql_com.h */},
- {"table_name", DATA_VARCHAR,
- DATA_NOT_NULL, 512},
+ {"table_name", DATA_VARMYSQL,
+ DATA_NOT_NULL, 192 /* NAME_LEN from mysql_com.h */},
- {"index_name", DATA_VARCHAR,
- DATA_NOT_NULL, 512},
+ {"index_name", DATA_VARMYSQL,
+ DATA_NOT_NULL, 192 /* NAME_LEN from mysql_com.h */},
{"stat_timestamp", DATA_INT,
DATA_NOT_NULL | DATA_UNSIGNED, 4},
- {"stat_name", DATA_VARCHAR,
- DATA_NOT_NULL, 64},
+ {"stat_name", DATA_VARMYSQL,
+ DATA_NOT_NULL, 64*3},
{"stat_value", DATA_INT,
DATA_NOT_NULL | DATA_UNSIGNED, 8},
@@ -285,8 +285,8 @@ dict_stats_persistent_storage_check(
{"sample_size", DATA_INT,
DATA_UNSIGNED, 8},
- {"stat_description", DATA_VARCHAR,
- DATA_NOT_NULL, 1024}
+ {"stat_description", DATA_VARMYSQL,
+ DATA_NOT_NULL, 1024*3}
};
dict_table_schema_t index_stats_schema = {
INDEX_STATS_NAME,
=== modified file 'storage/innobase/fil/fil0fil.c'
--- a/storage/innobase/fil/fil0fil.c revid:serge.kozlov@stripped
+++ b/storage/innobase/fil/fil0fil.c revid:vasil.dimov@stripped
@@ -1726,11 +1726,11 @@ static
ulint
fil_write_lsn_and_arch_no_to_file(
/*==============================*/
- ulint sum_of_sizes, /*!< in: combined size of previous files
- in space, in database pages */
- ib_uint64_t lsn, /*!< in: lsn to write */
- ulint arch_log_no __attribute__((unused)))
- /*!< in: archived log number to write */
+ ulint sum_of_sizes, /*!< in: combined size of previous files
+ in space, in database pages */
+ lsn_t lsn, /*!< in: lsn to write */
+ ulint arch_log_no __attribute__((unused)))
+ /*!< in: archived log number to write */
{
byte* buf1;
byte* buf;
@@ -1757,9 +1757,8 @@ UNIV_INTERN
ulint
fil_write_flushed_lsn_to_data_files(
/*================================*/
- ib_uint64_t lsn, /*!< in: lsn to write */
- ulint arch_log_no) /*!< in: latest archived log
- file number */
+ lsn_t lsn, /*!< in: lsn to write */
+ ulint arch_log_no) /*!< in: latest archived log file number */
{
fil_space_t* space;
fil_node_t* node;
@@ -1821,12 +1820,12 @@ fil_read_flushed_lsn_and_arch_log_no(
ulint* min_arch_log_no, /*!< in/out: */
ulint* max_arch_log_no, /*!< in/out: */
#endif /* UNIV_LOG_ARCHIVE */
- ib_uint64_t* min_flushed_lsn, /*!< in/out: */
- ib_uint64_t* max_flushed_lsn) /*!< in/out: */
+ lsn_t* min_flushed_lsn, /*!< in/out: */
+ lsn_t* max_flushed_lsn) /*!< in/out: */
{
- byte* buf;
- byte* buf2;
- ib_uint64_t flushed_lsn;
+ byte* buf;
+ byte* buf2;
+ lsn_t flushed_lsn;
buf2 = ut_malloc(2 * UNIV_PAGE_SIZE);
/* Align the memory for a possible read from a raw device */
@@ -2878,7 +2877,7 @@ fil_reset_too_high_lsns(
/*====================*/
const char* name, /*!< in: table name in the
databasename/tablename format */
- ib_uint64_t current_lsn) /*!< in: reset lsn's if the lsn stamped
+ lsn_t current_lsn) /*!< in: reset lsn's if the lsn stamped
to FIL_PAGE_FILE_FLUSH_LSN in the
first page is too high */
{
@@ -2886,7 +2885,7 @@ fil_reset_too_high_lsns(
char* filepath;
byte* page;
byte* buf2;
- ib_uint64_t flush_lsn;
+ lsn_t flush_lsn;
ulint space_id;
ib_int64_t file_size;
ib_int64_t offset;
@@ -2951,8 +2950,8 @@ fil_reset_too_high_lsns(
fprintf(stderr,
" InnoDB: Flush lsn in the tablespace file %lu"
" to be imported\n"
- "InnoDB: is %llu, which exceeds current"
- " system lsn %llu.\n"
+ "InnoDB: is " LSN_PF ", which exceeds current"
+ " system lsn " LSN_PF ".\n"
"InnoDB: We reset the lsn's in the file ",
(ulong) space_id,
flush_lsn, current_lsn);
=== modified file 'storage/innobase/handler/ha_innodb.cc'
--- a/storage/innobase/handler/ha_innodb.cc revid:serge.kozlov@stripped
+++ b/storage/innobase/handler/ha_innodb.cc revid:vasil.dimov@stripped
@@ -42,6 +42,7 @@ this program; if not, write to the Free
#include <mysql/plugin.h>
#include <mysql/innodb_priv.h>
#include <mysql/psi/psi.h>
+#include <my_sys.h>
/** @file ha_innodb.cc */
@@ -453,7 +454,7 @@ static SHOW_VAR innodb_status_variables[
{"os_log_pending_writes",
(char*) &export_vars.innodb_os_log_pending_writes, SHOW_LONG},
{"os_log_written",
- (char*) &export_vars.innodb_os_log_written, SHOW_LONG},
+ (char*) &export_vars.innodb_os_log_written, SHOW_LONGLONG},
{"page_size",
(char*) &export_vars.innodb_page_size, SHOW_LONG},
{"pages_created",
@@ -1323,6 +1324,20 @@ innobase_wildcasecmp(
}
/******************************************************************//**
+Strip dir name from a full path name and return only the file name
+@return file name or "null" if no file name */
+extern "C" UNIV_INTERN
+const char*
+innobase_basename(
+/*==============*/
+ const char* path_name) /*!< in: full path name */
+{
+ const char* name = base_name(path_name);
+
+ return((name) ? name : "null");
+}
+
+/******************************************************************//**
Makes all characters in a NUL-terminated UTF-8 string lower case. */
extern "C" UNIV_INTERN
void
@@ -2421,14 +2436,6 @@ innobase_init(
goto error;
}
-
- if (innobase_log_file_size > UINT_MAX32) {
- sql_print_error(
- "innobase_log_file_size can't be over 4GB"
- " on 32-bit systems");
-
- goto error;
- }
}
os_innodb_umask = (ulint)my_umask;
@@ -2602,7 +2609,7 @@ innobase_change_buffering_inited_ok:
srv_n_log_groups = (ulint) innobase_mirrored_log_groups;
srv_n_log_files = (ulint) innobase_log_files_in_group;
- srv_log_file_size = (ulint) innobase_log_file_size;
+ srv_log_file_size = (ib_uint64_t) innobase_log_file_size;
#ifdef UNIV_LOG_ARCHIVE
srv_log_archive_on = (ulint) innobase_log_archive;
@@ -9759,7 +9766,8 @@ innodb_mutex_show_status(
if (mutex->count_using > 0) {
buf1len= my_snprintf(buf1, sizeof(buf1),
"%s:%s",
- mutex->cmutex_name, mutex->cfile_name);
+ mutex->cmutex_name,
+ innobase_basename(mutex->cfile_name));
buf2len= my_snprintf(buf2, sizeof(buf2),
"count=%lu, spin_waits=%lu,"
" spin_rounds=%lu, "
@@ -9789,7 +9797,8 @@ innodb_mutex_show_status(
}
#else /* UNIV_DEBUG */
buf1len= (uint) my_snprintf(buf1, sizeof(buf1), "%s:%lu",
- mutex->cfile_name, (ulong) mutex->cline);
+ innobase_basename(mutex->cfile_name),
+ (ulong) mutex->cline);
buf2len= (uint) my_snprintf(buf2, sizeof(buf2), "os_waits=%lu",
(ulong) mutex->count_os_wait);
@@ -9805,7 +9814,8 @@ innodb_mutex_show_status(
if (block_mutex) {
buf1len = (uint) my_snprintf(buf1, sizeof buf1,
"combined %s:%lu",
- block_mutex->cfile_name,
+ innobase_basename(
+ block_mutex->cfile_name),
(ulong) block_mutex->cline);
buf2len = (uint) my_snprintf(buf2, sizeof buf2,
"os_waits=%lu",
@@ -9836,7 +9846,8 @@ innodb_mutex_show_status(
}
buf1len = my_snprintf(buf1, sizeof buf1, "%s:%lu",
- lock->cfile_name, (ulong) lock->cline);
+ innobase_basename(lock->cfile_name),
+ (ulong) lock->cline);
buf2len = my_snprintf(buf2, sizeof buf2, "os_waits=%lu",
(ulong) lock->count_os_wait);
@@ -9851,7 +9862,8 @@ innodb_mutex_show_status(
if (block_lock) {
buf1len = (uint) my_snprintf(buf1, sizeof buf1,
"combined %s:%lu",
- block_lock->cfile_name,
+ innobase_basename(
+ block_lock->cfile_name),
(ulong) block_lock->cline);
buf2len = (uint) my_snprintf(buf2, sizeof buf2,
"os_waits=%lu",
@@ -12509,7 +12521,7 @@ mysql_declare_plugin(innobase)
MYSQL_STORAGE_ENGINE_PLUGIN,
&innobase_storage_engine,
innobase_hton_name,
- "Innobase Oy",
+ plugin_author,
"Supports transactions, row-level locking, and foreign keys",
PLUGIN_LICENSE_GPL,
innobase_init, /* Plugin Init */
=== modified file 'storage/innobase/handler/i_s.cc'
--- a/storage/innobase/handler/i_s.cc revid:serge.kozlov@stripped
+++ b/storage/innobase/handler/i_s.cc revid:vasil.dimov@stripped
@@ -52,8 +52,6 @@ extern "C" {
#include "page0zip.h"
}
-static const char plugin_author[] = "Oracle Corporation";
-
/** structure associates a name string with a file page type and/or buffer
page state. */
struct buffer_page_desc_str_struct{
@@ -123,9 +121,9 @@ struct buffer_page_info_struct{
/*!< Number of records on Page */
unsigned data_size:UNIV_PAGE_SIZE_SHIFT;
/*!< Sum of the sizes of the records */
- ib_uint64_t newest_mod; /*!< Log sequence number of
+ lsn_t newest_mod; /*!< Log sequence number of
the youngest modification */
- ib_uint64_t oldest_mod; /*!< Log sequence number of
+ lsn_t oldest_mod; /*!< Log sequence number of
the oldest modification */
index_id_t index_id; /*!< Index ID if a index page */
};
@@ -1149,7 +1147,7 @@ UNIV_INTERN struct st_mysql_plugin i_s_i
/* plugin author (for SHOW PLUGINS) */
/* const char* */
- STRUCT_FLD(author, "Innobase Oy"),
+ STRUCT_FLD(author, plugin_author),
/* general descriptive text (for SHOW PLUGINS) */
/* const char* */
@@ -2347,7 +2345,7 @@ UNIV_INTERN struct st_mysql_plugin i_s_i
/* plugin author (for SHOW PLUGINS) */
/* const char* */
- STRUCT_FLD(author, "Oracle and/or its affiliates."),
+ STRUCT_FLD(author, plugin_author),
/* general descriptive text (for SHOW PLUGINS) */
/* const char* */
=== modified file 'storage/innobase/handler/i_s.h'
--- a/storage/innobase/handler/i_s.h revid:serge.kozlov@stripped
+++ b/storage/innobase/handler/i_s.h revid:vasil.dimov@stripped
@@ -26,6 +26,8 @@ Created July 18, 2007 Vasil Dimov
#ifndef i_s_h
#define i_s_h
+const char plugin_author[] = "Oracle Corporation";
+
extern struct st_mysql_plugin i_s_innodb_trx;
extern struct st_mysql_plugin i_s_innodb_locks;
extern struct st_mysql_plugin i_s_innodb_lock_waits;
=== modified file 'storage/innobase/include/buf0buf.h'
--- a/storage/innobase/include/buf0buf.h revid:serge.kozlov@stripped
+++ b/storage/innobase/include/buf0buf.h revid:vasil.dimov@stripped
@@ -36,11 +36,14 @@ Created 11/5/1995 Heikki Tuuri
#ifndef UNIV_HOTBACKUP
#include "ut0rbt.h"
#include "os0proc.h"
+#include "log0log.h"
/** @name Modes for buf_page_get_gen */
/* @{ */
#define BUF_GET 10 /*!< get always */
#define BUF_GET_IF_IN_POOL 11 /*!< get if in pool */
+#define BUF_PEEK_IF_IN_POOL 12 /*!< get if in pool, do not make
+ the block young in the LRU list */
#define BUF_GET_NO_LATCH 14 /*!< get and bufferfix, but
set no latch; we have
separated this case, because
@@ -271,7 +274,7 @@ Gets the smallest oldest_modification ls
zero if all modified pages have been flushed to disk.
@return oldest modification in pool, zero if none */
UNIV_INTERN
-ib_uint64_t
+lsn_t
buf_pool_get_oldest_modification(void);
/*==================================*/
/********************************************************************//**
@@ -401,7 +404,7 @@ buf_page_get_gen(
ulint rw_latch,/*!< in: RW_S_LATCH, RW_X_LATCH, RW_NO_LATCH */
buf_block_t* guess, /*!< in: guessed block or NULL */
ulint mode, /*!< in: BUF_GET, BUF_GET_IF_IN_POOL,
- BUF_GET_NO_LATCH or
+ BUF_PEEK_IF_IN_POOL, BUF_GET_NO_LATCH or
BUF_GET_IF_IN_POOL_OR_WATCH */
const char* file, /*!< in: file name */
ulint line, /*!< in: line where called */
@@ -556,7 +559,7 @@ Gets the youngest modification log seque
Returns zero if not file page or no modification occurred yet.
@return newest modification to page */
UNIV_INLINE
-ib_uint64_t
+lsn_t
buf_page_get_newest_modification(
/*=============================*/
const buf_page_t* bpage); /*!< in: block containing the
@@ -1445,13 +1448,13 @@ struct buf_page_struct{
should hold: in_free_list
== (state == BUF_BLOCK_NOT_USED) */
#endif /* UNIV_DEBUG */
- ib_uint64_t newest_modification;
+ lsn_t newest_modification;
/*!< log sequence number of
the youngest modification to
this block, zero if not
modified. Protected by block
mutex */
- ib_uint64_t oldest_modification;
+ lsn_t oldest_modification;
/*!< log sequence number of
the START of the log entry
written of the oldest
=== modified file 'storage/innobase/include/buf0buf.ic'
--- a/storage/innobase/include/buf0buf.ic revid:serge.kozlov@stripped
+++ b/storage/innobase/include/buf0buf.ic revid:vasil.dimov@stripped
@@ -822,13 +822,13 @@ Gets the youngest modification log seque
Returns zero if not file page or no modification occurred yet.
@return newest modification to page */
UNIV_INLINE
-ib_uint64_t
+lsn_t
buf_page_get_newest_modification(
/*=============================*/
const buf_page_t* bpage) /*!< in: block containing the
page frame */
{
- ib_uint64_t lsn;
+ lsn_t lsn;
mutex_t* block_mutex = buf_page_get_mutex(bpage);
mutex_enter(block_mutex);
=== modified file 'storage/innobase/include/buf0flu.h'
--- a/storage/innobase/include/buf0flu.h revid:serge.kozlov@stripped
+++ b/storage/innobase/include/buf0flu.h revid:vasil.dimov@stripped
@@ -82,10 +82,10 @@ UNIV_INTERN
void
buf_flush_init_for_writing(
/*=======================*/
- byte* page, /*!< in/out: page */
- void* page_zip_, /*!< in/out: compressed page, or NULL */
- ib_uint64_t newest_lsn); /*!< in: newest modification lsn
- to the page */
+ byte* page, /*!< in/out: page */
+ void* page_zip_, /*!< in/out: compressed page, or NULL */
+ lsn_t newest_lsn); /*!< in: newest modification lsn
+ to the page */
#ifndef UNIV_HOTBACKUP
# if defined UNIV_DEBUG || defined UNIV_IBUF_DEBUG
/********************************************************************//**
@@ -130,7 +130,7 @@ buf_flush_list(
ulint min_n, /*!< in: wished minimum mumber of blocks
flushed (it is not guaranteed that the
actual number is that big, though) */
- ib_uint64_t lsn_limit); /*!< in the case BUF_FLUSH_LIST all
+ lsn_t lsn_limit); /*!< in the case BUF_FLUSH_LIST all
blocks whose oldest_modification is
smaller than this should be flushed
(if their number does not exceed
@@ -172,9 +172,9 @@ void
buf_flush_recv_note_modification(
/*=============================*/
buf_block_t* block, /*!< in: block which is modified */
- ib_uint64_t start_lsn, /*!< in: start lsn of the first mtr in a
+ lsn_t start_lsn, /*!< in: start lsn of the first mtr in a
set of mtr's */
- ib_uint64_t end_lsn); /*!< in: end lsn of the last mtr in the
+ lsn_t end_lsn); /*!< in: end lsn of the last mtr in the
set of mtr's */
/********************************************************************//**
Returns TRUE if the file page block is immediately suitable for replacement,
@@ -198,8 +198,8 @@ how much redo the workload is generating
struct buf_flush_stat_struct
{
- ib_uint64_t redo; /**< amount of redo generated. */
- ulint n_flushed; /**< number of pages flushed. */
+ lsn_t redo; /**< amount of redo generated. */
+ ulint n_flushed; /**< number of pages flushed. */
};
/** Statistics for selecting flush rate of dirty pages. */
=== modified file 'storage/innobase/include/buf0flu.ic'
--- a/storage/innobase/include/buf0flu.ic revid:serge.kozlov@stripped
+++ b/storage/innobase/include/buf0flu.ic revid:vasil.dimov@stripped
@@ -35,7 +35,7 @@ buf_flush_insert_into_flush_list(
/*=============================*/
buf_pool_t* buf_pool, /*!< buffer pool instance */
buf_block_t* block, /*!< in/out: block which is modified */
- ib_uint64_t lsn); /*!< in: oldest modification */
+ lsn_t lsn); /*!< in: oldest modification */
/********************************************************************//**
Inserts a modified block into the flush list in the right sorted position.
This function is used by recovery, because there the modifications do not
@@ -46,7 +46,7 @@ buf_flush_insert_sorted_into_flush_list(
/*====================================*/
buf_pool_t* buf_pool, /*!< buffer pool instance */
buf_block_t* block, /*!< in/out: block which is modified */
- ib_uint64_t lsn); /*!< in: oldest modification */
+ lsn_t lsn); /*!< in: oldest modification */
/********************************************************************//**
This function should be called at a mini-transaction commit, if a page was
@@ -99,9 +99,9 @@ void
buf_flush_recv_note_modification(
/*=============================*/
buf_block_t* block, /*!< in: block which is modified */
- ib_uint64_t start_lsn, /*!< in: start lsn of the first mtr in a
+ lsn_t start_lsn, /*!< in: start lsn of the first mtr in a
set of mtr's */
- ib_uint64_t end_lsn) /*!< in: end lsn of the last mtr in the
+ lsn_t end_lsn) /*!< in: end lsn of the last mtr in the
set of mtr's */
{
buf_pool_t* buf_pool = buf_pool_from_block(block);
=== modified file 'storage/innobase/include/data0type.ic'
--- a/storage/innobase/include/data0type.ic revid:serge.kozlov@stripped
+++ b/storage/innobase/include/data0type.ic revid:vasil.dimov@stripped
@@ -473,9 +473,11 @@ dtype_sql_name(
ut_snprintf(name, name_sz, "BINARY(%u)", len);
break;
case DATA_CHAR:
+ case DATA_MYSQL:
ut_snprintf(name, name_sz, "CHAR(%u)", len);
break;
case DATA_VARCHAR:
+ case DATA_VARMYSQL:
ut_snprintf(name, name_sz, "VARCHAR(%u)", len);
break;
case DATA_BINARY:
=== modified file 'storage/innobase/include/fil0fil.h'
--- a/storage/innobase/include/fil0fil.h revid:serge.kozlov@stripped
+++ b/storage/innobase/include/fil0fil.h revid:vasil.dimov@stripped
@@ -33,6 +33,7 @@ Created 10/25/1995 Heikki Tuuri
#ifndef UNIV_HOTBACKUP
#include "sync0rw.h"
#include "ibuf0types.h"
+#include "log0log.h"
#endif /* !UNIV_HOTBACKUP */
/** When mysqld is run, the default directory "." is the mysqld datadir,
@@ -324,9 +325,8 @@ UNIV_INTERN
ulint
fil_write_flushed_lsn_to_data_files(
/*================================*/
- ib_uint64_t lsn, /*!< in: lsn to write */
- ulint arch_log_no); /*!< in: latest archived log
- file number */
+ lsn_t lsn, /*!< in: lsn to write */
+ ulint arch_log_no); /*!< in: latest archived log file number */
/*******************************************************************//**
Reads the flushed lsn and arch no fields from a data file at database
startup. */
@@ -342,8 +342,8 @@ fil_read_flushed_lsn_and_arch_log_no(
ulint* min_arch_log_no, /*!< in/out: */
ulint* max_arch_log_no, /*!< in/out: */
#endif /* UNIV_LOG_ARCHIVE */
- ib_uint64_t* min_flushed_lsn, /*!< in/out: */
- ib_uint64_t* max_flushed_lsn); /*!< in/out: */
+ lsn_t* min_flushed_lsn, /*!< in/out: */
+ lsn_t* max_flushed_lsn); /*!< in/out: */
/*******************************************************************//**
Increments the count of pending insert buffer page merges, if space is not
being deleted.
@@ -495,7 +495,7 @@ fil_reset_too_high_lsns(
/*====================*/
const char* name, /*!< in: table name in the
databasename/tablename format */
- ib_uint64_t current_lsn); /*!< in: reset lsn's if the lsn stamped
+ lsn_t current_lsn); /*!< in: reset lsn's if the lsn stamped
to FIL_PAGE_FILE_FLUSH_LSN in the
first page is too high */
#endif /* !UNIV_HOTBACKUP */
=== modified file 'storage/innobase/include/ha_prototypes.h'
--- a/storage/innobase/include/ha_prototypes.h revid:serge.kozlov@stripped
+++ b/storage/innobase/include/ha_prototypes.h revid:vasil.dimov@stripped
@@ -185,6 +185,15 @@ innobase_wildcasecmp(
const char* b); /*!< in: wildcard string to compare */
/******************************************************************//**
+Strip dir name from a full path name and return only its file name.
+@return file name or "null" if no file name */
+UNIV_INTERN
+const char*
+innobase_basename(
+/*==============*/
+ const char* path_name); /*!< in: full path name */
+
+/******************************************************************//**
Returns true if the thread is executing a SELECT statement.
@return true if thd is executing SELECT */
=== modified file 'storage/innobase/include/log0log.h'
--- a/storage/innobase/include/log0log.h revid:serge.kozlov@stripped
+++ b/storage/innobase/include/log0log.h revid:vasil.dimov@stripped
@@ -41,6 +41,11 @@ Created 12/9/1995 Heikki Tuuri
#include "sync0rw.h"
#endif /* !UNIV_HOTBACKUP */
+/* Type used for all log sequence number storage and arithmetics */
+typedef ib_uint64_t lsn_t;
+#define LSN_MAX IB_UINT64_MAX
+#define LSN_PF "%llu"
+
/** Redo log buffer */
typedef struct log_struct log_t;
/** Redo log group */
@@ -98,12 +103,12 @@ Writes to the log the string given. The
log_release.
@return end lsn of the log record, zero if did not succeed */
UNIV_INLINE
-ib_uint64_t
+lsn_t
log_reserve_and_write_fast(
/*=======================*/
const void* str, /*!< in: string */
ulint len, /*!< in: string length */
- ib_uint64_t* start_lsn);/*!< out: start lsn of the log record */
+ lsn_t* start_lsn);/*!< out: start lsn of the log record */
/***********************************************************************//**
Releases the log mutex. */
UNIV_INLINE
@@ -124,7 +129,7 @@ Opens the log for log_write_low. The log
released with log_release.
@return start lsn of the log record */
UNIV_INTERN
-ib_uint64_t
+lsn_t
log_reserve_and_open(
/*=================*/
ulint len); /*!< in: length of data to be catenated */
@@ -141,14 +146,14 @@ log_write_low(
Closes the log.
@return lsn */
UNIV_INTERN
-ib_uint64_t
+lsn_t
log_close(void);
/*===========*/
/************************************************************//**
Gets the current lsn.
@return current lsn */
UNIV_INLINE
-ib_uint64_t
+lsn_t
log_get_lsn(void);
/*=============*/
/****************************************************************
@@ -156,7 +161,7 @@ Gets the log group capacity. It is OK to
holding log_sys->mutex because it is constant.
@return log group capacity */
UNIV_INLINE
-ulint
+lsn_t
log_get_capacity(void);
/*==================*/
/******************************************************//**
@@ -173,7 +178,7 @@ log_group_init(
/*===========*/
ulint id, /*!< in: group id */
ulint n_files, /*!< in: number of log files */
- ulint file_size, /*!< in: log file size in bytes */
+ lsn_t file_size, /*!< in: log file size in bytes */
ulint space_id, /*!< in: space id of the file space
which contains the log files of this
group */
@@ -198,14 +203,13 @@ UNIV_INTERN
void
log_write_up_to(
/*============*/
- ib_uint64_t lsn, /*!< in: log sequence number up to which
- the log should be written,
- IB_ULONGLONG_MAX if not specified */
- ulint wait, /*!< in: LOG_NO_WAIT, LOG_WAIT_ONE_GROUP,
- or LOG_WAIT_ALL_GROUPS */
- ibool flush_to_disk);
- /*!< in: TRUE if we want the written log
- also to be flushed to disk */
+ lsn_t lsn, /*!< in: log sequence number up to which
+ the log should be written, LSN_MAX if not specified */
+ ulint wait, /*!< in: LOG_NO_WAIT, LOG_WAIT_ONE_GROUP,
+ or LOG_WAIT_ALL_GROUPS */
+ ibool flush_to_disk);
+ /*!< in: TRUE if we want the written log
+ also to be flushed to disk */
/****************************************************************//**
Does a syncronous flush of the log buffer to disk. */
UNIV_INTERN
@@ -225,10 +229,10 @@ log_buffer_sync_in_background(
/****************************************************************//**
Checks if an asynchronous flushing of dirty pages is required in the
background. This function is only called from the page cleaner thread.
-@return lsn to which the flushing should happen or IB_ULONGLONG_MAX
+@return lsn to which the flushing should happen or LSN_MAX
if flushing is not required */
UNIV_INTERN
-ib_uint64_t
+lsn_t
log_async_flush_lsn(void);
/*=====================*/
/******************************************************//**
@@ -255,16 +259,16 @@ UNIV_INTERN
void
log_make_checkpoint_at(
/*===================*/
- ib_uint64_t lsn, /*!< in: make a checkpoint at this or a
- later lsn, if IB_ULONGLONG_MAX, makes
- a checkpoint at the latest lsn */
- ibool write_always); /*!< in: the function normally checks if
- the new checkpoint would have a
- greater lsn than the previous one: if
- not, then no physical write is done;
- by setting this parameter TRUE, a
- physical write will always be made to
- log files */
+ lsn_t lsn, /*!< in: make a checkpoint at this or a
+ later lsn, if LSN_MAX, makes
+ a checkpoint at the latest lsn */
+ ibool write_always); /*!< in: the function normally checks if
+ the new checkpoint would have a
+ greater lsn than the previous one: if
+ not, then no physical write is done;
+ by setting this parameter TRUE, a
+ physical write will always be made to
+ log files */
/****************************************************************//**
Makes a checkpoint at the latest lsn and writes it to first page of each
data file in the database, so that we know that the file spaces contain
@@ -382,8 +386,8 @@ log_group_read_log_seg(
ulint type, /*!< in: LOG_ARCHIVE or LOG_RECOVER */
byte* buf, /*!< in: buffer where to read */
log_group_t* group, /*!< in: log group */
- ib_uint64_t start_lsn, /*!< in: read area start */
- ib_uint64_t end_lsn); /*!< in: read area end */
+ lsn_t start_lsn, /*!< in: read area start */
+ lsn_t end_lsn); /*!< in: read area end */
/******************************************************//**
Writes a buffer to a log file group. */
UNIV_INTERN
@@ -394,7 +398,7 @@ log_group_write_buf(
byte* buf, /*!< in: buffer */
ulint len, /*!< in: buffer len; must be divisible
by OS_FILE_LOG_BLOCK_SIZE */
- ib_uint64_t start_lsn, /*!< in: start lsn of the buffer; must
+ lsn_t start_lsn, /*!< in: start lsn of the buffer; must
be divisible by
OS_FILE_LOG_BLOCK_SIZE */
ulint new_data_offset);/*!< in: start offset of new data in
@@ -410,14 +414,14 @@ void
log_group_set_fields(
/*=================*/
log_group_t* group, /*!< in/out: group */
- ib_uint64_t lsn); /*!< in: lsn for which the values should be
+ lsn_t lsn); /*!< in: lsn for which the values should be
set */
/******************************************************//**
Calculates the data capacity of a log group, when the log file headers are not
included.
@return capacity in bytes */
UNIV_INTERN
-ulint
+lsn_t
log_group_get_capacity(
/*===================*/
const log_group_t* group); /*!< in: log group */
@@ -509,8 +513,8 @@ UNIV_INLINE
void
log_block_init(
/*===========*/
- byte* log_block, /*!< in: pointer to the log buffer */
- ib_uint64_t lsn); /*!< in: lsn within the log block */
+ byte* log_block, /*!< in: pointer to the log buffer */
+ lsn_t lsn); /*!< in: lsn within the log block */
/************************************************************//**
Initializes a log block in the log buffer in the old, < 3.23.52 format, where
there was no checksum yet. */
@@ -518,8 +522,8 @@ UNIV_INLINE
void
log_block_init_in_old_format(
/*=========================*/
- byte* log_block, /*!< in: pointer to the log buffer */
- ib_uint64_t lsn); /*!< in: lsn within the log block */
+ byte* log_block, /*!< in: pointer to the log buffer */
+ lsn_t lsn); /*!< in: lsn within the log block */
/************************************************************//**
Converts a lsn to a log block number.
@return log block number, it is > 0 and <= 1G */
@@ -527,7 +531,7 @@ UNIV_INLINE
ulint
log_block_convert_lsn_to_no(
/*========================*/
- ib_uint64_t lsn); /*!< in: lsn of a byte within the block */
+ lsn_t lsn); /*!< in: lsn of a byte within the block */
/******************************************************//**
Prints info of the log. */
UNIV_INTERN
@@ -542,7 +546,7 @@ UNIV_INTERN
ibool
log_peek_lsn(
/*=========*/
- ib_uint64_t* lsn); /*!< out: if returns TRUE, current lsn is here */
+ lsn_t* lsn); /*!< out: if returns TRUE, current lsn is here */
/**********************************************************************//**
Refreshes the statistics used to print per-second averages. */
UNIV_INTERN
@@ -573,7 +577,7 @@ extern log_t* log_sys;
#define LOG_RECOVER 98887331
/* The counting of lsn's starts from this value: this must be non-zero */
-#define LOG_START_LSN ((ib_uint64_t) (16 * OS_FILE_LOG_BLOCK_SIZE))
+#define LOG_START_LSN ((lsn_t) (16 * OS_FILE_LOG_BLOCK_SIZE))
#define LOG_BUFFER_SIZE (srv_log_buffer_size * UNIV_PAGE_SIZE)
#define LOG_ARCHIVE_BUF_SIZE (srv_log_buffer_size * UNIV_PAGE_SIZE / 4)
@@ -620,7 +624,7 @@ extern log_t* log_sys;
/* Offsets for a checkpoint field */
#define LOG_CHECKPOINT_NO 0
#define LOG_CHECKPOINT_LSN 8
-#define LOG_CHECKPOINT_OFFSET 16
+#define LOG_CHECKPOINT_OFFSET_LOW32 16
#define LOG_CHECKPOINT_LOG_BUF_SIZE 20
#define LOG_CHECKPOINT_ARCHIVED_LSN 24
#define LOG_CHECKPOINT_GROUP_ARRAY 32
@@ -647,7 +651,8 @@ extern log_t* log_sys;
checkpoint contains the above field:
the field was added to
InnoDB-3.23.50 */
-#define LOG_CHECKPOINT_SIZE (16 + LOG_CHECKPOINT_ARRAY_END)
+#define LOG_CHECKPOINT_OFFSET_HIGH32 (16 + LOG_CHECKPOINT_ARRAY_END)
+#define LOG_CHECKPOINT_SIZE (20 + LOG_CHECKPOINT_ARRAY_END)
#define LOG_CHECKPOINT_FSP_MAGIC_N_VAL 1441231243
@@ -699,15 +704,15 @@ struct log_group_struct{
/* The following fields are protected by log_sys->mutex */
ulint id; /*!< log group id */
ulint n_files; /*!< number of files in the group */
- ulint file_size; /*!< individual log file size in bytes,
+ lsn_t file_size; /*!< individual log file size in bytes,
including the log file header */
ulint space_id; /*!< file space which implements the log
group */
ulint state; /*!< LOG_GROUP_OK or
LOG_GROUP_CORRUPTED */
- ib_uint64_t lsn; /*!< lsn used to fix coordinates within
+ lsn_t lsn; /*!< lsn used to fix coordinates within
the log group */
- ulint lsn_offset; /*!< the offset of the above lsn */
+ lsn_t lsn_offset; /*!< the offset of the above lsn */
ulint n_pending_writes;/*!< number of currently pending flush
writes for this log group */
byte** file_header_bufs_ptr;/*!< unaligned buffers */
@@ -736,7 +741,7 @@ struct log_group_struct{
ulint next_archived_offset; /*!< like the preceding field */
#endif /* UNIV_LOG_ARCHIVE */
/*-----------------------------*/
- ib_uint64_t scanned_lsn; /*!< used only in recovery: recovery scan
+ lsn_t scanned_lsn; /*!< used only in recovery: recovery scan
succeeded up to this lsn in this log
group */
byte* checkpoint_buf_ptr;/*!< unaligned checkpoint header */
@@ -751,7 +756,7 @@ struct log_struct{
byte pad[64]; /*!< padding to prevent other memory
update hotspots from residing on the
same memory cache line */
- ib_uint64_t lsn; /*!< log sequence number */
+ lsn_t lsn; /*!< log sequence number */
ulint buf_free; /*!< first free offset within the log
buffer */
#ifndef UNIV_HOTBACKUP
@@ -800,13 +805,13 @@ struct log_struct{
later; this is advanced when a flush
operation is completed to all the log
groups */
- ib_uint64_t written_to_some_lsn;
+ lsn_t written_to_some_lsn;
/*!< first log sequence number not yet
written to any log group; for this to
be advanced, it is enough that the
write i/o has been completed for any
one log group */
- ib_uint64_t written_to_all_lsn;
+ lsn_t written_to_all_lsn;
/*!< first log sequence number not yet
written to some log group; for this to
be advanced, it is enough that the
@@ -822,16 +827,16 @@ struct log_struct{
flushed_to_disk_lsn or
write_lsn which are always
up-to-date and accurate. */
- ib_uint64_t write_lsn; /*!< end lsn for the current running
+ lsn_t write_lsn; /*!< end lsn for the current running
write */
ulint write_end_offset;/*!< the data in buffer has
been written up to this offset
when the current write ends:
this field will then be copied
to buf_next_to_write */
- ib_uint64_t current_flush_lsn;/*!< end lsn for the current running
+ lsn_t current_flush_lsn;/*!< end lsn for the current running
write + flush operation */
- ib_uint64_t flushed_to_disk_lsn;
+ lsn_t flushed_to_disk_lsn;
/*!< how far we have written the log
AND flushed to disk */
ulint n_pending_writes;/*!< number of currently
@@ -868,42 +873,37 @@ struct log_struct{
/* @} */
/** Fields involved in checkpoints @{ */
- ulint log_group_capacity; /*!< capacity of the log group; if
+ lsn_t log_group_capacity; /*!< capacity of the log group; if
the checkpoint age exceeds this, it is
a serious error because it is possible
we will then overwrite log and spoil
crash recovery */
- ulint max_modified_age_async;
+ lsn_t max_modified_age_async;
/*!< when this recommended
value for lsn -
buf_pool_get_oldest_modification()
is exceeded, we start an
asynchronous preflush of pool pages */
- ulint max_modified_age_sync;
+ lsn_t max_modified_age_sync;
/*!< when this recommended
value for lsn -
buf_pool_get_oldest_modification()
is exceeded, we start a
synchronous preflush of pool pages */
- ulint adm_checkpoint_interval;
- /*!< administrator-specified checkpoint
- interval in terms of log growth in
- bytes; the interval actually used by
- the database can be smaller */
- ulint max_checkpoint_age_async;
+ lsn_t max_checkpoint_age_async;
/*!< when this checkpoint age
is exceeded we start an
asynchronous writing of a new
checkpoint */
- ulint max_checkpoint_age;
+ lsn_t max_checkpoint_age;
/*!< this is the maximum allowed value
for lsn - last_checkpoint_lsn when a
new query step is started */
ib_uint64_t next_checkpoint_no;
/*!< next checkpoint number */
- ib_uint64_t last_checkpoint_lsn;
+ lsn_t last_checkpoint_lsn;
/*!< latest checkpoint lsn */
- ib_uint64_t next_checkpoint_lsn;
+ lsn_t next_checkpoint_lsn;
/*!< next checkpoint lsn */
ulint n_pending_checkpoint_writes;
/*!< number of currently pending
@@ -921,16 +921,16 @@ struct log_struct{
/** Fields involved in archiving @{ */
ulint archiving_state;/*!< LOG_ARCH_ON, LOG_ARCH_STOPPING
LOG_ARCH_STOPPED, LOG_ARCH_OFF */
- ib_uint64_t archived_lsn; /*!< archiving has advanced to this
+ lsn_t archived_lsn; /*!< archiving has advanced to this
lsn */
- ulint max_archived_lsn_age_async;
+ lsn_t max_archived_lsn_age_async;
/*!< recommended maximum age of
archived_lsn, before we start
asynchronous copying to the archive */
- ulint max_archived_lsn_age;
+ lsn_t max_archived_lsn_age;
/*!< maximum allowed age for
archived_lsn */
- ib_uint64_t next_archived_lsn;/*!< during an archive write,
+ lsn_t next_archived_lsn;/*!< during an archive write,
until the write is completed, we
store the next value for
archived_lsn here: the write
=== modified file 'storage/innobase/include/log0log.ic'
--- a/storage/innobase/include/log0log.ic revid:serge.kozlov@stripped
+++ b/storage/innobase/include/log0log.ic revid:vasil.dimov@stripped
@@ -193,7 +193,7 @@ UNIV_INLINE
ulint
log_block_convert_lsn_to_no(
/*========================*/
- ib_uint64_t lsn) /*!< in: lsn of a byte within the block */
+ lsn_t lsn) /*!< in: lsn of a byte within the block */
{
return(((ulint) (lsn / OS_FILE_LOG_BLOCK_SIZE) & 0x3FFFFFFFUL) + 1);
}
@@ -261,8 +261,8 @@ UNIV_INLINE
void
log_block_init(
/*===========*/
- byte* log_block, /*!< in: pointer to the log buffer */
- ib_uint64_t lsn) /*!< in: lsn within the log block */
+ byte* log_block, /*!< in: pointer to the log buffer */
+ lsn_t lsn) /*!< in: lsn within the log block */
{
ulint no;
@@ -283,8 +283,8 @@ UNIV_INLINE
void
log_block_init_in_old_format(
/*=========================*/
- byte* log_block, /*!< in: pointer to the log buffer */
- ib_uint64_t lsn) /*!< in: lsn within the log block */
+ byte* log_block, /*!< in: pointer to the log buffer */
+ lsn_t lsn) /*!< in: lsn within the log block */
{
ulint no;
@@ -305,12 +305,12 @@ Writes to the log the string given. The
log_release.
@return end lsn of the log record, zero if did not succeed */
UNIV_INLINE
-ib_uint64_t
+lsn_t
log_reserve_and_write_fast(
/*=======================*/
const void* str, /*!< in: string */
ulint len, /*!< in: string length */
- ib_uint64_t* start_lsn)/*!< out: start lsn of the log record */
+ lsn_t* start_lsn)/*!< out: start lsn of the log record */
{
ulint data_len;
#ifdef UNIV_LOG_LSN_DEBUG
@@ -400,11 +400,11 @@ log_release(void)
Gets the current lsn.
@return current lsn */
UNIV_INLINE
-ib_uint64_t
+lsn_t
log_get_lsn(void)
/*=============*/
{
- ib_uint64_t lsn;
+ lsn_t lsn;
mutex_enter(&(log_sys->mutex));
@@ -420,7 +420,7 @@ Gets the log group capacity. It is OK to
holding log_sys->mutex because it is constant.
@return log group capacity */
UNIV_INLINE
-ulint
+lsn_t
log_get_capacity(void)
/*==================*/
{
=== modified file 'storage/innobase/include/log0recv.h'
--- a/storage/innobase/include/log0recv.h revid:serge.kozlov@stripped
+++ b/storage/innobase/include/log0recv.h revid:vasil.dimov@stripped
@@ -44,13 +44,13 @@ recv_read_cp_info_for_backup(
/*=========================*/
const byte* hdr, /*!< in: buffer containing the log group
header */
- ib_uint64_t* lsn, /*!< out: checkpoint lsn */
- ulint* offset, /*!< out: checkpoint offset in the log group */
+ lsn_t* lsn, /*!< out: checkpoint lsn */
+ lsn_t* offset, /*!< out: checkpoint offset in the log group */
ulint* fsp_limit,/*!< out: fsp limit of space 0,
1000000000 if the database is running
with < version 3.23.50 of InnoDB */
ib_uint64_t* cp_no, /*!< out: checkpoint number */
- ib_uint64_t* first_header_lsn);
+ lsn_t* first_header_lsn);
/*!< out: lsn of of the start of the
first log file */
/*******************************************************************//**
@@ -62,7 +62,7 @@ recv_scan_log_seg_for_backup(
/*=========================*/
byte* buf, /*!< in: buffer containing log data */
ulint buf_len, /*!< in: data length in that buffer */
- ib_uint64_t* scanned_lsn, /*!< in/out: lsn of buffer start,
+ lsn_t* scanned_lsn, /*!< in/out: lsn of buffer start,
we return scanned lsn */
ulint* scanned_checkpoint_no,
/*!< in/out: 4 lowest bytes of the
@@ -136,12 +136,12 @@ recv_recovery_from_checkpoint_start_func
#ifdef UNIV_LOG_ARCHIVE
ulint type, /*!< in: LOG_CHECKPOINT or
LOG_ARCHIVE */
- ib_uint64_t limit_lsn, /*!< in: recover up to this lsn
+ lsn_t limit_lsn, /*!< in: recover up to this lsn
if possible */
#endif /* UNIV_LOG_ARCHIVE */
- ib_uint64_t min_flushed_lsn,/*!< in: min flushed lsn from
+ lsn_t min_flushed_lsn,/*!< in: min flushed lsn from
data files */
- ib_uint64_t max_flushed_lsn);/*!< in: max flushed lsn from
+ lsn_t max_flushed_lsn);/*!< in: max flushed lsn from
data files */
#ifdef UNIV_LOG_ARCHIVE
/** Wrapper for recv_recovery_from_checkpoint_start_func().
@@ -202,11 +202,11 @@ recv_scan_log_recs(
const byte* buf, /*!< in: buffer containing a log
segment or garbage */
ulint len, /*!< in: buffer length */
- ib_uint64_t start_lsn, /*!< in: buffer start lsn */
- ib_uint64_t* contiguous_lsn, /*!< in/out: it is known that all log
+ lsn_t start_lsn, /*!< in: buffer start lsn */
+ lsn_t* contiguous_lsn, /*!< in/out: it is known that all log
groups contain contiguous log data up
to this lsn */
- ib_uint64_t* group_scanned_lsn);/*!< out: scanning succeeded up to
+ lsn_t* group_scanned_lsn);/*!< out: scanning succeeded up to
this lsn */
/******************************************************//**
Resets the logs. The contents of log files will be lost! */
@@ -214,7 +214,7 @@ UNIV_INTERN
void
recv_reset_logs(
/*============*/
- ib_uint64_t lsn, /*!< in: reset to this lsn
+ lsn_t lsn, /*!< in: reset to this lsn
rounded up to be divisible by
OS_FILE_LOG_BLOCK_SIZE, after
which we add
@@ -235,8 +235,8 @@ recv_reset_log_files_for_backup(
/*============================*/
const char* log_dir, /*!< in: log file directory path */
ulint n_log_files, /*!< in: number of log files */
- ulint log_file_size, /*!< in: log file size */
- ib_uint64_t lsn); /*!< in: new start lsn, must be
+ lsn_t log_file_size, /*!< in: log file size */
+ lsn_t lsn); /*!< in: new start lsn, must be
divisible by OS_FILE_LOG_BLOCK_SIZE */
#endif /* UNIV_HOTBACKUP */
/********************************************************//**
@@ -302,9 +302,9 @@ UNIV_INTERN
ulint
recv_recovery_from_archive_start(
/*=============================*/
- ib_uint64_t min_flushed_lsn,/*!< in: min flushed lsn field from the
+ lsn_t min_flushed_lsn,/*!< in: min flushed lsn field from the
data files */
- ib_uint64_t limit_lsn, /*!< in: recover up to this lsn if
+ lsn_t limit_lsn, /*!< in: recover up to this lsn if
possible */
ulint first_log_no); /*!< in: number of the first archived
log file to use in the recovery; the
@@ -337,11 +337,11 @@ struct recv_struct{
ulint len; /*!< log record body length in bytes */
recv_data_t* data; /*!< chain of blocks containing the log record
body */
- ib_uint64_t start_lsn;/*!< start lsn of the log segment written by
+ lsn_t start_lsn;/*!< start lsn of the log segment written by
the mtr which generated this log record: NOTE
that this is not necessarily the start lsn of
this log record */
- ib_uint64_t end_lsn;/*!< end lsn of the log segment written by
+ lsn_t end_lsn;/*!< end lsn of the log segment written by
the mtr which generated this log record: NOTE
that this is not necessarily the end lsn of
this log record */
@@ -392,7 +392,7 @@ struct recv_sys_struct{
ibool apply_batch_on;
/*!< this is TRUE when a log rec application
batch is running */
- ib_uint64_t lsn; /*!< log sequence number */
+ lsn_t lsn; /*!< log sequence number */
ulint last_log_buf_size;
/*!< size of the log buffer when the database
last time wrote to the log */
@@ -404,12 +404,12 @@ struct recv_sys_struct{
preceding buffer */
byte* buf; /*!< buffer for parsing log records */
ulint len; /*!< amount of data in buf */
- ib_uint64_t parse_start_lsn;
+ lsn_t parse_start_lsn;
/*!< this is the lsn from which we were able to
start parsing log records and adding them to
the hash table; zero if a suitable
start point not found yet */
- ib_uint64_t scanned_lsn;
+ lsn_t scanned_lsn;
/*!< the log data has been scanned up to this
lsn */
ulint scanned_checkpoint_no;
@@ -418,10 +418,10 @@ struct recv_sys_struct{
ulint recovered_offset;
/*!< start offset of non-parsed log records in
buf */
- ib_uint64_t recovered_lsn;
+ lsn_t recovered_lsn;
/*!< the log records have been parsed up to
this lsn */
- ib_uint64_t limit_lsn;/*!< recovery should be made at most
+ lsn_t limit_lsn;/*!< recovery should be made at most
up to this lsn */
ibool found_corrupt_log;
/*!< this is set to TRUE if we during log
=== modified file 'storage/innobase/include/mtr0mtr.h'
--- a/storage/innobase/include/mtr0mtr.h revid:serge.kozlov@stripped
+++ b/storage/innobase/include/mtr0mtr.h revid:vasil.dimov@stripped
@@ -189,6 +189,9 @@ functions). The page number parameter w
MLOG_FILE_CREATE, MLOG_FILE_CREATE2 */
/* @} */
+/* included here because it needs MLOG_LSN defined */
+#include "log0log.h"
+
/***************************************************************//**
Starts a mini-transaction and creates a mini-transaction handle
and buffer in the memory buffer given by the caller.
@@ -386,9 +389,9 @@ struct mtr_struct{
have been written to the mtr log */
ulint log_mode; /* specifies which operations should be
logged; default value MTR_LOG_ALL */
- ib_uint64_t start_lsn;/* start lsn of the possible log entry for
+ lsn_t start_lsn;/* start lsn of the possible log entry for
this mtr */
- ib_uint64_t end_lsn;/* end lsn of the possible log entry for
+ lsn_t end_lsn;/* end lsn of the possible log entry for
this mtr */
#ifdef UNIV_DEBUG
ulint magic_n;
=== modified file 'storage/innobase/include/srv0mon.h'
--- a/storage/innobase/include/srv0mon.h revid:serge.kozlov@stripped
+++ b/storage/innobase/include/srv0mon.h revid:vasil.dimov@stripped
@@ -340,6 +340,12 @@ enum monitor_id_value {
MONITOR_MODULE_DDL_STATS,
MONITOR_BACKGROUND_DROP_TABLE,
+ MONITOR_MODULE_ICP,
+ MONITOR_ICP_ATTEMPTS,
+ MONITOR_ICP_NO_MATCH,
+ MONITOR_ICP_OUT_OF_RANGE,
+ MONITOR_ICP_MATCH,
+
/* This is used only for control system to turn
on/off and reset all monitor counters */
MONITOR_ALL_COUNTER,
=== modified file 'storage/innobase/include/srv0srv.h'
--- a/storage/innobase/include/srv0srv.h revid:serge.kozlov@stripped
+++ b/storage/innobase/include/srv0srv.h revid:vasil.dimov@stripped
@@ -43,6 +43,7 @@ Created 10/10/1995 Heikki Tuuri
#include "univ.i"
#ifndef UNIV_HOTBACKUP
+#include "log0log.h"
#include "sync0sync.h"
#include "os0sync.h"
#include "que0types.h"
@@ -139,7 +140,7 @@ extern ibool srv_created_new_raw;
extern ulint srv_n_log_groups;
extern ulint srv_n_log_files;
-extern ulint srv_log_file_size;
+extern ib_uint64_t srv_log_file_size;
extern ulint srv_log_buffer_size;
extern ulong srv_flush_log_at_trx_commit;
extern char srv_adaptive_flushing;
@@ -285,7 +286,7 @@ extern ulint srv_log_write_requests;
extern ulint srv_log_writes;
/* amount of data written to the log files in bytes */
-extern ulint srv_os_log_written;
+extern lsn_t srv_os_log_written;
/* amount of writes being done to the log files */
extern ulint srv_os_log_pending_writes;
@@ -777,7 +778,7 @@ struct export_var_struct{
ulint innodb_log_waits; /*!< srv_log_waits */
ulint innodb_log_write_requests; /*!< srv_log_write_requests */
ulint innodb_log_writes; /*!< srv_log_writes */
- ulint innodb_os_log_written; /*!< srv_os_log_written */
+ lsn_t innodb_os_log_written; /*!< srv_os_log_written */
ulint innodb_os_log_fsyncs; /*!< fil_n_log_flushes */
ulint innodb_os_log_pending_writes; /*!< srv_os_log_pending_writes */
ulint innodb_os_log_pending_fsyncs; /*!< fil_n_pending_log_flushes */
=== modified file 'storage/innobase/include/srv0start.h'
--- a/storage/innobase/include/srv0start.h revid:serge.kozlov@stripped
+++ b/storage/innobase/include/srv0start.h revid:vasil.dimov@stripped
@@ -27,6 +27,7 @@ Created 10/10/1995 Heikki Tuuri
#define srv0start_h
#include "univ.i"
+#include "log0log.h"
#include "ut0byte.h"
/*********************************************************************//**
@@ -87,9 +88,9 @@ int
innobase_shutdown_for_mysql(void);
/*=============================*/
/** Log sequence number at shutdown */
-extern ib_uint64_t srv_shutdown_lsn;
+extern lsn_t srv_shutdown_lsn;
/** Log sequence number immediately after startup */
-extern ib_uint64_t srv_start_lsn;
+extern lsn_t srv_start_lsn;
#ifdef HAVE_DARWIN_THREADS
/** TRUE if the F_FULLFSYNC option is available */
=== modified file 'storage/innobase/include/trx0trx.h'
--- a/storage/innobase/include/trx0trx.h revid:serge.kozlov@stripped
+++ b/storage/innobase/include/trx0trx.h revid:vasil.dimov@stripped
@@ -31,6 +31,7 @@ Created 3/26/1996 Heikki Tuuri
#include "dict0types.h"
#ifndef UNIV_HOTBACKUP
#include "lock0types.h"
+#include "log0log.h"
#include "usr0types.h"
#include "que0types.h"
#include "mem0mem.h"
@@ -448,9 +449,9 @@ struct trx_lock_struct {
hold lock_sys->mutex, except when
they are holding trx->mutex and
wait_lock==NULL */
- ulint deadlock_mark; /*!< a mark field used in deadlock
- checking algorithm. This is only
- covered by the lock_sys->mutex. */
+ ib_uint64_t deadlock_mark; /*!< A mark field that is initialized
+ to and checked against lock_mark_counter
+ by lock_deadlock_recursive(). */
ibool was_chosen_as_deadlock_victim;
/*!< when the transaction decides to
wait for a lock, it sets this to FALSE;
@@ -660,7 +661,7 @@ struct trx_struct{
XID xid; /*!< X/Open XA transaction
identification to identify a
transaction branch */
- ib_uint64_t commit_lsn; /*!< lsn at the time of the commit */
+ lsn_t commit_lsn; /*!< lsn at the time of the commit */
table_id_t table_id; /*!< Table to drop iff dict_operation
is TRUE, or 0. */
/*------------------------------*/
=== modified file 'storage/innobase/include/univ.i'
--- a/storage/innobase/include/univ.i revid:serge.kozlov@stripped
+++ b/storage/innobase/include/univ.i revid:vasil.dimov@stripped
@@ -402,6 +402,7 @@ typedef unsigned long long int ullint;
/* Maximum value for ib_uint64_t */
#define IB_ULONGLONG_MAX ((ib_uint64_t) (~0ULL))
+#define IB_UINT64_MAX IB_ULONGLONG_MAX
/** The generic InnoDB system object identifier data type */
typedef ib_uint64_t ib_id_t;
=== modified file 'storage/innobase/lock/lock0lock.c'
--- a/storage/innobase/lock/lock0lock.c revid:serge.kozlov@stripped
+++ b/storage/innobase/lock/lock0lock.c revid:vasil.dimov@stripped
@@ -424,9 +424,12 @@ lock_deadlock_recursive(
ulint* cost, /*!< in/out: number of calculation steps thus
far: if this exceeds LOCK_MAX_N_STEPS_...
we return LOCK_VICTIM_EXCEED_MAX_DEPTH */
- ulint depth); /*!< in: recursion depth: if this exceeds
+ ulint depth, /*!< in: recursion depth: if this exceeds
LOCK_MAX_DEPTH_IN_DEADLOCK_CHECK, we
return LOCK_VICTIM_EXCEED_MAX_DEPTH */
+ const ib_uint64_t
+ mark_start); /*!< in: Value of lock_mark_count at the start
+ of the deadlock check. */
/*********************************************************************//**
Gets the nth bit of a record lock.
@@ -3474,6 +3477,9 @@ lock_deadlock_lock_print(
}
}
+/** Used in deadlock tracking. Protected by lock_sys->mutex. */
+static ib_uint64_t lock_mark_counter = 0;
+
/********************************************************************//**
Checks if a lock request results in a deadlock.
@return TRUE if a deadlock was detected and we chose trx as a victim;
@@ -3486,7 +3492,6 @@ lock_deadlock_occurs(
lock_t* lock, /*!< in: lock the transaction is requesting */
trx_t* trx) /*!< in/out: transaction */
{
- trx_t* mark_trx;
ulint cost = 0;
ut_ad(trx);
@@ -3500,25 +3505,9 @@ retry:
does not produce a cycle. First mark all active transactions
with 0: */
- /* To obey the latching order. Since we have the lock mutex, this
- transaction's state can't be changed. */
- trx_mutex_exit(trx);
-
- rw_lock_s_lock(&trx_sys->lock);
-
- for (mark_trx = UT_LIST_GET_FIRST(trx_sys->trx_list);
- mark_trx != NULL;
- mark_trx = UT_LIST_GET_NEXT(trx_list, mark_trx)) {
-
- ut_ad(mark_trx->in_trx_list);
- mark_trx->lock.deadlock_mark = 0;
- }
+ switch (lock_deadlock_recursive(
+ trx, trx, lock, &cost, 0, lock_mark_counter)) {
- rw_lock_s_unlock(&trx_sys->lock);
-
- trx_mutex_enter(trx);
-
- switch (lock_deadlock_recursive(trx, trx, lock, &cost, 0)) {
case LOCK_VICTIM_IS_OTHER:
/* We chose some other trx as a victim: retry if there still
is a deadlock */
@@ -3592,9 +3581,12 @@ lock_deadlock_recursive(
ulint* cost, /*!< in/out: number of calculation steps thus
far: if this exceeds LOCK_MAX_N_STEPS_...
we return LOCK_VICTIM_EXCEED_MAX_DEPTH */
- ulint depth) /*!< in: recursion depth: if this exceeds
+ ulint depth, /*!< in: recursion depth: if this exceeds
LOCK_MAX_DEPTH_IN_DEADLOCK_CHECK, we
return LOCK_VICTIM_EXCEED_MAX_DEPTH */
+ const ib_uint64_t
+ mark_start) /*!< in: Value of lock_mark_count at the start
+ of the deadlock check. */
{
lock_victim_t ret;
lock_t* lock;
@@ -3605,8 +3597,9 @@ lock_deadlock_recursive(
ut_a(wait_lock);
ut_ad(lock_mutex_own());
ut_ad(trx->in_trx_list);
+ ut_ad(mark_start <= lock_mark_counter);
- if (trx->lock.deadlock_mark) {
+ if (trx->lock.deadlock_mark > mark_start) {
/* We have already exhaustively searched the subtree starting
from this trx */
@@ -3645,7 +3638,14 @@ lock_deadlock_recursive(
if (lock == NULL || lock == wait_lock) {
/* We can mark this subtree as searched */
- trx->lock.deadlock_mark = 1;
+ ut_a(trx->lock.deadlock_mark <= mark_start);
+ trx->lock.deadlock_mark = ++lock_mark_counter;
+
+ /* We are not prepared for an overflow. This 64-bit
+ counter should never wrap around. At 10^9 increments
+ per second, it would take 10^3 years of uptime. */
+
+ ut_a(lock_mark_counter > 0);
return(LOCK_VICTIM_NONE);
}
@@ -3765,7 +3765,7 @@ lock_deadlock_recursive(
ret = lock_deadlock_recursive(
start, lock_trx,
lock_trx->lock.wait_lock,
- cost, depth + 1);
+ cost, depth + 1, mark_start);
if (ret != LOCK_VICTIM_NONE) {
=== modified file 'storage/innobase/log/log0log.c'
--- a/storage/innobase/log/log0log.c revid:serge.kozlov@stripped
+++ b/storage/innobase/log/log0log.c revid:vasil.dimov@stripped
@@ -196,11 +196,11 @@ Returns the oldest modified block lsn in
exists.
@return LSN of oldest modification */
static
-ib_uint64_t
+lsn_t
log_buf_pool_get_oldest_modification(void)
/*======================================*/
{
- ib_uint64_t lsn;
+ lsn_t lsn;
ut_ad(mutex_own(&(log_sys->mutex)));
@@ -219,7 +219,7 @@ Opens the log for log_write_low. The log
released with log_release.
@return start lsn of the log record */
UNIV_INTERN
-ib_uint64_t
+lsn_t
log_reserve_and_open(
/*=================*/
ulint len) /*!< in: length of data to be catenated */
@@ -363,16 +363,16 @@ part_loop:
Closes the log.
@return lsn */
UNIV_INTERN
-ib_uint64_t
+lsn_t
log_close(void)
/*===========*/
{
byte* log_block;
ulint first_rec_group;
- ib_uint64_t oldest_lsn;
- ib_uint64_t lsn;
+ lsn_t oldest_lsn;
+ lsn_t lsn;
log_t* log = log_sys;
- ib_uint64_t checkpoint_age;
+ lsn_t checkpoint_age;
ut_ad(mutex_own(&(log->mutex)));
ut_ad(!recv_no_log_write);
@@ -415,16 +415,16 @@ log_close(void)
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: ERROR: the age of the last"
- " checkpoint is %lu,\n"
+ " checkpoint is " LSN_PF ",\n"
"InnoDB: which exceeds the log group"
- " capacity %lu.\n"
+ " capacity " LSN_PF ".\n"
"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",
- (ulong) checkpoint_age,
- (ulong) log->log_group_capacity);
+ checkpoint_age,
+ log->log_group_capacity);
}
}
@@ -490,7 +490,7 @@ Calculates the data capacity of a log gr
included.
@return capacity in bytes */
UNIV_INTERN
-ulint
+lsn_t
log_group_get_capacity(
/*===================*/
const log_group_t* group) /*!< in: log group */
@@ -505,10 +505,10 @@ Calculates the offset within a log group
included.
@return size offset (<= offset) */
UNIV_INLINE
-ulint
+lsn_t
log_group_calc_size_offset(
/*=======================*/
- ulint offset, /*!< in: real offset within the
+ lsn_t offset, /*!< in: real offset within the
log group */
const log_group_t* group) /*!< in: log group */
{
@@ -522,10 +522,10 @@ Calculates the offset within a log group
included.
@return real offset (>= offset) */
UNIV_INLINE
-ulint
+lsn_t
log_group_calc_real_offset(
/*=======================*/
- ulint offset, /*!< in: size offset within the
+ lsn_t offset, /*!< in: size offset within the
log group */
const log_group_t* group) /*!< in: log group */
{
@@ -539,36 +539,31 @@ log_group_calc_real_offset(
Calculates the offset of an lsn within a log group.
@return offset within the log group */
static
-ulint
+lsn_t
log_group_calc_lsn_offset(
/*======================*/
- ib_uint64_t lsn, /*!< in: lsn, must be within 4 GB of
- group->lsn */
+ lsn_t lsn, /*!< in: lsn */
const log_group_t* group) /*!< in: log group */
{
- ib_uint64_t gr_lsn;
- ib_int64_t gr_lsn_size_offset;
- ib_int64_t difference;
- ib_int64_t group_size;
- ib_int64_t offset;
+ lsn_t gr_lsn;
+ lsn_t gr_lsn_size_offset;
+ lsn_t difference;
+ lsn_t group_size;
+ lsn_t offset;
ut_ad(mutex_own(&(log_sys->mutex)));
- /* If total log file size is > 2 GB we can easily get overflows
- with 32-bit integers. Use 64-bit integers instead. */
-
gr_lsn = group->lsn;
- gr_lsn_size_offset = (ib_int64_t)
- log_group_calc_size_offset(group->lsn_offset, group);
+ gr_lsn_size_offset = log_group_calc_size_offset(group->lsn_offset, group);
- group_size = (ib_int64_t) log_group_get_capacity(group);
+ group_size = log_group_get_capacity(group);
if (lsn >= gr_lsn) {
- difference = (ib_int64_t) (lsn - gr_lsn);
+ difference = lsn - gr_lsn;
} else {
- difference = (ib_int64_t) (gr_lsn - lsn);
+ difference = gr_lsn - lsn;
difference = difference % group_size;
@@ -577,14 +572,13 @@ log_group_calc_lsn_offset(
offset = (gr_lsn_size_offset + difference) % group_size;
- ut_a(offset < (((ib_int64_t) 1) << 32)); /* offset must be < 4 GB */
-
/* fprintf(stderr,
- "Offset is %lu gr_lsn_offset is %lu difference is %lu\n",
- (ulint)offset,(ulint)gr_lsn_size_offset, (ulint)difference);
+ "Offset is " LSN_PF " gr_lsn_offset is " LSN_PF
+ " difference is " LSN_PF "\n",
+ offset, gr_lsn_size_offset, difference);
*/
- return(log_group_calc_real_offset((ulint)offset, group));
+ return(log_group_calc_real_offset(offset, group));
}
#endif /* !UNIV_HOTBACKUP */
@@ -642,7 +636,7 @@ void
log_group_set_fields(
/*=================*/
log_group_t* group, /*!< in/out: group */
- ib_uint64_t lsn) /*!< in: lsn for which the values should be
+ lsn_t lsn) /*!< in: lsn for which the values should be
set */
{
group->lsn_offset = log_group_calc_lsn_offset(lsn, group);
@@ -660,12 +654,12 @@ log_calc_max_ages(void)
/*===================*/
{
log_group_t* group;
- ulint margin;
+ lsn_t margin;
ulint free;
ibool success = TRUE;
- ulint smallest_capacity;
- ulint archive_margin;
- ulint smallest_archive_margin;
+ lsn_t smallest_capacity;
+ lsn_t archive_margin;
+ lsn_t smallest_archive_margin;
mutex_enter(&(log_sys->mutex));
@@ -673,8 +667,8 @@ log_calc_max_ages(void)
ut_ad(group);
- smallest_capacity = ULINT_MAX;
- smallest_archive_margin = ULINT_MAX;
+ smallest_capacity = LSN_MAX;
+ smallest_archive_margin = LSN_MAX;
while (group) {
if (log_group_get_capacity(group) < smallest_capacity) {
@@ -712,8 +706,6 @@ log_calc_max_ages(void)
margin = smallest_capacity - free;
}
- margin = ut_min(margin, log_sys->adm_checkpoint_interval);
-
margin = margin - margin / 10; /* Add still some extra safety */
log_sys->log_group_capacity = smallest_capacity;
@@ -826,7 +818,6 @@ log_init(void)
os_event_set(log_sys->one_flushed_event);
/*----------------------------*/
- log_sys->adm_checkpoint_interval = ULINT_MAX;
log_sys->next_checkpoint_no = 0;
log_sys->last_checkpoint_lsn = log_sys->lsn;
@@ -900,7 +891,7 @@ log_group_init(
/*===========*/
ulint id, /*!< in: group id */
ulint n_files, /*!< in: number of log files */
- ulint file_size, /*!< in: log file size in bytes */
+ lsn_t file_size, /*!< in: log file size in bytes */
ulint space_id, /*!< in: space id of the file space
which contains the log files of this
group */
@@ -1163,11 +1154,11 @@ log_group_file_header_flush(
log_group_t* group, /*!< in: log group */
ulint nth_file, /*!< in: header to the nth file in the
log file space */
- ib_uint64_t start_lsn) /*!< in: log file data starts at this
+ lsn_t start_lsn) /*!< in: log file data starts at this
lsn */
{
byte* buf;
- ulint dest_offset;
+ lsn_t dest_offset;
ut_ad(mutex_own(&(log_sys->mutex)));
ut_ad(!recv_no_log_write);
@@ -1198,8 +1189,8 @@ log_group_file_header_flush(
srv_os_log_pending_writes++;
fil_io(OS_FILE_WRITE | OS_FILE_LOG, TRUE, group->space_id, 0,
- dest_offset / UNIV_PAGE_SIZE,
- dest_offset % UNIV_PAGE_SIZE,
+ (ulint) (dest_offset / UNIV_PAGE_SIZE),
+ (ulint) (dest_offset % UNIV_PAGE_SIZE),
OS_FILE_LOG_BLOCK_SIZE,
buf, group);
@@ -1230,7 +1221,7 @@ log_group_write_buf(
byte* buf, /*!< in: buffer */
ulint len, /*!< in: buffer len; must be divisible
by OS_FILE_LOG_BLOCK_SIZE */
- ib_uint64_t start_lsn, /*!< in: start lsn of the buffer; must
+ lsn_t start_lsn, /*!< in: start lsn of the buffer; must
be divisible by
OS_FILE_LOG_BLOCK_SIZE */
ulint new_data_offset)/*!< in: start offset of new data in
@@ -1238,15 +1229,15 @@ log_group_write_buf(
if we have to write a new log file
header */
{
- ulint write_len;
- ibool write_header;
- ulint next_offset;
- ulint i;
+ ulint write_len;
+ ibool write_header;
+ lsn_t next_offset;
+ ulint i;
ut_ad(mutex_own(&(log_sys->mutex)));
ut_ad(!recv_no_log_write);
ut_a(len % OS_FILE_LOG_BLOCK_SIZE == 0);
- ut_a(((ulint) start_lsn) % OS_FILE_LOG_BLOCK_SIZE == 0);
+ ut_a(start_lsn % OS_FILE_LOG_BLOCK_SIZE == 0);
if (new_data_offset == 0) {
write_header = TRUE;
@@ -1265,17 +1256,21 @@ loop:
&& write_header) {
/* We start to write a new log file instance in the group */
- log_group_file_header_flush(group,
- next_offset / group->file_size,
+ ut_a(next_offset / group->file_size <= ULINT_MAX);
+
+ log_group_file_header_flush(group, (ulint)
+ (next_offset / group->file_size),
start_lsn);
- srv_os_log_written+= OS_FILE_LOG_BLOCK_SIZE;
+ srv_os_log_written += OS_FILE_LOG_BLOCK_SIZE;
srv_log_writes++;
}
if ((next_offset % group->file_size) + len > group->file_size) {
- write_len = group->file_size
- - (next_offset % group->file_size);
+ /* if the above condition holds, then the below expression
+ is < len which is ulint, so the typecast is ok */
+ write_len = (ulint)
+ (group->file_size - (next_offset % group->file_size));
} else {
write_len = len;
}
@@ -1285,11 +1280,11 @@ loop:
fprintf(stderr,
"Writing log file segment to group %lu"
- " offset %lu len %lu\n"
- "start lsn %llu\n"
+ " offset " LSN_PF " len %lu\n"
+ "start lsn " LSN_PF "\n"
"First block n:o %lu last block n:o %lu\n",
- (ulong) group->id, (ulong) next_offset,
- (ulong) write_len,
+ (ulong) group->id, next_offset,
+ write_len,
start_lsn,
(ulong) log_block_get_hdr_no(buf),
(ulong) log_block_get_hdr_no(
@@ -1319,13 +1314,16 @@ loop:
srv_os_log_pending_writes++;
+ ut_a(next_offset / UNIV_PAGE_SIZE <= ULINT_MAX);
+
fil_io(OS_FILE_WRITE | OS_FILE_LOG, TRUE, group->space_id, 0,
- next_offset / UNIV_PAGE_SIZE,
- next_offset % UNIV_PAGE_SIZE, write_len, buf, group);
+ (ulint) (next_offset / UNIV_PAGE_SIZE),
+ (ulint) (next_offset % UNIV_PAGE_SIZE), write_len, buf,
+ group);
srv_os_log_pending_writes--;
- srv_os_log_written+= write_len;
+ srv_os_log_written += write_len;
srv_log_writes++;
}
@@ -1349,14 +1347,14 @@ UNIV_INTERN
void
log_write_up_to(
/*============*/
- ib_uint64_t lsn, /*!< in: log sequence number up to which
- the log should be written,
- IB_ULONGLONG_MAX if not specified */
- ulint wait, /*!< in: LOG_NO_WAIT, LOG_WAIT_ONE_GROUP,
- or LOG_WAIT_ALL_GROUPS */
- ibool flush_to_disk)
- /*!< in: TRUE if we want the written log
- also to be flushed to disk */
+ lsn_t lsn, /*!< in: log sequence number up to which
+ the log should be written,
+ IB_ULONGLONG_MAX if not specified */
+ ulint wait, /*!< in: LOG_NO_WAIT, LOG_WAIT_ONE_GROUP,
+ or LOG_WAIT_ALL_GROUPS */
+ ibool flush_to_disk)
+ /*!< in: TRUE if we want the written log
+ also to be flushed to disk */
{
log_group_t* group;
ulint start_offset;
@@ -1450,7 +1448,7 @@ loop:
#ifdef UNIV_DEBUG
if (log_debug_writes) {
fprintf(stderr,
- "Writing log from %llu up to lsn %llu\n",
+ "Writing log from " LSN_PF " up to lsn " LSN_PF "\n",
log_sys->written_to_all_lsn,
log_sys->lsn);
}
@@ -1576,7 +1574,7 @@ void
log_buffer_flush_to_disk(void)
/*==========================*/
{
- ib_uint64_t lsn;
+ lsn_t lsn;
mutex_enter(&(log_sys->mutex));
@@ -1598,7 +1596,7 @@ log_buffer_sync_in_background(
/*==========================*/
ibool flush) /*!< in: flush the logs to disk */
{
- ib_uint64_t lsn;
+ lsn_t lsn;
mutex_enter(&(log_sys->mutex));
@@ -1618,8 +1616,8 @@ void
log_flush_margin(void)
/*==================*/
{
- log_t* log = log_sys;
- ib_uint64_t lsn = 0;
+ log_t* log = log_sys;
+ lsn_t lsn = 0;
mutex_enter(&(log->mutex));
@@ -1650,9 +1648,8 @@ static
ibool
log_preflush_pool_modified_pages(
/*=============================*/
- ib_uint64_t new_oldest) /*!< in: try to advance
- oldest_modified_lsn at least
- to this lsn */
+ lsn_t new_oldest) /*!< in: try to advance oldest_modified_lsn
+ at least to this lsn */
{
ulint n_pages;
@@ -1775,6 +1772,7 @@ log_group_checkpoint(
ib_uint64_t archived_lsn;
ib_uint64_t next_archived_lsn;
#endif /* UNIV_LOG_ARCHIVE */
+ lsn_t lsn_offset;
ulint write_offset;
ulint fold;
byte* buf;
@@ -1790,9 +1788,12 @@ log_group_checkpoint(
mach_write_to_8(buf + LOG_CHECKPOINT_NO, log_sys->next_checkpoint_no);
mach_write_to_8(buf + LOG_CHECKPOINT_LSN, log_sys->next_checkpoint_lsn);
- mach_write_to_4(buf + LOG_CHECKPOINT_OFFSET,
- log_group_calc_lsn_offset(
- log_sys->next_checkpoint_lsn, group));
+ lsn_offset = log_group_calc_lsn_offset(log_sys->next_checkpoint_lsn,
+ group);
+ mach_write_to_4(buf + LOG_CHECKPOINT_OFFSET_LOW32,
+ lsn_offset & 0xFFFFFFFFUL);
+ mach_write_to_4(buf + LOG_CHECKPOINT_OFFSET_HIGH32,
+ lsn_offset >> 32);
mach_write_to_4(buf + LOG_CHECKPOINT_LOG_BUF_SIZE, log_sys->buf_size);
@@ -1920,8 +1921,9 @@ log_reset_first_header_and_checkpoint(
mach_write_to_8(buf + LOG_CHECKPOINT_NO, 0);
mach_write_to_8(buf + LOG_CHECKPOINT_LSN, lsn);
- mach_write_to_4(buf + LOG_CHECKPOINT_OFFSET,
+ mach_write_to_4(buf + LOG_CHECKPOINT_OFFSET_LOW32,
LOG_FILE_HDR_SIZE + LOG_BLOCK_HDR_SIZE);
+ mach_write_to_4(buf + LOG_CHECKPOINT_OFFSET_HIGH32, 0);
mach_write_to_4(buf + LOG_CHECKPOINT_LOG_BUF_SIZE, 2 * 1024 * 1024);
@@ -2000,7 +2002,7 @@ log_checkpoint(
parameter TRUE, a physical write will always be
made to log files */
{
- ib_uint64_t oldest_lsn;
+ lsn_t oldest_lsn;
if (recv_recovery_is_on()) {
recv_apply_hashed_log_recs(TRUE);
@@ -2057,8 +2059,8 @@ log_checkpoint(
#ifdef UNIV_DEBUG
if (log_debug_writes) {
- fprintf(stderr, "Making checkpoint no %lu at lsn %llu\n",
- (ulong) log_sys->next_checkpoint_no,
+ fprintf(stderr, "Making checkpoint no %llu at lsn " LSN_PF "\n",
+ log_sys->next_checkpoint_no,
oldest_lsn);
}
#endif /* UNIV_DEBUG */
@@ -2084,16 +2086,16 @@ UNIV_INTERN
void
log_make_checkpoint_at(
/*===================*/
- ib_uint64_t lsn, /*!< in: make a checkpoint at this or a
- later lsn, if IB_ULONGLONG_MAX, makes
- a checkpoint at the latest lsn */
- ibool write_always) /*!< in: the function normally checks if
- the new checkpoint would have a
- greater lsn than the previous one: if
- not, then no physical write is done;
- by setting this parameter TRUE, a
- physical write will always be made to
- log files */
+ lsn_t lsn, /*!< in: make a checkpoint at this or a
+ later lsn, if IB_ULONGLONG_MAX, makes
+ a checkpoint at the latest lsn */
+ ibool write_always) /*!< in: the function normally checks if
+ the new checkpoint would have a
+ greater lsn than the previous one: if
+ not, then no physical write is done;
+ by setting this parameter TRUE, a
+ physical write will always be made to
+ log files */
{
/* Preflush pages synchronously */
@@ -2105,23 +2107,33 @@ log_make_checkpoint_at(
/****************************************************************//**
Checks if an asynchronous flushing of dirty pages is required in the
background. This function is only called from the page cleaner thread.
-@return lsn to which the flushing should happen or IB_ULONGLONG_MAX
+@return lsn to which the flushing should happen or LSN_MAX
if flushing is not required */
UNIV_INTERN
-ib_uint64_t
+lsn_t
log_async_flush_lsn(void)
/*=====================*/
{
- ib_int64_t age_diff;
- ib_uint64_t oldest_lsn;
+ lsn_t age;
+ lsn_t oldest_lsn;
+ lsn_t new_lsn = LSN_MAX;
mutex_enter(&log_sys->mutex);
+
oldest_lsn = log_buf_pool_get_oldest_modification();
- age_diff = log_sys->lsn - oldest_lsn
- - log_sys->max_modified_age_async;
+
+ ut_a(log_sys->lsn >= oldest_lsn);
+ age = log_sys->lsn - oldest_lsn;
+
+ if (age > log_sys->max_modified_age_async) {
+ /* An asynchronous preflush is required */
+ ut_a(log_sys->lsn >= log_sys->max_modified_age_async);
+ new_lsn = log_sys->lsn - log_sys->max_modified_age_async;
+ }
+
mutex_exit(&log_sys->mutex);
- return(age_diff > 0 ? oldest_lsn + age_diff : IB_ULONGLONG_MAX);
+ return(new_lsn);
}
/****************************************************************//**
@@ -2135,10 +2147,10 @@ log_checkpoint_margin(void)
/*=======================*/
{
log_t* log = log_sys;
- ib_uint64_t age;
- ib_uint64_t checkpoint_age;
+ lsn_t age;
+ lsn_t checkpoint_age;
ib_uint64_t advance;
- ib_uint64_t oldest_lsn;
+ lsn_t oldest_lsn;
ibool checkpoint_sync;
ibool do_checkpoint;
ibool success;
@@ -2188,7 +2200,7 @@ loop:
mutex_exit(&(log->mutex));
if (advance) {
- ib_uint64_t new_oldest = oldest_lsn + advance;
+ lsn_t new_oldest = oldest_lsn + advance;
success = log_preflush_pool_modified_pages(new_oldest);
@@ -2224,11 +2236,11 @@ log_group_read_log_seg(
ulint type, /*!< in: LOG_ARCHIVE or LOG_RECOVER */
byte* buf, /*!< in: buffer where to read */
log_group_t* group, /*!< in: log group */
- ib_uint64_t start_lsn, /*!< in: read area start */
- ib_uint64_t end_lsn) /*!< in: read area end */
+ lsn_t start_lsn, /*!< in: read area start */
+ lsn_t end_lsn) /*!< in: read area end */
{
ulint len;
- ulint source_offset;
+ lsn_t source_offset;
ibool sync;
ut_ad(mutex_own(&(log_sys->mutex)));
@@ -2237,13 +2249,17 @@ log_group_read_log_seg(
loop:
source_offset = log_group_calc_lsn_offset(start_lsn, group);
+ ut_a(end_lsn - start_lsn <= ULINT_MAX);
len = (ulint) (end_lsn - start_lsn);
ut_ad(len != 0);
if ((source_offset % group->file_size) + len > group->file_size) {
- len = group->file_size - (source_offset % group->file_size);
+ /* If the above condition is true then len (which is ulint)
+ is > the expression below, so the typecast is ok */
+ len = (ulint) (group->file_size -
+ (source_offset % group->file_size));
}
#ifdef UNIV_LOG_ARCHIVE
@@ -2257,8 +2273,11 @@ loop:
MONITOR_INC(MONITOR_LOG_IO);
+ ut_a(source_offset / UNIV_PAGE_SIZE <= ULINT_MAX);
+
fil_io(OS_FILE_READ | OS_FILE_LOG, sync, group->space_id, 0,
- source_offset / UNIV_PAGE_SIZE, source_offset % UNIV_PAGE_SIZE,
+ (ulint) (source_offset / UNIV_PAGE_SIZE),
+ (ulint) (source_offset % UNIV_PAGE_SIZE),
len, buf, NULL);
start_lsn += len;
@@ -2371,14 +2390,14 @@ log_group_archive(
/*==============*/
log_group_t* group) /*!< in: log group */
{
- os_file_t file_handle;
- ib_uint64_t start_lsn;
- ib_uint64_t end_lsn;
+ os_file_t file_handle;
+ lsn_t start_lsn;
+ lsn_t end_lsn;
char name[1024];
byte* buf;
ulint len;
ibool ret;
- ulint next_offset;
+ lsn_t next_offset;
ulint n_files;
ulint open_mode;
@@ -2485,7 +2504,8 @@ loop:
MONITOR_INC(MONITOR_LOG_IO);
fil_io(OS_FILE_WRITE | OS_FILE_LOG, FALSE, group->archive_space_id,
- next_offset / UNIV_PAGE_SIZE, next_offset % UNIV_PAGE_SIZE,
+ (ulint) (next_offset / UNIV_PAGE_SIZE),
+ (ulint) (next_offset % UNIV_PAGE_SIZE),
ut_calc_align(len, OS_FILE_LOG_BLOCK_SIZE), buf,
&log_archive_io);
@@ -3119,7 +3139,7 @@ void
logs_empty_and_mark_files_at_shutdown(void)
/*=======================================*/
{
- ib_uint64_t lsn;
+ lsn_t lsn;
ulint arch_log_no;
ulint count = 0;
ulint total_trx;
@@ -3298,7 +3318,7 @@ loop:
log_archive_all();
#endif /* UNIV_LOG_ARCHIVE */
- log_make_checkpoint_at(IB_ULONGLONG_MAX, TRUE);
+ log_make_checkpoint_at(LSN_MAX, TRUE);
mutex_enter(&(log_sys->mutex));
@@ -3371,8 +3391,8 @@ loop:
if (lsn < srv_start_lsn) {
fprintf(stderr,
"InnoDB: Error: log sequence number"
- " at shutdown %llu\n"
- "InnoDB: is lower than at startup %llu!\n",
+ " at shutdown " LSN_PF "\n"
+ "InnoDB: is lower than at startup " LSN_PF "!\n",
lsn, srv_start_lsn);
}
@@ -3450,7 +3470,7 @@ UNIV_INTERN
ibool
log_peek_lsn(
/*=========*/
- ib_uint64_t* lsn) /*!< out: if returns TRUE, current lsn is here */
+ lsn_t* lsn) /*!< out: if returns TRUE, current lsn is here */
{
if (0 == mutex_enter_nowait(&(log_sys->mutex))) {
*lsn = log_sys->lsn;
@@ -3477,10 +3497,10 @@ log_print(
mutex_enter(&(log_sys->mutex));
fprintf(file,
- "Log sequence number %llu\n"
- "Log flushed up to %llu\n"
- "Pages flushed up to %llu\n"
- "Last checkpoint at %llu\n",
+ "Log sequence number " LSN_PF "\n"
+ "Log flushed up to " LSN_PF "\n"
+ "Pages flushed up to " LSN_PF "\n"
+ "Last checkpoint at " LSN_PF "\n",
log_sys->lsn,
log_sys->flushed_to_disk_lsn,
log_buf_pool_get_oldest_modification(),
=== modified file 'storage/innobase/log/log0recv.c'
--- a/storage/innobase/log/log0recv.c revid:serge.kozlov@stripped
+++ b/storage/innobase/log/log0recv.c revid:vasil.dimov@stripped
@@ -146,7 +146,7 @@ UNIV_INTERN ulint recv_n_pool_free_frame
/** The maximum lsn we see for a page during the recovery process. If this
is bigger than the lsn we are able to scan up to, that is an indication that
the recovery failed and the database may be corrupt. */
-UNIV_INTERN ib_uint64_t recv_max_page_lsn;
+UNIV_INTERN lsn_t recv_max_page_lsn;
#ifdef UNIV_PFS_THREAD
UNIV_INTERN mysql_pfs_key_t trx_rollback_clean_thread_key;
@@ -410,24 +410,23 @@ void
recv_truncate_group(
/*================*/
log_group_t* group, /*!< in: log group */
- ib_uint64_t recovered_lsn, /*!< in: recovery succeeded up to this
+ lsn_t recovered_lsn, /*!< in: recovery succeeded up to this
lsn */
- ib_uint64_t limit_lsn, /*!< in: this was the limit for
+ lsn_t limit_lsn, /*!< in: this was the limit for
recovery */
- ib_uint64_t checkpoint_lsn, /*!< in: recovery was started from this
+ lsn_t checkpoint_lsn, /*!< in: recovery was started from this
checkpoint */
- ib_uint64_t archived_lsn) /*!< in: the log has been archived up to
+ lsn_t archived_lsn) /*!< in: the log has been archived up to
this lsn */
{
- ib_uint64_t start_lsn;
- ib_uint64_t end_lsn;
- ib_uint64_t finish_lsn1;
- ib_uint64_t finish_lsn2;
- ib_uint64_t finish_lsn;
- ulint len;
+ lsn_t start_lsn;
+ lsn_t end_lsn;
+ lsn_t finish_lsn1;
+ lsn_t finish_lsn2;
+ lsn_t finish_lsn;
ulint i;
- if (archived_lsn == IB_ULONGLONG_MAX) {
+ if (archived_lsn == LSN_MAX) {
/* Checkpoint was taken in the NOARCHIVELOG mode */
archived_lsn = checkpoint_lsn;
}
@@ -440,7 +439,7 @@ recv_truncate_group(
OS_FILE_LOG_BLOCK_SIZE)
+ recv_sys->last_log_buf_size;
- if (limit_lsn != IB_ULONGLONG_MAX) {
+ if (limit_lsn != LSN_MAX) {
/* We do not know how far we should erase log records: erase
as much as possible */
@@ -465,11 +464,13 @@ recv_truncate_group(
if (start_lsn != recovered_lsn) {
/* Copy the last incomplete log block to the log buffer and
edit its data length: */
+ lsn_t diff = recovered_lsn - start_lsn;
+
+ ut_a(diff <= 0xFFFFUL);
ut_memcpy(log_sys->buf, recv_sys->last_block,
OS_FILE_LOG_BLOCK_SIZE);
- log_block_set_data_len(log_sys->buf,
- (ulint) (recovered_lsn - start_lsn));
+ log_block_set_data_len(log_sys->buf, (ulint) diff);
}
if (start_lsn >= finish_lsn) {
@@ -478,6 +479,8 @@ recv_truncate_group(
}
for (;;) {
+ ulint len;
+
end_lsn = start_lsn + RECV_SCAN_SIZE;
if (end_lsn > finish_lsn) {
@@ -514,12 +517,11 @@ recv_copy_group(
group */
log_group_t* group, /*!< in: copy to this log
group */
- ib_uint64_t recovered_lsn) /*!< in: recovery succeeded up
+ lsn_t recovered_lsn) /*!< in: recovery succeeded up
to this lsn */
{
- ib_uint64_t start_lsn;
- ib_uint64_t end_lsn;
- ulint len;
+ lsn_t start_lsn;
+ lsn_t end_lsn;
if (group->scanned_lsn >= recovered_lsn) {
@@ -531,6 +533,8 @@ recv_copy_group(
start_lsn = ut_uint64_align_down(group->scanned_lsn,
OS_FILE_LOG_BLOCK_SIZE);
for (;;) {
+ ulint len;
+
end_lsn = start_lsn + RECV_SCAN_SIZE;
if (end_lsn > recovered_lsn) {
@@ -567,9 +571,9 @@ recv_synchronize_groups(
log group */
{
log_group_t* group;
- ib_uint64_t start_lsn;
- ib_uint64_t end_lsn;
- ib_uint64_t recovered_lsn;
+ lsn_t start_lsn;
+ lsn_t end_lsn;
+ lsn_t recovered_lsn;
recovered_lsn = recv_sys->recovered_lsn;
@@ -706,7 +710,9 @@ recv_find_max_checkpoint(
group->lsn = mach_read_from_8(
buf + LOG_CHECKPOINT_LSN);
group->lsn_offset = mach_read_from_4(
- buf + LOG_CHECKPOINT_OFFSET);
+ buf + LOG_CHECKPOINT_OFFSET_LOW32);
+ group->lsn_offset |= ((lsn_t) mach_read_from_4(
+ buf + LOG_CHECKPOINT_OFFSET_HIGH32)) << 32;
checkpoint_no = mach_read_from_8(
buf + LOG_CHECKPOINT_NO);
@@ -760,8 +766,8 @@ recv_read_cp_info_for_backup(
/*=========================*/
const byte* hdr, /*!< in: buffer containing the log group
header */
- ib_uint64_t* lsn, /*!< out: checkpoint lsn */
- ulint* offset, /*!< out: checkpoint offset in the log group */
+ lsn_t* lsn, /*!< out: checkpoint lsn */
+ lsn_t* offset, /*!< out: checkpoint offset in the log group */
ulint* fsp_limit,/*!< out: fsp limit of space 0,
1000000000 if the database is running
with < version 3.23.50 of InnoDB */
@@ -796,7 +802,10 @@ recv_read_cp_info_for_backup(
cp_buf = hdr + max_cp;
*lsn = mach_read_from_8(cp_buf + LOG_CHECKPOINT_LSN);
- *offset = mach_read_from_4(cp_buf + LOG_CHECKPOINT_OFFSET);
+ *offset = mach_read_from_4(
+ cp_buf + LOG_CHECKPOINT_OFFSET_LOW32);
+ *offset |= mach_read_from_4(
+ cp_buf + LOG_CHECKPOINT_OFFSET_HIGH32) << 32;
/* If the user is running a pre-3.23.50 version of InnoDB, its
checkpoint data does not contain the fsp limit info */
@@ -869,7 +878,7 @@ recv_scan_log_seg_for_backup(
/*=========================*/
byte* buf, /*!< in: buffer containing log data */
ulint buf_len, /*!< in: data length in that buffer */
- ib_uint64_t* scanned_lsn, /*!< in/out: lsn of buffer start,
+ lsn_t* scanned_lsn, /*!< in/out: lsn of buffer start,
we return scanned lsn */
ulint* scanned_checkpoint_no,
/*!< in/out: 4 lowest bytes of the
@@ -1341,13 +1350,13 @@ static
void
recv_add_to_hash_table(
/*===================*/
- byte type, /*!< in: log record type */
- ulint space, /*!< in: space id */
- ulint page_no, /*!< in: page number */
- byte* body, /*!< in: log record body */
- byte* rec_end, /*!< in: log record end */
- ib_uint64_t start_lsn, /*!< in: start lsn of the mtr */
- ib_uint64_t end_lsn) /*!< in: end lsn of the mtr */
+ byte type, /*!< in: log record type */
+ ulint space, /*!< in: space id */
+ ulint page_no, /*!< in: page number */
+ byte* body, /*!< in: log record body */
+ byte* rec_end, /*!< in: log record end */
+ lsn_t start_lsn, /*!< in: start lsn of the mtr */
+ lsn_t end_lsn) /*!< in: end lsn of the mtr */
{
recv_t* recv;
ulint len;
@@ -1472,10 +1481,10 @@ recv_recover_page_func(
recv_addr_t* recv_addr;
recv_t* recv;
byte* buf;
- ib_uint64_t start_lsn;
- ib_uint64_t end_lsn;
- ib_uint64_t page_lsn;
- ib_uint64_t page_newest_lsn;
+ lsn_t start_lsn;
+ lsn_t end_lsn;
+ lsn_t page_lsn;
+ lsn_t page_newest_lsn;
ibool modification_to_page;
#ifndef UNIV_HOTBACKUP
ibool success;
@@ -1590,7 +1599,7 @@ recv_recover_page_func(
if (recv->start_lsn >= page_lsn) {
- ib_uint64_t end_lsn;
+ lsn_t end_lsn;
if (!modification_to_page) {
@@ -1847,10 +1856,10 @@ loop:
mutex_exit(&(recv_sys->mutex));
mutex_exit(&(log_sys->mutex));
- n_pages = buf_flush_list(ULINT_MAX, IB_ULONGLONG_MAX);
- ut_a(n_pages != ULINT_UNDEFINED);
-
- buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST);
+ n_pages = buf_flush_list(ULINT_MAX, LSN_MAX);
+ ut_a(n_pages != ULINT_UNDEFINED);
+
+ buf_flush_wait_batch_end(NULL, BUF_FLUSH_LIST);
buf_pool_invalidate();
@@ -2070,7 +2079,7 @@ recv_parse_log_rec(
#ifdef UNIV_LOG_LSN_DEBUG
if (*type == MLOG_LSN) {
- ib_uint64_t lsn = (ib_uint64_t) *space << 32 | *page_no;
+ lsn_t lsn = (lsn_t) *space << 32 | *page_no;
# ifdef UNIV_LOG_DEBUG
ut_a(lsn == log_sys->old_lsn);
# else /* UNIV_LOG_DEBUG */
@@ -2096,21 +2105,20 @@ recv_parse_log_rec(
/*******************************************************//**
Calculates the new value for lsn when more data is added to the log. */
static
-ib_uint64_t
+lsn_t
recv_calc_lsn_on_data_add(
/*======================*/
- ib_uint64_t lsn, /*!< in: old lsn */
+ lsn_t lsn, /*!< in: old lsn */
ib_uint64_t len) /*!< in: this many bytes of data is
added, log block headers not included */
{
- ulint frag_len;
- ulint lsn_len;
+ ulint frag_len;
+ ib_uint64_t lsn_len;
- frag_len = (((ulint) lsn) % OS_FILE_LOG_BLOCK_SIZE)
- - LOG_BLOCK_HDR_SIZE;
+ frag_len = (lsn % OS_FILE_LOG_BLOCK_SIZE) - LOG_BLOCK_HDR_SIZE;
ut_ad(frag_len < OS_FILE_LOG_BLOCK_SIZE - LOG_BLOCK_HDR_SIZE
- LOG_BLOCK_TRL_SIZE);
- lsn_len = (ulint) len;
+ lsn_len = len;
lsn_len += (lsn_len + frag_len)
/ (OS_FILE_LOG_BLOCK_SIZE - LOG_BLOCK_HDR_SIZE
- LOG_BLOCK_TRL_SIZE)
@@ -2157,7 +2165,7 @@ recv_report_corrupt_log(
fprintf(stderr,
"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 %llu\n"
+ "InnoDB: Log parsing proceeded successfully up to " LSN_PF "\n"
"InnoDB: Previous log record type %lu, is multi %lu\n"
"InnoDB: Recv offset %lu, prev %lu\n",
(ulong) type, (ulong) space, (ulong) page_no,
@@ -2218,18 +2226,18 @@ recv_parse_log_recs(
to the hash table; this is set to FALSE if just
debug checking is needed */
{
- byte* ptr;
- byte* end_ptr;
- ulint single_rec;
- ulint len;
- ulint total_len;
- ib_uint64_t new_recovered_lsn;
- ib_uint64_t old_lsn;
- byte type;
- ulint space;
- ulint page_no;
- byte* body;
- ulint n_recs;
+ byte* ptr;
+ byte* end_ptr;
+ ulint single_rec;
+ ulint len;
+ ulint total_len;
+ lsn_t new_recovered_lsn;
+ lsn_t old_lsn;
+ byte type;
+ ulint space;
+ ulint page_no;
+ byte* body;
+ ulint n_recs;
ut_ad(mutex_own(&(log_sys->mutex)));
ut_ad(recv_sys->parse_start_lsn != 0);
@@ -2467,7 +2475,7 @@ ibool
recv_sys_add_to_parsing_buf(
/*========================*/
const byte* log_block, /*!< in: log block */
- ib_uint64_t scanned_lsn) /*!< in: lsn of how far we were able
+ lsn_t scanned_lsn) /*!< in: lsn of how far we were able
to find data in this log block */
{
ulint more_len;
@@ -2568,16 +2576,16 @@ recv_scan_log_recs(
const byte* buf, /*!< in: buffer containing a log
segment or garbage */
ulint len, /*!< in: buffer length */
- ib_uint64_t start_lsn, /*!< in: buffer start lsn */
- ib_uint64_t* contiguous_lsn, /*!< in/out: it is known that all log
+ lsn_t start_lsn, /*!< in: buffer start lsn */
+ lsn_t* contiguous_lsn, /*!< in/out: it is known that all log
groups contain contiguous log data up
to this lsn */
- ib_uint64_t* group_scanned_lsn)/*!< out: scanning succeeded up to
+ lsn_t* group_scanned_lsn)/*!< out: scanning succeeded up to
this lsn */
{
const byte* log_block;
ulint no;
- ib_uint64_t scanned_lsn;
+ lsn_t scanned_lsn;
ibool finished;
ulint data_len;
ibool more_data;
@@ -2609,7 +2617,7 @@ recv_scan_log_recs(
log_block)) {
fprintf(stderr,
"InnoDB: Log block no %lu at"
- " lsn %llu has\n"
+ " lsn " LSN_PF " has\n"
"InnoDB: ok header, but checksum field"
" contains %lu, should be %lu\n",
(ulong) no,
@@ -2690,7 +2698,7 @@ recv_scan_log_recs(
fprintf(stderr,
"InnoDB: Log scan progressed"
- " past the checkpoint lsn %llu\n",
+ " past the checkpoint lsn " LSN_PF "\n",
recv_sys->scanned_lsn);
recv_init_crash_recovery();
}
@@ -2749,7 +2757,7 @@ recv_scan_log_recs(
fprintf(stderr,
"InnoDB: Doing recovery: scanned up to"
- " log sequence number %llu\n",
+ " log sequence number " LSN_PF "\n",
*group_scanned_lsn);
}
}
@@ -2792,15 +2800,15 @@ void
recv_group_scan_log_recs(
/*=====================*/
log_group_t* group, /*!< in: log group */
- ib_uint64_t* contiguous_lsn, /*!< in/out: it is known that all log
+ lsn_t* contiguous_lsn, /*!< in/out: it is known that all log
groups contain contiguous log data up
to this lsn */
- ib_uint64_t* group_scanned_lsn)/*!< out: scanning succeeded up to
+ lsn_t* group_scanned_lsn)/*!< out: scanning succeeded up to
this lsn */
{
- ibool finished;
- ib_uint64_t start_lsn;
- ib_uint64_t end_lsn;
+ ibool finished;
+ lsn_t start_lsn;
+ lsn_t end_lsn;
finished = FALSE;
@@ -2825,7 +2833,7 @@ recv_group_scan_log_recs(
if (log_debug_writes) {
fprintf(stderr,
"InnoDB: Scanned group %lu up to"
- " log sequence number %llu\n",
+ " log sequence number " LSN_PF "\n",
(ulong) group->id,
*group_scanned_lsn);
}
@@ -2884,34 +2892,30 @@ ulint
recv_recovery_from_checkpoint_start_func(
/*=====================================*/
#ifdef UNIV_LOG_ARCHIVE
- ulint type, /*!< in: LOG_CHECKPOINT or
- LOG_ARCHIVE */
- ib_uint64_t limit_lsn, /*!< in: recover up to this lsn
- if possible */
+ ulint type, /*!< in: LOG_CHECKPOINT or LOG_ARCHIVE */
+ lsn_t limit_lsn, /*!< in: recover up to this lsn if possible */
#endif /* UNIV_LOG_ARCHIVE */
- ib_uint64_t min_flushed_lsn,/*!< in: min flushed lsn from
- data files */
- ib_uint64_t max_flushed_lsn)/*!< in: max flushed lsn from
- data files */
+ lsn_t min_flushed_lsn,/*!< in: min flushed lsn from data files */
+ lsn_t max_flushed_lsn)/*!< in: max flushed lsn from data files */
{
log_group_t* group;
log_group_t* max_cp_group;
log_group_t* up_to_date_group;
ulint max_cp_field;
- ib_uint64_t checkpoint_lsn;
+ lsn_t checkpoint_lsn;
ib_uint64_t checkpoint_no;
- ib_uint64_t old_scanned_lsn;
- ib_uint64_t group_scanned_lsn;
- ib_uint64_t contiguous_lsn;
+ lsn_t old_scanned_lsn;
+ lsn_t group_scanned_lsn;
+ lsn_t contiguous_lsn;
#ifdef UNIV_LOG_ARCHIVE
- ib_uint64_t archived_lsn;
+ lsn_t archived_lsn;
#endif /* UNIV_LOG_ARCHIVE */
byte* buf;
byte log_hdr_buf[LOG_FILE_HDR_SIZE];
ulint err;
#ifdef UNIV_LOG_ARCHIVE
- ut_ad(type != LOG_CHECKPOINT || limit_lsn == IB_ULONGLONG_MAX);
+ ut_ad(type != LOG_CHECKPOINT || limit_lsn == LSN_MAX);
/** TRUE when recovering from a checkpoint */
# define TYPE_CHECKPOINT (type == LOG_CHECKPOINT)
/** Recover up to this log sequence number */
@@ -2920,7 +2924,7 @@ recv_recovery_from_checkpoint_start_func
/** TRUE when recovering from a checkpoint */
# define TYPE_CHECKPOINT 1
/** Recover up to this log sequence number */
-# define LIMIT_LSN IB_ULONGLONG_MAX
+# define LIMIT_LSN LSN_MAX
#endif /* UNIV_LOG_ARCHIVE */
if (TYPE_CHECKPOINT) {
@@ -3123,10 +3127,10 @@ recv_recovery_from_checkpoint_start_func
" ib_logfiles to start up"
" the database?\n"
"InnoDB: Log sequence number in"
- " ib_logfiles is %llu, log\n"
+ " ib_logfiles is " LSN_PF ", log\n"
"InnoDB: sequence numbers stamped"
" to ibdata file headers are between\n"
- "InnoDB: %llu and %llu.\n"
+ "InnoDB: " LSN_PF " and " LSN_PF ".\n"
"InnoDB: #########################"
"#################################\n",
checkpoint_lsn,
@@ -3156,7 +3160,8 @@ recv_recovery_from_checkpoint_start_func
fprintf(stderr,
" InnoDB: ERROR: We were only able to scan the log"
" up to\n"
- "InnoDB: %llu, but a checkpoint was at %llu.\n"
+ "InnoDB: " LSN_PF ", but a checkpoint was at "
+ LSN_PF ".\n"
"InnoDB: It is possible that"
" the database is now corrupt!\n",
group_scanned_lsn,
@@ -3167,8 +3172,8 @@ recv_recovery_from_checkpoint_start_func
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: ERROR: We were only able to scan the log"
- " up to %llu\n"
- "InnoDB: but a database page a had an lsn %llu."
+ " up to " LSN_PF "\n"
+ "InnoDB: but a database page a had an lsn " LSN_PF "."
" It is possible that the\n"
"InnoDB: database is now corrupt!\n",
group_scanned_lsn,
@@ -3343,7 +3348,7 @@ UNIV_INTERN
void
recv_reset_logs(
/*============*/
- ib_uint64_t lsn, /*!< in: reset to this lsn
+ lsn_t lsn, /*!< in: reset to this lsn
rounded up to be divisible by
OS_FILE_LOG_BLOCK_SIZE, after
which we add
@@ -3404,8 +3409,7 @@ recv_reset_logs(
/* Reset the checkpoint fields in logs */
- log_make_checkpoint_at(IB_ULONGLONG_MAX, TRUE);
- log_make_checkpoint_at(IB_ULONGLONG_MAX, TRUE);
+ log_make_checkpoint_at(LSN_MAX, TRUE);
mutex_enter(&(log_sys->mutex));
}
@@ -3420,8 +3424,8 @@ recv_reset_log_files_for_backup(
/*============================*/
const char* log_dir, /*!< in: log file directory path */
ulint n_log_files, /*!< in: number of log files */
- ulint log_file_size, /*!< in: log file size */
- ib_uint64_t lsn) /*!< in: new start lsn, must be
+ lsn_t log_file_size, /*!< in: log file size */
+ lsn_t lsn) /*!< in: new start lsn, must be
divisible by OS_FILE_LOG_BLOCK_SIZE */
{
os_file_t log_file;
=== modified file 'storage/innobase/mem/mem0dbg.c'
--- a/storage/innobase/mem/mem0dbg.c revid:serge.kozlov@stripped
+++ b/storage/innobase/mem/mem0dbg.c revid:vasil.dimov@stripped
@@ -24,6 +24,8 @@ but is included in mem0mem.* !
Created 6/9/1994 Heikki Tuuri
*************************************************************************/
+#include "ha_prototypes.h"
+
#ifdef UNIV_MEM_DEBUG
# ifndef UNIV_HOTBACKUP
/* The mutex which protects in the debug version the hash table
@@ -400,7 +402,7 @@ mem_hash_remove(
fprintf(stderr,
"Memory heap or buffer freed in %s line %lu"
" did not exist.\n",
- file_name, (ulong) line);
+ innobase_basename(file_name), (ulong) line);
ut_error;
}
@@ -419,8 +421,9 @@ mem_hash_remove(
"in %s line %lu and tried to free in %s line %lu.\n"
"Hex dump of 400 bytes around memory heap"
" first block start:\n",
- node->nth_heap, node->file_name, (ulong) node->line,
- file_name, (ulong) line);
+ node->nth_heap,
+ innobase_basename(node->file_name), (ulong) node->line,
+ innobase_basename(file_name), (ulong) line);
ut_print_buf(stderr, (byte*)node->heap - 200, 400);
fputs("\nDump of the mem heap:\n", stderr);
mem_heap_validate_or_print(node->heap, NULL, TRUE, &error,
@@ -763,7 +766,8 @@ mem_validate_no_assert(void)
"Inconsistency in memory heap"
" or buffer created\n"
"in %s line %lu.\n",
- node->file_name, node->line);
+ innobase_basename(node->file_name),
+ node->line);
mutex_exit(&mem_hash_mutex);
@@ -989,7 +993,8 @@ mem_print_info_low(
fprintf(outfile,
"%lu: file %s line %lu of size %lu phys.size %lu"
" with %lu blocks, type %lu\n",
- node->nth_heap, node->file_name, node->line,
+ node->nth_heap,
+ innobase_basename(node->file_name), node->line,
allocated_mem, ph_size, n_blocks,
(node->heap)->type);
next_heap:
=== modified file 'storage/innobase/mtr/mtr0mtr.c'
--- a/storage/innobase/mtr/mtr0mtr.c revid:serge.kozlov@stripped
+++ b/storage/innobase/mtr/mtr0mtr.c revid:vasil.dimov@stripped
@@ -52,6 +52,10 @@ mtr_memo_slot_release(
ut_ad(mtr);
ut_ad(slot);
+ /* slot release is a local operation for the current mtr.
+ We must not be holding the flush_order mutex while
+ doing this. */
+ ut_ad(!log_flush_order_mutex_own());
#ifndef UNIV_DEBUG
UT_NOT_USED(mtr);
#endif /* UNIV_DEBUG */
@@ -124,9 +128,7 @@ mtr_memo_slot_note_modification(
if (slot->object != NULL && slot->type == MTR_MEMO_PAGE_X_FIX) {
buf_block_t* block = (buf_block_t*) slot->object;
-#ifdef UNIV_DEBUG
ut_ad(log_flush_order_mutex_own());
-#endif /* UNIV_DEBUG */
buf_flush_note_modification(block, mtr);
}
}
@@ -330,7 +332,6 @@ mtr_memo_release(
offset = dyn_array_get_data_size(memo);
- log_flush_order_mutex_enter();
while (offset > 0) {
offset -= sizeof(mtr_memo_slot_t);
@@ -349,7 +350,6 @@ mtr_memo_release(
break;
}
}
- log_flush_order_mutex_exit();
}
#endif /* !UNIV_HOTBACKUP */
=== modified file 'storage/innobase/page/page0zip.c'
--- a/storage/innobase/page/page0zip.c revid:serge.kozlov@stripped
+++ b/storage/innobase/page/page0zip.c revid:vasil.dimov@stripped
@@ -654,13 +654,13 @@ page_zip_dir_encode(
Allocate memory for zlib. */
static
void*
-page_zip_malloc(
+page_zip_zalloc(
/*============*/
void* opaque, /*!< in/out: memory heap */
uInt items, /*!< in: number of items to allocate */
uInt size) /*!< in: size of an item in bytes */
{
- return(mem_heap_alloc(opaque, items * size));
+ return(mem_heap_zalloc(opaque, items * size));
}
/**********************************************************************//**
@@ -685,7 +685,7 @@ page_zip_set_alloc(
{
z_stream* strm = stream;
- strm->zalloc = page_zip_malloc;
+ strm->zalloc = page_zip_zalloc;
strm->zfree = page_zip_free;
strm->opaque = heap;
}
@@ -2915,19 +2915,18 @@ zlib_error:
page_zip_set_alloc(&d_stream, heap);
- if (UNIV_UNLIKELY(inflateInit2(&d_stream, UNIV_PAGE_SIZE_SHIFT)
- != Z_OK)) {
- ut_error;
- }
-
d_stream.next_in = page_zip->data + PAGE_DATA;
/* Subtract the space reserved for
the page header and the end marker of the modification log. */
d_stream.avail_in = page_zip_get_size(page_zip) - (PAGE_DATA + 1);
-
d_stream.next_out = page + PAGE_ZIP_START;
d_stream.avail_out = UNIV_PAGE_SIZE - PAGE_ZIP_START;
+ if (UNIV_UNLIKELY(inflateInit2(&d_stream, UNIV_PAGE_SIZE_SHIFT)
+ != Z_OK)) {
+ ut_error;
+ }
+
/* Decode the zlib header and the index information. */
if (UNIV_UNLIKELY(inflate(&d_stream, Z_BLOCK) != Z_OK)) {
=== modified file 'storage/innobase/row/row0mysql.c'
--- a/storage/innobase/row/row0mysql.c revid:serge.kozlov@stripped
+++ b/storage/innobase/row/row0mysql.c revid:vasil.dimov@stripped
@@ -2584,7 +2584,7 @@ row_import_tablespace_for_mysql(
{
dict_table_t* table;
ibool success;
- ib_uint64_t current_lsn;
+ lsn_t current_lsn;
ulint err = DB_SUCCESS;
ut_ad(trx->mysql_thd == NULL
=== modified file 'storage/innobase/row/row0sel.c'
--- a/storage/innobase/row/row0sel.c revid:serge.kozlov@stripped
+++ b/storage/innobase/row/row0sel.c revid:vasil.dimov@stripped
@@ -2662,8 +2662,18 @@ row_sel_field_store_in_mysql_format_func
ut_ad(templ->mysql_col_len >= len);
ut_ad(templ->mbmaxlen >= templ->mbminlen);
+ /* If field_no equals to templ->icp_rec_field_no,
+ we are examining a row pointed by "icp_rec_field_no".
+ There is possibility that icp_rec_field_no refers to
+ a field in a secondary index while templ->rec_field_no
+ points to field in a primary index. The length
+ should still be equal, unless the field pointed
+ by icp_rec_field_no has a prefix */
ut_ad(templ->mbmaxlen > templ->mbminlen
- || templ->mysql_col_len == len);
+ || templ->mysql_col_len == len
+ || (field_no == templ->icp_rec_field_no
+ && field->prefix_len > 0));
+
/* The following assertion would fail for old tables
containing UTF-8 ENUM columns due to Bug #9526. */
ut_ad(!templ->mbmaxlen
@@ -3276,16 +3286,15 @@ row_sel_pop_cached_row_for_mysql(
}
/********************************************************************//**
-Pushes a row for MySQL to the fetch cache.
-@return TRUE on success, FALSE if the record contains incomplete BLOBs */
-UNIV_INLINE __attribute__((warn_unused_result))
-ibool
+Pushes a row for MySQL to the fetch cache. */
+UNIV_INLINE
+void
row_sel_push_cache_row_for_mysql(
/*=============================*/
byte* mysql_rec, /*!< in/out: MySQL record */
row_prebuilt_t* prebuilt) /*!< in/out: prebuilt struct */
{
- ut_ad(prebuilt->n_fetch_cached < MYSQL_FETCH_CACHE_SIZE);
+ ut_a(prebuilt->n_fetch_cached < MYSQL_FETCH_CACHE_SIZE);
ut_a(!prebuilt->templ_contains_blob);
if (UNIV_UNLIKELY(prebuilt->fetch_cache[0] == NULL)) {
@@ -3317,12 +3326,7 @@ row_sel_push_cache_row_for_mysql(
memcpy(prebuilt->fetch_cache[prebuilt->n_fetch_cached],
mysql_rec, prebuilt->mysql_row_len);
- if (++prebuilt->n_fetch_cached < MYSQL_FETCH_CACHE_SIZE) {
- return(FALSE);
- }
-
- row_sel_pop_cached_row_for_mysql(mysql_rec, prebuilt);
- return(TRUE);
+ ++prebuilt->n_fetch_cached;
}
/*********************************************************************//**
@@ -3426,6 +3430,8 @@ row_search_idx_cond_check(
return(ICP_MATCH);
}
+ MONITOR_INC(MONITOR_ICP_ATTEMPTS);
+
/* Convert to MySQL format those fields that are needed for
evaluating the index condition. */
@@ -3462,12 +3468,16 @@ row_search_idx_cond_check(
mysql_rec, prebuilt, rec, FALSE,
prebuilt->index, offsets)) {
ut_ad(dict_index_is_clust(prebuilt->index));
- result = ICP_NO_MATCH;
+ return(ICP_NO_MATCH);
}
}
- /* fall through */
+ MONITOR_INC(MONITOR_ICP_MATCH);
+ return(result);
case ICP_NO_MATCH:
+ MONITOR_INC(MONITOR_ICP_NO_MATCH);
+ return(result);
case ICP_OUT_OF_RANGE:
+ MONITOR_INC(MONITOR_ICP_OUT_OF_RANGE);
return(result);
}
@@ -4650,12 +4660,18 @@ requires_clust_rec:
not cache rows because there the cursor is a scrollable
cursor. */
+ ut_a(prebuilt->n_fetch_cached < MYSQL_FETCH_CACHE_SIZE);
+
+ /* We only convert from InnoDB row format to MySQL row
+ format when ICP is disabled. */
+
if (!prebuilt->idx_cond
&& !row_sel_store_mysql_rec(
buf, prebuilt, result_rec,
result_rec != rec,
result_rec != rec ? clust_index : index,
offsets)) {
+
/* Only fresh inserts may contain incomplete
externally stored columns. Pretend that such
records do not exist. Such records may only be
@@ -4664,7 +4680,11 @@ requires_clust_rec:
transaction. Rollback happens at a lower
level, not here. */
goto next_rec;
- } else if (row_sel_push_cache_row_for_mysql(buf, prebuilt)) {
+ }
+
+ row_sel_push_cache_row_for_mysql(buf, prebuilt);
+
+ if (prebuilt->n_fetch_cached < MYSQL_FETCH_CACHE_SIZE) {
goto next_rec;
}
} else {
=== modified file 'storage/innobase/scripts/persistent_storage.sql'
--- a/storage/innobase/scripts/persistent_storage.sql revid:serge.kozlov@stripped
+++ b/storage/innobase/scripts/persistent_storage.sql revid:vasil.dimov@stripped
@@ -3,8 +3,8 @@ CREATE DATABASE innodb;
-- DROP TABLE IF EXISTS innodb.table_stats;
CREATE TABLE innodb.table_stats (
- database_name VARCHAR(512) NOT NULL,
- table_name VARCHAR(512) NOT NULL,
+ database_name VARCHAR(64) NOT NULL,
+ table_name VARCHAR(64) NOT NULL,
stats_timestamp TIMESTAMP NOT NULL,
n_rows BIGINT UNSIGNED NOT NULL,
clustered_index_size BIGINT UNSIGNED NOT NULL,
@@ -14,9 +14,9 @@ CREATE TABLE innodb.table_stats (
-- DROP TABLE IF EXISTS innodb.index_stats;
CREATE TABLE innodb.index_stats (
- database_name VARCHAR(512) NOT NULL,
- table_name VARCHAR(512) NOT NULL,
- index_name VARCHAR(512) NOT NULL,
+ database_name VARCHAR(64) NOT NULL,
+ table_name VARCHAR(64) NOT NULL,
+ index_name VARCHAR(64) NOT NULL,
stat_timestamp TIMESTAMP NOT NULL,
/* there are at least:
stat_name='size'
=== modified file 'storage/innobase/srv/srv0mon.c'
--- a/storage/innobase/srv/srv0mon.c revid:serge.kozlov@stripped
+++ b/storage/innobase/srv/srv0mon.c revid:vasil.dimov@stripped
@@ -825,6 +825,26 @@ static monitor_info_t innodb_counter_inf
"Number of tables in background drop table list",
0, 0, MONITOR_BACKGROUND_DROP_TABLE},
+ /* ===== Counters for ICP (Index Condition Pushdown) Module ===== */
+ {"module_icp", "icp", "Index Condition Pushdown",
+ MONITOR_MODULE, 0, MONITOR_MODULE_ICP},
+
+ {"icp_attempts", "icp",
+ "Number of attempts for index push-down condition checks",
+ 0, 0, MONITOR_ICP_ATTEMPTS},
+
+ {"icp_no_match", "icp",
+ "Index push-down condition does not match",
+ 0, 0, MONITOR_ICP_NO_MATCH},
+
+ {"icp_out_of_range", "icp",
+ "Index push-down condition out of range",
+ 0, 0, MONITOR_ICP_OUT_OF_RANGE},
+
+ {"icp_match", "icp",
+ "Index push-down condition matches",
+ 0, 0, MONITOR_ICP_MATCH},
+
/* ========== To turn on/off reset all counters ========== */
{"all", "All Counters", "Turn on/off and reset all counters",
MONITOR_MODULE, 0, MONITOR_ALL_COUNTER}
@@ -1154,7 +1174,7 @@ srv_mon_process_existing_counter(
/* innodb_os_log_written */
case MONITOR_OVLD_OS_LOG_WRITTEN:
- value = srv_os_log_written;
+ value = (mon_type_t) srv_os_log_written;
break;
/* innodb_os_log_fsyncs */
=== modified file 'storage/innobase/srv/srv0srv.c'
--- a/storage/innobase/srv/srv0srv.c revid:serge.kozlov@stripped
+++ b/storage/innobase/srv/srv0srv.c revid:vasil.dimov@stripped
@@ -163,7 +163,7 @@ UNIV_INTERN char** srv_log_group_home_di
UNIV_INTERN ulint srv_n_log_groups = ULINT_MAX;
UNIV_INTERN ulint srv_n_log_files = ULINT_MAX;
/* size in database pages */
-UNIV_INTERN ulint srv_log_file_size = ULINT_MAX;
+UNIV_INTERN ib_uint64_t srv_log_file_size = IB_UINT64_MAX;
/* size in database pages */
UNIV_INTERN ulint srv_log_buffer_size = ULINT_MAX;
UNIV_INTERN ulong srv_flush_log_at_trx_commit = 1;
@@ -272,7 +272,7 @@ UNIV_INTERN ulint srv_log_write_requests
UNIV_INTERN ulint srv_log_writes = 0;
/* amount of data written to the log files in bytes */
-UNIV_INTERN ulint srv_os_log_written = 0;
+UNIV_INTERN lsn_t srv_os_log_written = 0;
/* amount of writes being done to the log files */
UNIV_INTERN ulint srv_os_log_pending_writes = 0;
@@ -1848,8 +1848,8 @@ srv_error_monitor_thread(
{
/* number of successive fatal timeouts observed */
ulint fatal_cnt = 0;
- ib_uint64_t old_lsn;
- ib_uint64_t new_lsn;
+ lsn_t old_lsn;
+ lsn_t new_lsn;
ib_int64_t sig_count;
old_lsn = srv_start_lsn;
@@ -1873,9 +1873,9 @@ loop:
if (new_lsn < old_lsn) {
ut_print_timestamp(stderr);
fprintf(stderr,
- " InnoDB: Error: old log sequence number %llu"
+ " InnoDB: Error: old log sequence number " LSN_PF
" was greater\n"
- "InnoDB: than the new log sequence number %llu!\n"
+ "InnoDB: than the new log sequence number " LSN_PF "!\n"
"InnoDB: Please submit a bug report"
" to http://bugs.mysql.com\n",
old_lsn, new_lsn);
=== modified file 'storage/innobase/srv/srv0start.c'
--- a/storage/innobase/srv/srv0start.c revid:serge.kozlov@stripped
+++ b/storage/innobase/srv/srv0start.c revid:vasil.dimov@stripped
@@ -90,9 +90,9 @@ Created 2/16/1996 Heikki Tuuri
# include "zlib.h" /* for ZLIB_VERSION */
/** Log sequence number immediately after startup */
-UNIV_INTERN ib_uint64_t srv_start_lsn;
+UNIV_INTERN lsn_t srv_start_lsn;
/** Log sequence number at shutdown */
-UNIV_INTERN ib_uint64_t srv_shutdown_lsn;
+UNIV_INTERN lsn_t srv_shutdown_lsn;
#ifdef HAVE_DARWIN_THREADS
# include <sys/utsname.h>
@@ -528,9 +528,9 @@ static
ulint
srv_calc_low32(
/*===========*/
- ulint file_size) /*!< in: file size in database pages */
+ ib_uint64_t file_size) /*!< in: file size in database pages */
{
- return(0xFFFFFFFFUL & (file_size << UNIV_PAGE_SIZE_SHIFT));
+ return((ulint) (0xFFFFFFFFUL & (file_size << UNIV_PAGE_SIZE_SHIFT)));
}
/*********************************************************************//**
@@ -541,9 +541,9 @@ static
ulint
srv_calc_high32(
/*============*/
- ulint file_size) /*!< in: file size in database pages */
+ ib_uint64_t file_size) /*!< in: file size in database pages */
{
- return(file_size >> (32 - UNIV_PAGE_SIZE_SHIFT));
+ return((ulint) (file_size >> (32 - UNIV_PAGE_SIZE_SHIFT)));
}
/*********************************************************************//**
@@ -680,7 +680,11 @@ open_or_create_log_file(
ut_a(fil_validate());
- fil_node_create(name, srv_log_file_size,
+ /* srv_log_file_size is measured in pages; if page size is 16KB,
+ then we have a limit of 64TB on 32 bit systems */
+ ut_a(srv_log_file_size <= ULINT_MAX);
+
+ fil_node_create(name, (ulint) srv_log_file_size,
2 * k + SRV_LOG_SPACE_FIRST_ID, FALSE);
#ifdef UNIV_LOG_ARCHIVE
/* If this is the first log group, create the file space object
@@ -721,9 +725,9 @@ open_or_create_data_files(
ulint* max_arch_log_no,/*!< out: max of archived log
numbers in data files */
#endif /* UNIV_LOG_ARCHIVE */
- ib_uint64_t* min_flushed_lsn,/*!< out: min of flushed lsn
+ lsn_t* min_flushed_lsn,/*!< out: min of flushed lsn
values in data files */
- ib_uint64_t* max_flushed_lsn,/*!< out: max of flushed lsn
+ lsn_t* max_flushed_lsn,/*!< out: max of flushed lsn
values in data files */
ulint* sum_of_new_sizes)/*!< out: sum of sizes of the
new files added */
@@ -1000,8 +1004,8 @@ innobase_start_or_create_for_mysql(void)
ibool log_file_created;
ibool log_created = FALSE;
ibool log_opened = FALSE;
- ib_uint64_t min_flushed_lsn;
- ib_uint64_t max_flushed_lsn;
+ lsn_t min_flushed_lsn;
+ lsn_t max_flushed_lsn;
#ifdef UNIV_LOG_ARCHIVE
ulint min_arch_log_no;
ulint max_arch_log_no;
@@ -1422,11 +1426,18 @@ innobase_start_or_create_for_mysql(void)
}
#endif /* UNIV_LOG_ARCHIVE */
- if (srv_n_log_files * srv_log_file_size >= 262144) {
+ if (srv_n_log_files * srv_log_file_size >= ULINT_MAX) {
+ /* fil_io() takes ulint as an argument and we are passing
+ (next_offset / UNIV_PAGE_SIZE) to it in log_group_write_buf().
+ So (next_offset / UNIV_PAGE_SIZE) must be less than ULINT_MAX.
+ So next_offset must be < ULINT_MAX * UNIV_PAGE_SIZE. This
+ means that we are limited to ULINT_MAX * UNIV_PAGE_SIZE which
+ is 64 TB on 32 bit systems. */
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Error: combined size of log files"
- " must be < 4 GB\n");
+ " must be < %lu GB\n",
+ ULINT_MAX / 1073741824 * UNIV_PAGE_SIZE);
return(DB_ERROR);
}
@@ -1576,7 +1587,7 @@ innobase_start_or_create_for_mysql(void)
return(DB_ERROR);
}
- if (max_flushed_lsn < (ib_uint64_t) 1000) {
+ if (max_flushed_lsn < (lsn_t) 1000) {
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Cannot initialize created"
@@ -2017,7 +2028,7 @@ innobase_start_or_create_for_mysql(void)
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: %s started; "
- "log sequence number %llu\n",
+ "log sequence number " LSN_PF "\n",
INNODB_VERSION_STR, srv_start_lsn);
}
@@ -2305,7 +2316,7 @@ innobase_shutdown_for_mysql(void)
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Shutdown completed;"
- " log sequence number %llu\n",
+ " log sequence number " LSN_PF "\n",
srv_shutdown_lsn);
}
=== modified file 'storage/innobase/sync/sync0arr.c'
--- a/storage/innobase/sync/sync0arr.c revid:serge.kozlov@stripped
+++ b/storage/innobase/sync/sync0arr.c revid:vasil.dimov@stripped
@@ -40,6 +40,7 @@ Created 9/5/1995 Heikki Tuuri
#include "os0sync.h"
#include "os0file.h"
#include "srv0srv.h"
+#include "ha_prototypes.h"
/*
WAIT ARRAY
@@ -478,8 +479,8 @@ sync_array_cell_print(
fprintf(file,
"--Thread %lu has waited at %s line %lu"
" for %.2f seconds the semaphore:\n",
- (ulong) os_thread_pf(cell->thread), cell->file,
- (ulong) cell->line,
+ (ulong) os_thread_pf(cell->thread),
+ innobase_basename(cell->file), (ulong) cell->line,
difftime(time(NULL), cell->reservation_time));
if (type == SYNC_MUTEX) {
@@ -493,7 +494,8 @@ sync_array_cell_print(
"Last time reserved in file %s line %lu, "
#endif /* UNIV_SYNC_DEBUG */
"waiters flag %lu\n",
- (void*) mutex, mutex->cfile_name, (ulong) mutex->cline,
+ (void*) mutex, innobase_basename(mutex->cfile_name),
+ (ulong) mutex->cline,
(ulong) mutex->lock_word,
#ifdef UNIV_SYNC_DEBUG
mutex->file_name, (ulong) mutex->line,
@@ -512,7 +514,7 @@ sync_array_cell_print(
fprintf(file,
" RW-latch at %p created in file %s line %lu\n",
- (void*) rwlock, rwlock->cfile_name,
+ (void*) rwlock, innobase_basename(rwlock->cfile_name),
(ulong) rwlock->cline);
writer = rw_lock_get_writer(rwlock);
if (writer != RW_LOCK_NOT_LOCKED) {
@@ -533,7 +535,7 @@ sync_array_cell_print(
(ulong) rw_lock_get_reader_count(rwlock),
(ulong) rwlock->waiters,
rwlock->lock_word,
- rwlock->last_s_file_name,
+ innobase_basename(rwlock->last_s_file_name),
(ulong) rwlock->last_s_line,
rwlock->last_x_file_name,
(ulong) rwlock->last_x_line);
=== modified file 'storage/innobase/sync/sync0rw.c'
--- a/storage/innobase/sync/sync0rw.c revid:serge.kozlov@stripped
+++ b/storage/innobase/sync/sync0rw.c revid:vasil.dimov@stripped
@@ -39,6 +39,7 @@ Created 9/11/1995 Heikki Tuuri
#include "mem0mem.h"
#include "srv0srv.h"
#include "os0sync.h" /* for INNODB_RW_LOCKS_USE_ATOMICS */
+#include "ha_prototypes.h"
/*
IMPLEMENTATION OF THE RW_LOCK
@@ -407,7 +408,8 @@ lock_loop:
" cfile %s cline %lu rnds %lu\n",
(ulong) os_thread_pf(os_thread_get_curr_id()),
(void*) lock,
- lock->cfile_name, (ulong) lock->cline, (ulong) i);
+ innobase_basename(lock->cfile_name),
+ (ulong) lock->cline, (ulong) i);
}
/* We try once again to obtain the lock */
@@ -442,7 +444,8 @@ lock_loop:
"Thread %lu OS wait rw-s-lock at %p"
" cfile %s cline %lu\n",
os_thread_pf(os_thread_get_curr_id()),
- (void*) lock, lock->cfile_name,
+ (void*) lock,
+ innobase_basename(lock->cfile_name),
(ulong) lock->cline);
}
@@ -664,7 +667,8 @@ lock_loop:
"Thread %lu spin wait rw-x-lock at %p"
" cfile %s cline %lu rnds %lu\n",
os_thread_pf(os_thread_get_curr_id()), (void*) lock,
- lock->cfile_name, (ulong) lock->cline, (ulong) i);
+ innobase_basename(lock->cfile_name),
+ (ulong) lock->cline, (ulong) i);
}
sync_array_reserve_cell(sync_primary_wait_array,
@@ -687,7 +691,8 @@ lock_loop:
"Thread %lu OS wait for rw-x-lock at %p"
" cfile %s cline %lu\n",
os_thread_pf(os_thread_get_curr_id()), (void*) lock,
- lock->cfile_name, (ulong) lock->cline);
+ innobase_basename(lock->cfile_name),
+ (ulong) lock->cline);
}
/* these stats may not be accurate */
=== modified file 'storage/innobase/sync/sync0sync.c'
--- a/storage/innobase/sync/sync0sync.c revid:serge.kozlov@stripped
+++ b/storage/innobase/sync/sync0sync.c revid:vasil.dimov@stripped
@@ -43,6 +43,7 @@ Created 9/5/1995 Heikki Tuuri
#ifdef UNIV_SYNC_DEBUG
# include "srv0start.h" /* srv_is_being_started */
#endif /* UNIV_SYNC_DEBUG */
+#include "ha_prototypes.h"
/*
REASONS FOR IMPLEMENTING THE SPIN LOCK MUTEX
@@ -544,7 +545,8 @@ spin_loop:
"Thread %lu spin wait mutex at %p"
" cfile %s cline %lu rnds %lu\n",
(ulong) os_thread_pf(os_thread_get_curr_id()), (void*) mutex,
- mutex->cfile_name, (ulong) mutex->cline, (ulong) i);
+ innobase_basename(mutex->cfile_name),
+ (ulong) mutex->cline, (ulong) i);
#endif
mutex_spin_round_count += i;
@@ -621,7 +623,8 @@ spin_loop:
fprintf(stderr,
"Thread %lu OS wait mutex at %p cfile %s cline %lu rnds %lu\n",
(ulong) os_thread_pf(os_thread_get_curr_id()), (void*) mutex,
- mutex->cfile_name, (ulong) mutex->cline, (ulong) i);
+ innobase_basename(mutex->cfile_name),
+ (ulong) mutex->cline, (ulong) i);
#endif
mutex_os_wait_count++;
@@ -870,7 +873,8 @@ sync_print_warning(
if (mutex->magic_n == MUTEX_MAGIC_N) {
fprintf(stderr,
"Mutex created at %s %lu\n",
- mutex->cfile_name, (ulong) mutex->cline);
+ innobase_basename(mutex->cfile_name),
+ (ulong) mutex->cline);
if (mutex_get_lock_word(mutex) != 0) {
ulint line;
=== modified file 'storage/innobase/trx/trx0sys.c'
--- a/storage/innobase/trx/trx0sys.c revid:serge.kozlov@stripped
+++ b/storage/innobase/trx/trx0sys.c revid:vasil.dimov@stripped
@@ -238,7 +238,7 @@ trx_sys_mark_upgraded_to_multiple_tables
mtr_commit(&mtr);
/* Flush the modified pages to disk and make a checkpoint */
- log_make_checkpoint_at(IB_ULONGLONG_MAX, TRUE);
+ log_make_checkpoint_at(LSN_MAX, TRUE);
trx_sys_multiple_tablespace_format = TRUE;
}
@@ -407,7 +407,7 @@ start_again:
mtr_commit(&mtr);
/* Flush the modified pages to disk and make a checkpoint */
- log_make_checkpoint_at(IB_ULONGLONG_MAX, TRUE);
+ log_make_checkpoint_at(LSN_MAX, TRUE);
fprintf(stderr, "InnoDB: Doublewrite buffer created\n");
=== modified file 'storage/innobase/trx/trx0trx.c'
--- a/storage/innobase/trx/trx0trx.c revid:serge.kozlov@stripped
+++ b/storage/innobase/trx/trx0trx.c revid:vasil.dimov@stripped
@@ -734,7 +734,7 @@ Assign the transaction its history seria
update UNDO log record to the assigned rollback segment.
@return the LSN of the UNDO log write. */
static
-ib_uint64_t
+lsn_t
trx_write_serialisation_history(
/*============================*/
trx_t* trx) /*!< in: transaction */
@@ -837,7 +837,7 @@ trx_commit(
trx_t* trx) /*!< in: transaction */
{
trx_named_savept_t* savep;
- ib_uint64_t lsn = 0;
+ lsn_t lsn = 0;
ut_ad(trx->in_trx_list);
ut_ad(!trx_state_eq(trx, TRX_STATE_COMMITTED_IN_MEMORY));
@@ -1188,7 +1188,7 @@ trx_commit_complete_for_mysql(
/*==========================*/
trx_t* trx) /*!< in: trx handle */
{
- ib_uint64_t lsn = trx->commit_lsn;
+ lsn_t lsn = trx->commit_lsn;
ut_a(trx);
@@ -1522,7 +1522,7 @@ trx_prepare(
trx_t* trx) /*!< in/out: transaction */
{
trx_rseg_t* rseg;
- ib_uint64_t lsn;
+ lsn_t lsn;
mtr_t mtr;
rseg = trx->rseg;
=== modified file 'storage/innobase/ut/ut0dbg.c'
--- a/storage/innobase/ut/ut0dbg.c revid:serge.kozlov@stripped
+++ b/storage/innobase/ut/ut0dbg.c revid:vasil.dimov@stripped
@@ -25,6 +25,7 @@ Created 1/30/1994 Heikki Tuuri
#include "univ.i"
#include "ut0dbg.h"
+#include "ha_prototypes.h"
#if defined(__GNUC__) && (__GNUC__ > 2)
#else
@@ -55,12 +56,13 @@ ut_dbg_assertion_failed(
ut_print_timestamp(stderr);
#ifdef UNIV_HOTBACKUP
fprintf(stderr, " InnoDB: Assertion failure in file %s line %lu\n",
- file, line);
+ innobase_basename(file), line);
#else /* UNIV_HOTBACKUP */
fprintf(stderr,
" InnoDB: Assertion failure in thread %lu"
" in file %s line %lu\n",
- os_thread_pf(os_thread_get_curr_id()), file, line);
+ os_thread_pf(os_thread_get_curr_id()),
+ innobase_basename(file), line);
#endif /* UNIV_HOTBACKUP */
if (expr) {
fprintf(stderr,
@@ -93,7 +95,8 @@ ut_dbg_stop_thread(
{
#ifndef UNIV_HOTBACKUP
fprintf(stderr, "InnoDB: Thread %lu stopped in file %s line %lu\n",
- os_thread_pf(os_thread_get_curr_id()), file, line);
+ os_thread_pf(os_thread_get_curr_id()),
+ innobase_basename(file), line);
os_thread_sleep(1000000000);
#endif /* !UNIV_HOTBACKUP */
}
No bundle (reason: revision is a merge (you can force generation of a bundle with env var BZR_FORCE_BUNDLE=1)).
| Thread |
|---|
| • bzr commit into mysql-trunk branch (vasil.dimov:3772) | vasil.dimov | 16 Mar |
