database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-29 05:21:33 +03:00
Code Activity

Merge spetrunia@bk-internal.mysql.com:/home/bk/mysql-4.1

Browse Source 
into mysql.com:/dbdata/psergey/mysql-4.1-ps-merge
This commit is contained in:
sergefp@mysql.com
2004-04-28 19:27:56 +04:00
parent 9250a0e4e1 9d8bb4bd4c
commit d4e9522962
176 changed files with 9231 additions and 5733 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.bzrignore
View File

@ -772,3 +772,5 @@ ndb/lib/libNEWTON_BASICTEST_COMMON.so
ndb/lib/libREP_API.so
ndb/lib/libndbclient.so
ndb/lib/libndbclient_extra.so
libmysqld/discover.cc
include/readline

2
BUILD/compile-pentium-max
View File

@ -9,6 +9,6 @@ extra_configs="$pentium_configs"
extra_configs="$extra_configs --with-innodb --with-berkeley-db \
--with-embedded-server --enable-thread-safe-client \
--with-openssl --with-vio --with-raid"
--with-openssl --with-vio --with-raid --with-ndbcluster"
. "$path/FINISH.sh"

1
BitKeeper/etc/logging_ok
View File

@ -92,6 +92,7 @@ monty@donna.mysql.fi
monty@hundin.mysql.fi
monty@mashka.(none)
monty@mashka.mysql.fi
monty@mishka.local
monty@mishka.mysql.fi
monty@mysql.com
monty@narttu.

1254
Docs/net_doc.txt
View File

File diff suppressed because it is too large Load Diff

2
client/client_priv.h
View File

@ -43,5 +43,5 @@ enum options_client
OPT_PROMPT, OPT_IGN_LINES,OPT_TRANSACTION,OPT_MYSQL_PROTOCOL,
OPT_SHARED_MEMORY_BASE_NAME, OPT_FRM, OPT_SKIP_OPTIMIZATION,
OPT_COMPATIBLE, OPT_RECONNECT, OPT_DELIMITER, OPT_SECURE_AUTH,
OPT_OPEN_FILES_LIMIT, OPT_SET_CHARSET
OPT_OPEN_FILES_LIMIT, OPT_SET_CHARSET, OPT_CREATE_OPTIONS
};

56
client/mysqldump.c
View File

@ -37,7 +37,7 @@
** 10 Jun 2003: SET NAMES and --no-set-names by Alexander Barkov
*/
#define DUMP_VERSION "10.6"
#define DUMP_VERSION "10.7"
#include <my_global.h>
#include <my_sys.h>
@ -91,7 +91,6 @@ static char insert_pat[12 * 1024],*opt_password=0,*current_user=0,
*opt_compatible_mode_str= 0,
*err_ptr= 0;
static char compatible_mode_normal_str[255];
static char *default_charset= (char*) MYSQL_UNIVERSAL_CLIENT_CHARSET;
static ulong opt_compatible_mode= 0;
static uint opt_mysql_port= 0, err_len= 0;
static my_string opt_mysql_unix_port=0;
@ -104,7 +103,9 @@ FILE *md_result_file;
static char *shared_memory_base_name=0;
#endif
static uint opt_protocol= 0;
static char *default_charset= (char*) MYSQL_UNIVERSAL_CLIENT_CHARSET;
static CHARSET_INFO *charset_info= &my_charset_latin1;
const char *default_dbug_option="d:t:o,/tmp/mysqldump.trace";
const char *compatible_mode_names[]=
{
@ -132,9 +133,6 @@ static struct my_option my_long_options[] =
"Dump all the databases. This will be same as --databases with all databases selected.",
(gptr*) &opt_alldbs, (gptr*) &opt_alldbs, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
0, 0},
{"all", 'a', "Include all MySQL specific create options.",
(gptr*) &create_options, (gptr*) &create_options, 0, GET_BOOL, NO_ARG, 1,
0, 0, 0, 0, 0},
{"add-drop-table", OPT_DROP, "Add a 'drop table' before each create.",
(gptr*) &opt_drop, (gptr*) &opt_drop, 0, GET_BOOL, NO_ARG, 1, 0, 0, 0, 0,
0},
@ -148,7 +146,7 @@ static struct my_option my_long_options[] =
"Directory where character sets are.", (gptr*) &charsets_dir,
(gptr*) &charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
{"compatible", OPT_COMPATIBLE,
"Change the dump to be compatible with a given mode. By default tables are dumped without any restrictions. Legal modes are: ansi, mysql323, mysql40, postgresql, oracle, mssql, db2, maxdb, no_key_options, no_table_options, no_field_options. One can use several modes separated by commas. Note: Requires MySQL server version 4.1.0 or higher. This option does a no operation on earlier server versions.",
"Change the dump to be compatible with a given mode. By default tables are dumped in a format optimized for MySQL. Legal modes are: ansi, mysql323, mysql40, postgresql, oracle, mssql, db2, maxdb, no_key_options, no_table_options, no_field_options. One can use several modes separated by commas. Note: Requires MySQL server version 4.1.0 or higher. This option is ignored with earlier server versions.",
(gptr*) &opt_compatible_mode_str, (gptr*) &opt_compatible_mode_str, 0,
GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
{"compact", OPT_COMPACT,
@ -160,12 +158,21 @@ static struct my_option my_long_options[] =
{"compress", 'C', "Use compression in server/client protocol.",
(gptr*) &opt_compress, (gptr*) &opt_compress, 0, GET_BOOL, NO_ARG, 0, 0, 0,
0, 0, 0},
{"create-options", OPT_CREATE_OPTIONS,
"Include all MySQL specific create options.",
(gptr*) &create_options, (gptr*) &create_options, 0, GET_BOOL, NO_ARG, 1,
0, 0, 0, 0, 0},
{"databases", 'B',
"To dump several databases. Note the difference in usage; In this case no tables are given. All name arguments are regarded as databasenames. 'USE db_name;' will be included in the output.",
(gptr*) &opt_databases, (gptr*) &opt_databases, 0, GET_BOOL, NO_ARG, 0, 0,
0, 0, 0, 0},
{"debug", '#', "Output debug log. Often this is 'd:t:o,filename'.",
0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
#ifdef DBUG_OFF
{"debug", '#', "This is a non-debug version. Catch this and exit",
0,0, 0, GET_DISABLED, OPT_ARG, 0, 0, 0, 0, 0, 0},
#else
{"debug", '#', "Output debug log", (gptr*) &default_dbug_option,
(gptr*) &default_dbug_option, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
#endif
{"default-character-set", OPT_DEFAULT_CHARSET,
"Set the default character set.", (gptr*) &default_charset,
(gptr*) &default_charset, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
@ -463,7 +470,7 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
opt_disable_keys=0;
break;
case '#':
DBUG_PUSH(argument ? argument : "d:t:o");
DBUG_PUSH(argument ? argument : default_dbug_option);
break;
#include <sslopt-case.h>
case 'V': print_version(); exit(0);
@ -483,7 +490,7 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
break;
case (int) OPT_SKIP_OPTIMIZATION:
extended_insert= opt_drop= opt_lock= quick= create_options=
opt_disable_keys= lock_tables= 0;
opt_disable_keys= lock_tables= opt_set_charset= 0;
break;
case (int) OPT_COMPACT:
if (opt_compact)
@ -859,11 +866,11 @@ static void print_xml_row(FILE *xml_file, const char *row_name,
{
if ((*row)[i])
{
fputs(" ", xml_file);
fputc(' ', xml_file);
print_quoted_xml(xml_file, field->name, field->name_length);
fputs("=\"", xml_file);
print_quoted_xml(xml_file, (*row)[i], lengths[i]);
fputs("\"", xml_file);
fputc('"', xml_file);
}
}
fputs(" />\n", xml_file);
@ -897,6 +904,9 @@ static uint getTableStructure(char *table, char* db)
sprintf(insert_pat,"SET OPTION SQL_QUOTE_SHOW_CREATE=%d",
(opt_quoted || opt_keywords));
if (!create_options)
strmov(strend(insert_pat), "/*!40102 ,SQL_MODE=concat(@@sql_mode, _utf8 'NO_KEY_OPTIONS,NO_TABLE_OPTIONS,NO_FIELD_OPTIONS') */");
result_table= quote_name(table, table_buff, 1);
opt_quoted_table= quote_name(table, table_buff2, 0);
if (!opt_xml && !mysql_query(sock,insert_pat))
@ -978,8 +988,10 @@ static uint getTableStructure(char *table, char* db)
}
else
{
/* fprintf(stderr, "%s: Can't set SQL_QUOTE_SHOW_CREATE option (%s)\n",
my_progname, mysql_error(sock)); */
if (verbose)
fprintf(stderr,
"%s: Warning: Can't set SQL_QUOTE_SHOW_CREATE option (%s)\n",
my_progname, mysql_error(sock));
sprintf(insert_pat,"show fields from %s", result_table);
if (mysql_query(sock,insert_pat) || !(tableRes=mysql_store_result(sock)))
@ -1172,7 +1184,7 @@ static uint getTableStructure(char *table, char* db)
else
{
fputs("/*!",sql_file);
print_value(sql_file,tableRes,row,"type=","Type",0);
print_value(sql_file,tableRes,row,"engine=","Engine",0);
print_value(sql_file,tableRes,row,"","Create_options",0);
print_value(sql_file,tableRes,row,"comment=","Comment",1);
fputs(" */",sql_file);
@ -1413,12 +1425,12 @@ static void dumpTable(uint numFields, char *table)
fputs("Aborting dump (out of memory)",stderr);
safe_exit(EX_EOM);
}
dynstr_append(&extended_row,"\'");
dynstr_append(&extended_row,"'");
extended_row.length +=
mysql_real_escape_string(&mysql_connection,
&extended_row.str[extended_row.length],row[i],length);
extended_row.str[extended_row.length]='\0';
dynstr_append(&extended_row,"\'");
dynstr_append(&extended_row,"'");
}
else
{
@ -1432,9 +1444,9 @@ static void dumpTable(uint numFields, char *table)
if (field->type == FIELD_TYPE_DECIMAL)
{
/* add " signs around */
dynstr_append(&extended_row, "\"");
dynstr_append(&extended_row, "'");
dynstr_append(&extended_row, ptr);
dynstr_append(&extended_row, "\"");
dynstr_append(&extended_row, "'");
}
else
dynstr_append(&extended_row, ptr);
@ -1442,7 +1454,7 @@ static void dumpTable(uint numFields, char *table)
}
}
else
dynstr_append(&extended_row,"\'\'");
dynstr_append(&extended_row,"''");
}
else if (dynstr_append(&extended_row,"NULL"))
{
@ -1486,9 +1498,9 @@ static void dumpTable(uint numFields, char *table)
else if (field->type == FIELD_TYPE_DECIMAL)
{
/* add " signs around */
fputs("\"", md_result_file);
fputc('\'', md_result_file);
fputs(ptr, md_result_file);
fputs("\"", md_result_file);
fputc('\'', md_result_file);
}
else
fputs(ptr, md_result_file);

5
configure.in
View File

@ -2228,7 +2228,6 @@ if expr "$SYSTEM_TYPE" : ".*netware.*" > /dev/null; then
# For NetWare, do not need readline
echo "Skipping readline"
else
mkdir include/readline
if [test "$with_libedit" = "yes"] || [test "$with_libedit" = "undefined"] && [test "$with_readline" = "undefined"]
then
@ -2236,7 +2235,7 @@ then
readline_basedir="libedit"
readline_dir="$readline_topdir/$readline_basedir"
readline_link="\$(top_builddir)/cmd-line-utils/libedit/liblibedit.a"
readline_h_ln_cmd="\$(LN) \$(top_builddir)/cmd-line-utils/libedit/readline/*.h readline/"
readline_h_ln_cmd="\$(LN) -s \$(top_builddir)/cmd-line-utils/libedit/readline readline"
compile_libedit=yes
AC_DEFINE_UNQUOTED(USE_LIBEDIT_INTERFACE)
elif test "$with_readline" = "yes"
@ -2245,7 +2244,7 @@ then
readline_basedir="readline"
readline_dir="$readline_topdir/$readline_basedir"
readline_link="\$(top_builddir)/cmd-line-utils/readline/libreadline.a"
readline_h_ln_cmd="\$(LN) \$(top_builddir)/cmd-line-utils/readline/*.h readline/"
readline_h_ln_cmd="\$(LN) -s \$(top_builddir)/cmd-line-utils/readline readline"
compile_readline=yes
AC_DEFINE_UNQUOTED(USE_NEW_READLINE_INTERFACE)
else

8
include/Makefile.am
View File

@ -39,23 +39,23 @@ SUPERCLEANFILES = mysql_version.h my_config.h
DISTCLEANFILES = sched.h $(SUPERCLEANFILES)
clean:
$(RM) -f readline/*
$(RM) -fr readline
distclean:
$(RM) -f readline/*
$(RM) -fr readline
all-local: my_config.h
# Since we include my_config.h it better exist from the beginning
link_sources:
$(CP) ../config.h my_config.h
$(RM) -f readline/*
-$(RM) -fr readline
@readline_h_ln_cmd@
# Keep automake happy
my_config.h: ../config.h
$(CP) ../config.h my_config.h
$(RM) -f readline/*
-$(RM) -fr readline
@readline_h_ln_cmd@
# These files should not be included in distributions since they are

2
include/m_ctype.h
View File

@ -90,7 +90,7 @@ enum my_lex_states
MY_LEX_CMP_OP, MY_LEX_LONG_CMP_OP, MY_LEX_STRING, MY_LEX_COMMENT, MY_LEX_END,
MY_LEX_OPERATOR_OR_IDENT, MY_LEX_NUMBER_IDENT, MY_LEX_INT_OR_REAL,
MY_LEX_REAL_OR_POINT, MY_LEX_BOOL, MY_LEX_EOL, MY_LEX_ESCAPE,
MY_LEX_LONG_COMMENT, MY_LEX_END_LONG_COMMENT, MY_LEX_COLON,
MY_LEX_LONG_COMMENT, MY_LEX_END_LONG_COMMENT, MY_LEX_SEMICOLON,
MY_LEX_SET_VAR, MY_LEX_USER_END, MY_LEX_HOSTNAME, MY_LEX_SKIP,
MY_LEX_USER_VARIABLE_DELIMITER, MY_LEX_SYSTEM_VAR,
MY_LEX_IDENT_OR_KEYWORD,

3
include/my_base.h
View File

@ -287,6 +287,9 @@ enum ha_base_keytype {
#define HA_ERR_ROW_IS_REFERENCED 152 /* Cannot delete a parent row */
#define HA_ERR_NO_SAVEPOINT 153 /* No savepoint with that name */
#define HA_ERR_NON_UNIQUE_BLOCK_SIZE 154 /* Non unique key block size */
#define HA_ERR_OLD_METADATA 155 /* The frm file on disk is old */
#define HA_ERR_TABLE_EXIST 156 /* The table existed in storage engine */
#define HA_ERR_NO_CONNECTION 157 /* Could not connect to storage engine */
/* Other constants */

2
include/myisam.h
View File

@ -36,7 +36,7 @@ extern "C" {
/* defines used by myisam-funktions */
/* The following defines can be increased if necessary */
#define MI_MAX_KEY 32 /* Max allowed keys */
#define MI_MAX_KEY 64 /* Max allowed keys */
#define MI_MAX_KEY_SEG 16 /* Max segments for key */
#define MI_MAX_KEY_LENGTH 1000

1
include/mysql_embed.h
View File

@ -26,6 +26,7 @@
#undef HAVE_OPENSSL
#undef HAVE_ISAM
#undef HAVE_SMEM /* No shared memory */
#undef HAVE_NDBCLUSTER_DB /* No NDB cluster */
#define DONT_USE_RAID

268
innobase/btr/btr0btr.c
View File

@ -589,28 +589,29 @@ btr_page_get_father_for_rec(
if (btr_node_ptr_get_child_page_no(node_ptr) !=
buf_frame_get_page_no(page)) {
fprintf(stderr,
"InnoDB: Dump of the child page:\n");
fputs("InnoDB: Dump of the child page:\n", stderr);
buf_page_print(buf_frame_align(page));
fprintf(stderr,
"InnoDB: Dump of the parent page:\n");
fputs("InnoDB: Dump of the parent page:\n", stderr);
buf_page_print(buf_frame_align(node_ptr));
fprintf(stderr,
"InnoDB: Corruption of an index tree: table %s, index %s,\n"
fputs("InnoDB: Corruption of an index tree: table ", stderr);
ut_print_name(stderr,
UT_LIST_GET_FIRST(tree->tree_indexes)->table_name);
fputs(", index ", stderr);
ut_print_name(stderr,
UT_LIST_GET_FIRST(tree->tree_indexes)->name);
fprintf(stderr, ",\n"
"InnoDB: father ptr page no %lu, child page no %lu\n",
(UT_LIST_GET_FIRST(tree->tree_indexes))->table_name,
(UT_LIST_GET_FIRST(tree->tree_indexes))->name,
(unsigned long) btr_node_ptr_get_child_page_no(node_ptr),
(unsigned long) buf_frame_get_page_no(page));
(ulong) btr_node_ptr_get_child_page_no(node_ptr),
(ulong) buf_frame_get_page_no(page));
page_rec_print(page_rec_get_next(page_get_infimum_rec(page)));
page_rec_print(node_ptr);
fprintf(stderr,
fputs(
"InnoDB: You should dump + drop + reimport the table to fix the\n"
"InnoDB: corruption. If the crash happens at the database startup, see\n"
"InnoDB: section 6.1 of http://www.innodb.com/ibman.html about forcing\n"
"InnoDB: recovery. Then dump + drop + reimport.\n");
"InnoDB: section 6.1 of http://www.innodb.com/ibman.php about forcing\n"
"InnoDB: recovery. Then dump + drop + reimport.\n", stderr);
}
ut_a(btr_node_ptr_get_child_page_no(node_ptr) ==
@ -1053,7 +1054,7 @@ btr_root_raise_and_insert(
/* We play safe and reset the free bits for the new page */
/* printf("Root raise new page no %lu\n",
/* fprintf(stderr, "Root raise new page no %lu\n",
buf_frame_get_page_no(new_page)); */
ibuf_reset_free_bits(UT_LIST_GET_FIRST(tree->tree_indexes),
@ -1602,7 +1603,7 @@ func_start:
/* 5. Move then the records to the new page */
if (direction == FSP_DOWN) {
/* printf("Split left\n"); */
/* fputs("Split left\n", stderr); */
page_move_rec_list_start(new_page, page, move_limit, mtr);
left_page = new_page;
@ -1610,7 +1611,7 @@ func_start:
lock_update_split_left(right_page, left_page);
} else {
/* printf("Split right\n"); */
/* fputs("Split right\n", stderr); */
page_move_rec_list_end(new_page, page, move_limit, mtr);
left_page = page;
@ -1646,7 +1647,7 @@ func_start:
ibuf_update_free_bits_for_two_pages_low(cursor->index,
left_page,
right_page, mtr);
/* printf("Split and insert done %lu %lu\n",
/* fprintf(stderr, "Split and insert done %lu %lu\n",
buf_frame_get_page_no(left_page),
buf_frame_get_page_no(right_page)); */
return(rec);
@ -1666,7 +1667,7 @@ func_start:
/* We play safe and reset the free bits for new_page */
ibuf_reset_free_bits(cursor->index, new_page);
/* printf("Split second round %lu\n",
/* fprintf(stderr, "Split second round %lu\n",
buf_frame_get_page_no(page)); */
n_iterations++;
ut_ad(n_iterations < 2);
@ -1680,7 +1681,7 @@ func_start:
ibuf_update_free_bits_for_two_pages_low(cursor->index, left_page,
right_page, mtr);
/* printf("Split and insert done %lu %lu\n",
/* fprintf(stderr, "Split and insert done %lu %lu\n",
buf_frame_get_page_no(left_page),
buf_frame_get_page_no(right_page)); */
@ -1927,7 +1928,7 @@ btr_compress(
left_page_no = btr_page_get_prev(page, mtr);
right_page_no = btr_page_get_next(page, mtr);
/* printf("Merge left page %lu right %lu \n", left_page_no,
/* fprintf(stderr, "Merge left page %lu right %lu \n", left_page_no,
right_page_no); */
node_ptr = btr_page_get_father_node_ptr(tree, page, mtr);
@ -2164,6 +2165,7 @@ btr_discard_page(
ut_ad(btr_check_node_ptr(tree, merge_page, mtr));
}
#ifdef UNIV_DEBUG
/*****************************************************************
Prints size info of a B-tree. */
@ -2177,8 +2179,9 @@ btr_print_size(
mtr_t mtr;
if (tree->type & DICT_IBUF) {
printf(
"Sorry, cannot print info of an ibuf tree: use ibuf functions\n");
fputs(
"Sorry, cannot print info of an ibuf tree: use ibuf functions\n",
stderr);
return;
}
@ -2189,14 +2192,14 @@ btr_print_size(
seg = root + PAGE_HEADER + PAGE_BTR_SEG_TOP;
printf("INFO OF THE NON-LEAF PAGE SEGMENT\n");
fputs("INFO OF THE NON-LEAF PAGE SEGMENT\n", stderr);
fseg_print(seg, &mtr);
if (!(tree->type & DICT_UNIVERSAL)) {
seg = root + PAGE_HEADER + PAGE_BTR_SEG_LEAF;
printf("INFO OF THE LEAF PAGE SEGMENT\n");
fputs("INFO OF THE LEAF PAGE SEGMENT\n", stderr);
fseg_print(seg, &mtr);
}
@ -2224,7 +2227,7 @@ btr_print_recursive(
ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
MTR_MEMO_PAGE_X_FIX));
printf("NODE ON LEVEL %lu page number %lu\n",
fprintf(stderr, "NODE ON LEVEL %lu page number %lu\n",
(ulong) btr_page_get_level(page, mtr),
(ulong) buf_frame_get_page_no(page));
@ -2271,8 +2274,8 @@ btr_print_tree(
mtr_t mtr;
page_t* root;
printf("--------------------------\n");
printf("INDEX TREE PRINT\n");
fputs("--------------------------\n"
"INDEX TREE PRINT\n", stderr);
mtr_start(&mtr);
@ -2284,6 +2287,7 @@ btr_print_tree(
btr_validate_tree(tree);
}
#endif /* UNIV_DEBUG */
/****************************************************************
Checks that the node pointer to a page is appropriate. */
@ -2328,6 +2332,22 @@ btr_check_node_ptr(
return(TRUE);
}
/****************************************************************
Display identification information for a record. */
static
void
btr_index_rec_validate_report(
/*==========================*/
page_t* page, /* in: index page */
rec_t* rec, /* in: index record */
dict_index_t* index) /* in: index */
{
fputs("InnoDB: Record in ", stderr);
dict_index_name_print(stderr, index);
fprintf(stderr, ", page %lu, at offset %lu\n",
buf_frame_get_page_no(page), (ulint)(rec - page));
}
/****************************************************************
Checks the size and number of fields in a record based on the definition of
the index. */
@ -2342,13 +2362,10 @@ btr_index_rec_validate(
should print hex dump of record
and page on error */
{
dtype_t* type;
byte* data;
ulint len;
ulint n;
ulint i;
page_t* page;
char err_buf[1000];
page = buf_frame_align(rec);
@ -2363,14 +2380,9 @@ btr_index_rec_validate(
n = dict_index_get_n_fields(index);
if (rec_get_n_fields(rec) != n) {
fprintf(stderr,
"InnoDB: Record in index %s in table %s, page %lu, at offset %lu\n"
"InnoDB: has %lu fields, should have %lu\n",
index->name, index->table_name,
(unsigned long) buf_frame_get_page_no(page),
(unsigned long) (rec - page),
(unsigned long) rec_get_n_fields(rec),
(unsigned long) n);
btr_index_rec_validate_report(page, rec, index);
fprintf(stderr, "InnoDB: has %lu fields, should have %lu\n",
(ulong) rec_get_n_fields(rec), (ulong) n);
if (!dump_on_error) {
@ -2379,16 +2391,17 @@ btr_index_rec_validate(
buf_page_print(page);
rec_sprintf(err_buf, 900, rec);
fprintf(stderr, "InnoDB: corrupt record %s\n", err_buf);
fputs("InnoDB: corrupt record ", stderr);
rec_print(stderr, rec);
putc('\n', stderr);
return(FALSE);
}
for (i = 0; i < n; i++) {
data = rec_get_nth_field(rec, i, &len);
dtype_t* type = dict_index_get_nth_type(index, i);
type = dict_index_get_nth_type(index, i);
rec_get_nth_field(rec, i, &len);
if ((dict_index_get_nth_field(index, i)->prefix_len == 0
&& len != UNIV_SQL_NULL && dtype_is_fixed_size(type)
@ -2399,15 +2412,10 @@ btr_index_rec_validate(
&& len !=
dict_index_get_nth_field(index, i)->prefix_len)) {
btr_index_rec_validate_report(page, rec, index);
fprintf(stderr,
"InnoDB: Record in index %s in table %s, page %lu, at offset %lu\n"
"InnoDB: field %lu len is %lu, should be %lu\n",
index->name, index->table_name,
(unsigned long) buf_frame_get_page_no(page),
(unsigned long) (rec - page),
(unsigned long) i,
(unsigned long) len,
(unsigned long) dtype_get_fixed_size(type));
(ulong) i, (ulong) len, (ulong) dtype_get_fixed_size(type));
if (!dump_on_error) {
@ -2416,9 +2424,9 @@ btr_index_rec_validate(
buf_page_print(page);
rec_sprintf(err_buf, 900, rec);
fprintf(stderr,
"InnoDB: corrupt record %s\n", err_buf);
fputs("InnoDB: corrupt record ", stderr);
rec_print(stderr, rec);
putc('\n', stderr);
return(FALSE);
}
@ -2438,7 +2446,6 @@ btr_index_page_validate(
page_t* page, /* in: index page */
dict_index_t* index) /* in: index */
{
rec_t* rec;
page_cur_t cur;
ibool ret = TRUE;
@ -2446,14 +2453,12 @@ btr_index_page_validate(
page_cur_move_to_next(&cur);
for (;;) {
rec = (&cur)->rec;
if (page_cur_is_after_last(&cur)) {
break;
}
if (!btr_index_rec_validate(rec, index, TRUE)) {
if (!btr_index_rec_validate(cur.rec, index, TRUE)) {
return(FALSE);
}
@ -2464,6 +2469,46 @@ btr_index_page_validate(
return(ret);
}
/****************************************************************
Report an error on one page of an index tree. */
static
void
btr_validate_report1(
/* out: TRUE if ok */
dict_index_t* index, /* in: index */
ulint level, /* in: B-tree level */
page_t* page) /* in: index page */
{
fprintf(stderr, "InnoDB: Error in page %lu of ",
buf_frame_get_page_no(page));
dict_index_name_print(stderr, index);
if (level) {
fprintf(stderr, ", index tree level %lu", level);
}
putc('\n', stderr);
}
/****************************************************************
Report an error on two pages of an index tree. */
static
void
btr_validate_report2(
/* out: TRUE if ok */
dict_index_t* index, /* in: index */
ulint level, /* in: B-tree level */
page_t* page1, /* in: first index page */
page_t* page2) /* in: second index page */
{
fprintf(stderr, "InnoDB: Error in pages %lu and %lu of ",
buf_frame_get_page_no(page1),
buf_frame_get_page_no(page2));
dict_index_name_print(stderr, index);
if (level) {
fprintf(stderr, ", index tree level %lu", level);
}
putc('\n', stderr);
}
/****************************************************************
Validates index tree level. */
static
@ -2489,7 +2534,6 @@ btr_validate_level(
ibool ret = TRUE;
dict_index_t* index;
mtr_t mtr;
char err_buf[1000];
mtr_start(&mtr);
@ -2520,10 +2564,7 @@ loop:
/* Check ordering etc. of records */
if (!page_validate(page, index)) {
fprintf(stderr,
"InnoDB: Error in page %lu in index %s table %s, index tree level %lu\n",
(ulong) buf_frame_get_page_no(page), index->name,
index->table_name, (ulong) level);
btr_validate_report1(index, level, page);
ret = FALSE;
} else if (level == 0) {
@ -2553,25 +2594,22 @@ loop:
page_rec_get_next(page_get_infimum_rec(right_page)),
UT_LIST_GET_FIRST(tree->tree_indexes)) >= 0) {
fprintf(stderr,
"InnoDB: Error on pages %lu and %lu in index %s table %s\n",
(ulong) buf_frame_get_page_no(page),
(ulong) right_page_no,
index->name, index->table_name);
btr_validate_report2(index, level, page, right_page);
fprintf(stderr,
"InnoDB: records in wrong order on adjacent pages\n");
fputs("InnoDB: records in wrong order"
" on adjacent pages\n", stderr);
buf_page_print(page);
buf_page_print(right_page);
rec_sprintf(err_buf, 900,
page_rec_get_prev(page_get_supremum_rec(page)));
fprintf(stderr, "InnoDB: record %s\n", err_buf);
rec_sprintf(err_buf, 900,
page_rec_get_next(page_get_infimum_rec(right_page)));
fprintf(stderr, "InnoDB: record %s\n", err_buf);
fputs("InnoDB: record ", stderr);
rec_print(stderr, page_rec_get_prev(
page_get_supremum_rec(page)));
putc('\n', stderr);
fputs("InnoDB: record ", stderr);
rec_print(stderr, page_rec_get_next(
page_get_infimum_rec(right_page)));
putc('\n', stderr);
ret = FALSE;
}
@ -2594,32 +2632,27 @@ loop:
|| node_ptr != btr_page_get_father_for_rec(tree, page,
page_rec_get_prev(page_get_supremum_rec(page)),
&mtr)) {
fprintf(stderr,
"InnoDB: Error on page %lu in index %s table %s\n",
(unsigned long) buf_frame_get_page_no(page),
index->name, index->table_name);
btr_validate_report1(index, level, page);
fprintf(stderr,
"InnoDB: node pointer to the page is wrong\n");
fputs("InnoDB: node pointer to the page is wrong\n",
stderr);
buf_page_print(father_page);
buf_page_print(page);
rec_sprintf(err_buf, 900, node_ptr);
fputs("InnoDB: node ptr ", stderr);
rec_print(stderr, node_ptr);
fprintf(stderr, "InnoDB: node ptr %s\n", err_buf);
fprintf(stderr,
fprintf(stderr, "\n"
"InnoDB: node ptr child page n:o %lu\n",
(unsigned long) btr_node_ptr_get_child_page_no(node_ptr));
rec_sprintf(err_buf, 900,
fputs("InnoDB: record on page ", stderr);
rec_print(stderr,
btr_page_get_father_for_rec(tree, page,
page_rec_get_prev(page_get_supremum_rec(page)),
&mtr));
fprintf(stderr, "InnoDB: record on page %s\n",
err_buf);
putc('\n', stderr);
ret = FALSE;
goto node_ptr_fails;
@ -2637,27 +2670,19 @@ loop:
if (cmp_dtuple_rec(node_ptr_tuple, node_ptr) != 0) {
fprintf(stderr,
"InnoDB: Error on page %lu in index %s table %s\n",
(ulong) buf_frame_get_page_no(page),
index->name, index->table_name);
btr_validate_report1(index, level, page);
buf_page_print(father_page);
buf_page_print(page);
fprintf(stderr,
"InnoDB: Error: node ptrs differ on levels > 0\n");
rec_sprintf(err_buf, 900, node_ptr);
fprintf(stderr, "InnoDB: node ptr %s\n",
err_buf);
rec_sprintf(err_buf, 900,
page_rec_get_next(
fputs("InnoDB: Error: node ptrs differ"
" on levels > 0\n"
"InnoDB: node ptr ", stderr);
rec_print(stderr, node_ptr);
fputs("InnoDB: first rec ", stderr);
rec_print(stderr, page_rec_get_next(
page_get_infimum_rec(page)));
fprintf(stderr, "InnoDB: first rec %s\n",
err_buf);
putc('\n', stderr);
ret = FALSE;
mem_heap_free(heap);
@ -2689,13 +2714,12 @@ loop:
if (right_node_ptr !=
page_rec_get_next(node_ptr)) {
ret = FALSE;
fprintf(stderr,
"InnoDB: node pointer to the right page is wrong\n");
fputs(
"InnoDB: node pointer to the right page is wrong\n",
stderr);
fprintf(stderr,
"InnoDB: Error on page %lu in index %s table %s\n",
(unsigned long) buf_frame_get_page_no(page),
index->name, index->table_name);
btr_validate_report1(index, level,
page);
buf_page_print(father_page);
buf_page_print(page);
@ -2709,13 +2733,12 @@ loop:
page_get_infimum_rec(
right_father_page))) {
ret = FALSE;
fprintf(stderr,
"InnoDB: node pointer 2 to the right page is wrong\n");
fputs(
"InnoDB: node pointer 2 to the right page is wrong\n",
stderr);
fprintf(stderr,
"InnoDB: Error on page %lu in index %s table %s\n",
(unsigned long) buf_frame_get_page_no(page),
index->name, index->table_name);
btr_validate_report1(index, level,
page);
buf_page_print(father_page);
buf_page_print(right_father_page);
@ -2727,13 +2750,12 @@ loop:
!= btr_page_get_next(father_page, &mtr)) {
ret = FALSE;
fprintf(stderr,
"InnoDB: node pointer 3 to the right page is wrong\n");
fputs(
"InnoDB: node pointer 3 to the right page is wrong\n",
stderr);
fprintf(stderr,
"InnoDB: Error on page %lu in index %s table %s\n",
(unsigned long) buf_frame_get_page_no(page),
index->name, index->table_name);
btr_validate_report1(index, level,
page);
buf_page_print(father_page);
buf_page_print(right_father_page);

121
innobase/btr/btr0cur.c
View File

@ -120,7 +120,6 @@ static
void
btr_cur_latch_leaves(
/*=================*/
dict_tree_t* tree __attribute__((unused)), /* in: index tree */
page_t* page, /* in: leaf page where the search
converged */
ulint space, /* in: space id */
@ -133,7 +132,7 @@ btr_cur_latch_leaves(
ulint right_page_no;
page_t* get_page;
ut_ad(tree && page && mtr);
ut_ad(page && mtr);
if (latch_mode == BTR_SEARCH_LEAF) {
@ -366,17 +365,19 @@ btr_cur_search_to_nth_level(
B-tree. These let us end up in the right B-tree leaf. In that leaf
we use the original search mode. */
if (mode == PAGE_CUR_GE) {
switch (mode) {
case PAGE_CUR_GE:
page_mode = PAGE_CUR_L;
} else if (mode == PAGE_CUR_G) {
break;
case PAGE_CUR_G:
page_mode = PAGE_CUR_LE;
} else if (mode == PAGE_CUR_LE) {
page_mode = PAGE_CUR_LE;
} else if (mode == PAGE_CUR_LE_OR_EXTENDS) {
page_mode = PAGE_CUR_LE_OR_EXTENDS;
} else {
ut_ad(mode == PAGE_CUR_L);
page_mode = PAGE_CUR_L;
break;
default:
ut_ad(mode == PAGE_CUR_L
|| mode == PAGE_CUR_LE
|| mode == PAGE_CUR_LE_OR_EXTENDS);
page_mode = mode;
break;
}
/* Loop and search until we arrive at the desired level */
@ -451,7 +452,7 @@ retry_page_get:
if (height == 0) {
if (rw_latch == RW_NO_LATCH) {
btr_cur_latch_leaves(tree, page, space,
btr_cur_latch_leaves(page, space,
page_no, latch_mode, cursor,
mtr);
}
@ -478,6 +479,9 @@ retry_page_get:
/* If this is the desired level, leave the loop */
ut_ad(height
== btr_page_get_level(page_cur_get_page(page_cursor), mtr));
if (level == height) {
if (level > 0) {
@ -591,7 +595,7 @@ btr_cur_open_at_index_side(
}
if (height == 0) {
btr_cur_latch_leaves(tree, page, space, page_no,
btr_cur_latch_leaves(page, space, page_no,
latch_mode, cursor, mtr);
/* In versions <= 3.23.52 we had forgotten to
@ -697,7 +701,7 @@ btr_cur_open_at_rnd_pos(
}
if (height == 0) {
btr_cur_latch_leaves(tree, page, space, page_no,
btr_cur_latch_leaves(page, space, page_no,
latch_mode, cursor, mtr);
}
@ -829,6 +833,24 @@ btr_cur_ins_lock_and_undo(
return(DB_SUCCESS);
}
/*****************************************************************
Report information about a transaction. */
static
void
btr_cur_trx_report(
/*===============*/
const trx_t* trx, /* in: transaction */
const dict_index_t* index, /* in: index */
const char* op) /* in: operation */
{
fprintf(stderr, "Trx with id %lu %lu going to ",
ut_dulint_get_high(trx->id),
ut_dulint_get_low(trx->id));
fputs(op, stderr);
dict_index_name_print(stderr, index);
putc('\n', stderr);
}
/*****************************************************************
Tries to perform an insert to a page in an index tree, next to cursor.
It is assumed that mtr holds an x-latch on the page. The operation does
@ -876,18 +898,13 @@ btr_cur_optimistic_insert(
index = cursor->index;
if (!dtuple_check_typed_no_assert(entry)) {
fprintf(stderr,
"InnoDB: Error in a tuple to insert into table %s index %s\n",
index->table_name, index->name);
fputs("InnoDB: Error in a tuple to insert into ", stderr);
dict_index_name_print(stderr, index);
}
if (btr_cur_print_record_ops && thr) {
printf(
"Trx with id %lu %lu going to insert to table %s index %s\n",
(unsigned long) ut_dulint_get_high(thr_get_trx(thr)->id),
(unsigned long) ut_dulint_get_low(thr_get_trx(thr)->id),
index->table_name, index->name);
dtuple_print(entry);
btr_cur_trx_report(thr_get_trx(thr), index, "insert into ");
dtuple_print(stderr, entry);
}
ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
@ -980,21 +997,15 @@ calculate_sizes_again:
*rec = page_cur_tuple_insert(page_cursor, entry, mtr);
if (!(*rec)) {
char* err_buf = mem_alloc(1000);
dtuple_sprintf(err_buf, 900, entry);
fprintf(stderr,
"InnoDB: Error: cannot insert tuple %s to index %s of table %s\n"
"InnoDB: max insert size %lu\n",
err_buf, index->name, index->table->name,
(unsigned long) max_size);
mem_free(err_buf);
if (!*rec) {
fputs("InnoDB: Error: cannot insert tuple ", stderr);
dtuple_print(stderr, entry);
fputs(" into ", stderr);
dict_index_name_print(stderr, index);
fprintf(stderr, "\nInnoDB: max insert size %lu\n",
(ulong) max_size);
ut_error;
}
ut_a(*rec); /* <- We calculated above the record would fit */
}
#ifdef BTR_CUR_HASH_ADAPT
@ -1010,7 +1021,8 @@ calculate_sizes_again:
lock_update_insert(*rec);
}
/* printf("Insert to page %lu, max ins size %lu, rec %lu ind type %lu\n",
/* fprintf(stderr, "Insert into page %lu, max ins size %lu,"
" rec %lu ind type %lu\n",
buf_frame_get_page_no(page), max_size,
rec_size + PAGE_DIR_SLOT_SIZE, type);
*/
@ -1363,12 +1375,8 @@ btr_cur_update_in_place(
trx = thr_get_trx(thr);
if (btr_cur_print_record_ops && thr) {
printf(
"Trx with id %lu %lu going to update table %s index %s\n",
(unsigned long) ut_dulint_get_high(thr_get_trx(thr)->id),
(unsigned long) ut_dulint_get_low(thr_get_trx(thr)->id),
index->table_name, index->name);
rec_print(rec);
btr_cur_trx_report(trx, index, "update ");
rec_print(stderr, rec);
}
/* Do lock checking and undo logging */
@ -1467,12 +1475,8 @@ btr_cur_optimistic_update(
index = cursor->index;
if (btr_cur_print_record_ops && thr) {
printf(
"Trx with id %lu %lu going to update table %s index %s\n",
(unsigned long) ut_dulint_get_high(thr_get_trx(thr)->id),
(unsigned long) ut_dulint_get_low(thr_get_trx(thr)->id),
index->table_name, index->name);
rec_print(rec);
btr_cur_trx_report(thr_get_trx(thr), index, "update ");
rec_print(stderr, rec);
}
ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
@ -2016,12 +2020,8 @@ btr_cur_del_mark_set_clust_rec(
index = cursor->index;
if (btr_cur_print_record_ops && thr) {
printf(
"Trx with id %lu %lu going to del mark table %s index %s\n",
(unsigned long) ut_dulint_get_high(thr_get_trx(thr)->id),
(unsigned long) ut_dulint_get_low(thr_get_trx(thr)->id),
index->table_name, index->name);
rec_print(rec);
btr_cur_trx_report(thr_get_trx(thr), index, "del mark ");
rec_print(stderr, rec);
}
ut_ad(index->type & DICT_CLUSTERED);
@ -2156,12 +2156,9 @@ btr_cur_del_mark_set_sec_rec(
rec = btr_cur_get_rec(cursor);
if (btr_cur_print_record_ops && thr) {
printf(
"Trx with id %lu %lu going to del mark table %s index %s\n",
(unsigned long) ut_dulint_get_high(thr_get_trx(thr)->id),
(unsigned long) ut_dulint_get_low(thr_get_trx(thr)->id),
cursor->index->table_name, cursor->index->name);
rec_print(rec);
btr_cur_trx_report(thr_get_trx(thr), cursor->index,
"del mark ");
rec_print(stderr, rec);
}
err = lock_sec_rec_modify_check_and_lock(flags, rec, cursor->index,

46
innobase/btr/btr0sea.c
View File

@ -803,7 +803,7 @@ btr_search_guess_on_hash(
success = FALSE;
/*
printf("Tree id %lu, page index id %lu fold %lu\n",
fprintf(stderr, "Tree id %lu, page index id %lu fold %lu\n",
ut_dulint_get_low(tree_id),
ut_dulint_get_low(btr_page_get_index_id(page)),
fold);
@ -1517,8 +1517,9 @@ check_next_rec:
ha_insert_for_fold(table, ins_fold, ins_rec);
/*
printf("Hash insert for %s, fold %lu\n",
cursor->index->name, ins_fold);
fputs("Hash insert for ", stderr);
dict_index_name_print(stderr, cursor->index);
fprintf(stderr, " fold %lu\n", ins_fold);
*/
} else {
ha_insert_for_fold(table, next_fold, next_rec);
@ -1545,7 +1546,6 @@ btr_search_validate(void)
ulint n_page_dumps = 0;
ibool ok = TRUE;
ulint i;
char rec_str[500];
rw_lock_x_lock(&btr_search_latch);
@ -1566,29 +1566,25 @@ btr_search_validate(void)
fprintf(stderr,
" InnoDB: Error in an adaptive hash index pointer to page %lu\n"
"ptr mem address %lu index id %lu %lu, node fold %lu, rec fold %lu\n",
(ulong) buf_frame_get_page_no(page),
(ulong)(node->data),
(ulong) ut_dulint_get_high(btr_page_get_index_id(page)),
(ulong) ut_dulint_get_low(btr_page_get_index_id(page)),
(ulong) node->fold,
(ulong) rec_fold((rec_t*)(node->data),
block->curr_n_fields,
block->curr_n_bytes,
btr_page_get_index_id(page)));
"ptr mem address %p index id %lu %lu, node fold %lu, rec fold %lu\n",
(ulong) buf_frame_get_page_no(page),
node->data,
(ulong) ut_dulint_get_high(btr_page_get_index_id(page)),
(ulong) ut_dulint_get_low(btr_page_get_index_id(page)),
(ulong) node->fold,
(ulong) rec_fold((rec_t*)(node->data),
block->curr_n_fields,
block->curr_n_bytes,
btr_page_get_index_id(page)));
rec_sprintf(rec_str, 450, (rec_t*)(node->data));
fprintf(stderr,
"InnoDB: Record %s\n"
"InnoDB: on that page.", rec_str);
fprintf(stderr,
"Page mem address %lu, is hashed %lu, n fields %lu, n bytes %lu\n"
fputs("InnoDB: Record ", stderr);
rec_print(stderr, (rec_t*)(node->data));
fprintf(stderr, "\nInnoDB: on that page."
"Page mem address %p, is hashed %lu, n fields %lu, n bytes %lu\n"
"side %lu\n",
(ulong) page, (ulong) block->is_hashed,
(ulong) block->curr_n_fields,
(ulong) block->curr_n_bytes, (ulong) block->curr_side);
page, (ulong) block->is_hashed,
(ulong) block->curr_n_fields,
(ulong) block->curr_n_bytes, (ulong) block->curr_side);
if (n_page_dumps < 20) {
buf_page_print(page);

220
innobase/buf/buf0buf.c
View File

@ -223,12 +223,14 @@ in the free list to the frames.
buf_pool_t* buf_pool = NULL; /* The buffer buf_pool of the database */
ulint buf_dbg_counter = 0; /* This is used to insert validation
#ifdef UNIV_DEBUG
static ulint buf_dbg_counter = 0; /* This is used to insert validation
operations in excution in the
debug version */
ibool buf_debug_prints = FALSE; /* If this is set TRUE,
the program prints info whenever
read-ahead or flush occurs */
#endif /* UNIV_DEBUG */
/************************************************************************
Calculates a page checksum which is stored to the page when it is written
@ -372,19 +374,12 @@ buf_page_print(
dict_index_t* index;
ulint checksum;
ulint old_checksum;
char* buf;
buf = mem_alloc(4 * UNIV_PAGE_SIZE);
ut_sprintf_buf(buf, read_buf, UNIV_PAGE_SIZE);
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Page dump in ascii and hex (%lu bytes):\n%s",
(ulong) UNIV_PAGE_SIZE, buf);
fprintf(stderr, "InnoDB: End of page dump\n");
mem_free(buf);
fprintf(stderr, " InnoDB: Page dump in ascii and hex (%lu bytes):\n",
(ulint)UNIV_PAGE_SIZE);
ut_print_buf(stderr, read_buf, UNIV_PAGE_SIZE);
fputs("InnoDB: End of page dump\n", stderr);
checksum = buf_calc_page_new_checksum(read_buf);
old_checksum = buf_calc_page_old_checksum(read_buf);
@ -433,17 +428,16 @@ buf_page_print(
index = dict_index_find_on_id_low(
btr_page_get_index_id(read_buf));
if (index) {
fprintf(stderr,
"InnoDB: and table %s index %s\n",
index->table_name,
index->name);
fputs("InnoDB: (", stderr);
dict_index_name_print(stderr, index);
fputs(")\n", stderr);
}
}
} else if (fil_page_get_type(read_buf) == FIL_PAGE_INODE) {
fprintf(stderr, "InnoDB: Page may be an 'inode' page\n");
fputs("InnoDB: Page may be an 'inode' page\n", stderr);
} else if (fil_page_get_type(read_buf) == FIL_PAGE_IBUF_FREE_LIST) {
fprintf(stderr,
"InnoDB: Page may be an insert buffer free list page\n");
fputs("InnoDB: Page may be an insert buffer free list page\n",
stderr);
}
}
@ -1551,11 +1545,12 @@ buf_page_init(
"InnoDB: Error: page %lu %lu already found from the hash table\n",
(ulong) space,
(ulong) offset);
#ifdef UNIV_DEBUG
buf_print();
buf_LRU_print();
buf_validate();
buf_LRU_validate();
#endif /* UNIV_DEBUG */
ut_a(0);
}
@ -1732,11 +1727,12 @@ buf_page_create(
/* If we get here, the page was not in buf_pool: init it there */
#ifdef UNIV_DEBUG
if (buf_debug_prints) {
printf("Creating space %lu page %lu to buffer\n",
(ulong) space,
(ulong) offset);
fprintf(stderr, "Creating space %lu page %lu to buffer\n",
(ulong) space, (ulong) offset);
}
#endif /* UNIV_DEBUG */
block = free_block;
@ -1789,8 +1785,6 @@ buf_page_io_complete(
/*=================*/
buf_block_t* block) /* in: pointer to the block in question */
{
dict_index_t* index;
dulint id;
ulint io_type;
ulint read_page_no;
@ -1823,17 +1817,17 @@ buf_page_io_complete(
"InnoDB: Database page corruption on disk or a failed\n"
"InnoDB: file read of page %lu.\n", (ulong) block->offset);
fprintf(stderr,
"InnoDB: You may have to recover from a backup.\n");
fputs(
"InnoDB: You may have to recover from a backup.\n", stderr);
buf_page_print(block->frame);
fprintf(stderr,
"InnoDB: Database page corruption on disk or a failed\n"
"InnoDB: file read of page %lu.\n", (ulong) block->offset);
fprintf(stderr,
"InnoDB: You may have to recover from a backup.\n");
fprintf(stderr,
fputs(
"InnoDB: You may have to recover from a backup.\n", stderr);
fputs(
"InnoDB: It is also possible that your operating\n"
"InnoDB: system has corrupted its own file cache\n"
"InnoDB: and rebooting your computer removes the\n"
@ -1844,12 +1838,13 @@ buf_page_io_complete(
"InnoDB: the corrupt table. You can use CHECK\n"
"InnoDB: TABLE to scan your table for corruption.\n"
"InnoDB: Look also at section 6.1 of\n"
"InnoDB: http://www.innodb.com/ibman.html about\n"
"InnoDB: forcing recovery.\n");
"InnoDB: http://www.innodb.com/ibman.php about\n"
"InnoDB: forcing recovery.\n", stderr);
if (srv_force_recovery < SRV_FORCE_IGNORE_CORRUPT) {
fprintf(stderr,
"InnoDB: Ending processing because of a corrupt database page.\n");
fputs(
"InnoDB: Ending processing because of a corrupt database page.\n",
stderr);
exit(1);
}
}
@ -1888,9 +1883,11 @@ buf_page_io_complete(
rw_lock_x_unlock_gen(&(block->lock), BUF_IO_READ);
#ifdef UNIV_DEBUG
if (buf_debug_prints) {
printf("Has read ");
fputs("Has read ", stderr);
}
#endif /* UNIV_DEBUG */
} else {
ut_ad(io_type == BUF_IO_WRITE);
@ -1903,31 +1900,21 @@ buf_page_io_complete(
buf_pool->n_pages_written++;
#ifdef UNIV_DEBUG
if (buf_debug_prints) {
printf("Has written ");
fputs("Has written ", stderr);
}
#endif /* UNIV_DEBUG */
}
mutex_exit(&(buf_pool->mutex));
#ifdef UNIV_DEBUG
if (buf_debug_prints) {
printf("page space %lu page no %lu", (ulong) block->space,
(ulong) block->offset);
id = btr_page_get_index_id(block->frame);
index = NULL;
/* The following can cause deadlocks if used: */
/*
index = dict_index_get_if_in_cache(id);
if (index) {
printf(" index name %s table %s", index->name,
index->table->name);
}
*/
printf("\n");
fprintf(stderr, "page space %lu page no %lu\n",
(ulong) block->space, (ulong) block->offset);
}
#endif /* UNIV_DEBUG */
}
/*************************************************************************
@ -1956,6 +1943,7 @@ buf_pool_invalidate(void)
mutex_exit(&(buf_pool->mutex));
}
#ifdef UNIV_DEBUG
/*************************************************************************
Validates the buffer buf_pool data structure. */
@ -2027,16 +2015,14 @@ buf_validate(void)
}
if (n_lru + n_free > buf_pool->curr_size) {
printf("n LRU %lu, n free %lu\n", (ulong) n_lru,
(ulong) n_free);
fprintf(stderr, "n LRU %lu, n free %lu\n", (ulong) n_lru, (ulong) n_free);
ut_error;
}
ut_a(UT_LIST_GET_LEN(buf_pool->LRU) == n_lru);
if (UT_LIST_GET_LEN(buf_pool->free) != n_free) {
printf("Free list len %lu, free blocks %lu\n",
(ulong) UT_LIST_GET_LEN(buf_pool->free),
(ulong) n_free);
fprintf(stderr, "Free list len %lu, free blocks %lu\n",
(ulong) UT_LIST_GET_LEN(buf_pool->free), (ulong) n_free);
ut_error;
}
ut_a(UT_LIST_GET_LEN(buf_pool->flush_list) == n_flush);
@ -2079,23 +2065,24 @@ buf_print(void)
mutex_enter(&(buf_pool->mutex));
printf("buf_pool size %lu \n", (ulong) size);
printf("database pages %lu \n", (ulong) UT_LIST_GET_LEN(buf_pool->LRU));
printf("free pages %lu \n", (ulong) UT_LIST_GET_LEN(buf_pool->free));
printf("modified database pages %lu \n",
(ulong) UT_LIST_GET_LEN(buf_pool->flush_list));
printf("n pending reads %lu \n", (ulong) buf_pool->n_pend_reads);
printf("n pending flush LRU %lu list %lu single page %lu\n",
(ulong) buf_pool->n_flush[BUF_FLUSH_LRU],
(ulong) buf_pool->n_flush[BUF_FLUSH_LIST],
(ulong) buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]);
printf("pages read %lu, created %lu, written %lu\n",
(ulong) buf_pool->n_pages_read,
(ulong) buf_pool->n_pages_created,
(ulong) buf_pool->n_pages_written);
fprintf(stderr,
"buf_pool size %lu\n"
"database pages %lu\n"
"free pages %lu\n"
"modified database pages %lu\n"
"n pending reads %lu\n"
"n pending flush LRU %lu list %lu single page %lu\n"
"pages read %lu, created %lu, written %lu\n",
(ulong) size,
(ulong) UT_LIST_GET_LEN(buf_pool->LRU),
(ulong) UT_LIST_GET_LEN(buf_pool->free),
(ulong) UT_LIST_GET_LEN(buf_pool->flush_list),
(ulong) buf_pool->n_pend_reads,
(ulong) buf_pool->n_flush[BUF_FLUSH_LRU],
(ulong) buf_pool->n_flush[BUF_FLUSH_LIST],
(ulong) buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE],
(ulong) buf_pool->n_pages_read, buf_pool->n_pages_created,
(ulong) buf_pool->n_pages_written);
/* Count the number of blocks belonging to each index in the buffer */
@ -2138,16 +2125,17 @@ buf_print(void)
for (i = 0; i < n_found; i++) {
index = dict_index_get_if_in_cache(index_ids[i]);
printf("Block count for index %lu in buffer is about %lu",
fprintf(stderr,
"Block count for index %lu in buffer is about %lu",
(ulong) ut_dulint_get_low(index_ids[i]),
(ulong) counts[i]);
if (index) {
printf(" index name %s table %s", index->name,
index->table->name);
putc(' ', stderr);
dict_index_name_print(stderr, index);
}
printf("\n");
putc('\n', stderr);
}
mem_free(index_ids);
@ -2155,6 +2143,7 @@ buf_print(void)
ut_a(buf_validate());
}
#endif /* UNIV_DEBUG */
/*************************************************************************
Returns the number of pending buf pool ios. */
@ -2198,57 +2187,42 @@ Prints info of the buffer i/o. */
void
buf_print_io(
/*=========*/
char* buf, /* in/out: buffer where to print */
char* buf_end)/* in: buffer end */
FILE* file) /* in/out: buffer where to print */
{
time_t current_time;
double time_elapsed;
ulint size;
ut_ad(buf_pool);
if (buf_end - buf < 400) {
return;
}
size = buf_pool->curr_size;
mutex_enter(&(buf_pool->mutex));
buf += sprintf(buf,
"Buffer pool size %lu\n", (ulong) size);
buf += sprintf(buf,
"Free buffers %lu\n", (ulong) UT_LIST_GET_LEN(buf_pool->free));
buf += sprintf(buf,
"Database pages %lu\n", (ulong) UT_LIST_GET_LEN(buf_pool->LRU));
/*
buf += sprintf(buf,
"Lock heap buffers %lu\n", (ulong) buf_pool->n_lock_heap_pages);
buf += sprintf(buf,
"Hash index buffers %lu\n", (ulong) buf_pool->n_adaptive_hash_pages);
*/
buf += sprintf(buf,
"Modified db pages %lu\n",
(ulong) UT_LIST_GET_LEN(buf_pool->flush_list));
if (srv_use_awe) {
buf += sprintf(buf,
fprintf(stderr,
"AWE: Buffer pool memory frames %lu\n",
(ulong) buf_pool->n_frames);
buf += sprintf(buf,
fprintf(stderr,
"AWE: Database pages and free buffers mapped in frames %lu\n",
(ulong) UT_LIST_GET_LEN(buf_pool->awe_LRU_free_mapped));
}
buf += sprintf(buf, "Pending reads %lu \n", (ulong) buf_pool->n_pend_reads);
buf += sprintf(buf,
fprintf(file,
"Buffer pool size %lu\n"
"Free buffers %lu\n"
"Database pages %lu\n"
"Modified db pages %lu\n"
"Pending reads %lu\n"
"Pending writes: LRU %lu, flush list %lu, single page %lu\n",
(ulong) (buf_pool->n_flush[BUF_FLUSH_LRU]
+ buf_pool->init_flush[BUF_FLUSH_LRU]),
(ulong) (buf_pool->n_flush[BUF_FLUSH_LIST]
+ buf_pool->init_flush[BUF_FLUSH_LIST]),
(ulong) size,
(ulong) UT_LIST_GET_LEN(buf_pool->free),
(ulong) UT_LIST_GET_LEN(buf_pool->LRU),
(ulong) UT_LIST_GET_LEN(buf_pool->flush_list),
(ulong) buf_pool->n_pend_reads,
(ulong) buf_pool->n_flush[BUF_FLUSH_LRU]
+ buf_pool->init_flush[BUF_FLUSH_LRU],
(ulong) buf_pool->n_flush[BUF_FLUSH_LIST]
+ buf_pool->init_flush[BUF_FLUSH_LIST],
(ulong) buf_pool->n_flush[BUF_FLUSH_SINGLE_PAGE]);
current_time = time(NULL);
@ -2256,11 +2230,12 @@ buf_print_io(
buf_pool->last_printout_time);
buf_pool->last_printout_time = current_time;
buf += sprintf(buf, "Pages read %lu, created %lu, written %lu\n",
(ulong) buf_pool->n_pages_read,
(ulong) buf_pool->n_pages_created,
(ulong) buf_pool->n_pages_written);
buf += sprintf(buf, "%.2f reads/s, %.2f creates/s, %.2f writes/s\n",
fprintf(file,
"Pages read %lu, created %lu, written %lu\n"
"%.2f reads/s, %.2f creates/s, %.2f writes/s\n",
(ulong) buf_pool->n_pages_read,
(ulong) buf_pool->n_pages_created,
(ulong) buf_pool->n_pages_written,
(buf_pool->n_pages_read - buf_pool->n_pages_read_old)
/ time_elapsed,
(buf_pool->n_pages_created - buf_pool->n_pages_created_old)
@ -2269,21 +2244,21 @@ buf_print_io(
/ time_elapsed);
if (srv_use_awe) {
buf += sprintf(buf, "AWE: %.2f page remaps/s\n",
fprintf(file, "AWE: %.2f page remaps/s\n",
(buf_pool->n_pages_awe_remapped
- buf_pool->n_pages_awe_remapped_old)
/ time_elapsed);
}
if (buf_pool->n_page_gets > buf_pool->n_page_gets_old) {
buf += sprintf(buf, "Buffer pool hit rate %lu / 1000\n",
fprintf(file, "Buffer pool hit rate %lu / 1000\n",
(ulong) (1000
- ((1000 *
(buf_pool->n_pages_read - buf_pool->n_pages_read_old))
/ (buf_pool->n_page_gets - buf_pool->n_page_gets_old))));
} else {
buf += sprintf(buf,
"No buffer pool page gets since the last printout\n");
fputs("No buffer pool page gets since the last printout\n",
file);
}
buf_pool->n_page_gets_old = buf_pool->n_page_gets;
@ -2332,8 +2307,9 @@ buf_all_freed(void)
if (!buf_flush_ready_for_replace(block)) {
/* printf("Page %lu %lu still fixed or dirty\n",
block->space, block->offset); */
fprintf(stderr,
"Page %lu %lu still fixed or dirty\n",
(ulong) block->space, (ulong) block->offset);
ut_error;
}
}

43
innobase/buf/buf0flu.c
View File

@ -32,6 +32,7 @@ flushed along with the original page. */
#define BUF_FLUSH_AREA ut_min(BUF_READ_AHEAD_AREA,\
buf_pool->curr_size / 16)
#ifdef UNIV_DEBUG
/**********************************************************************
Validates the flush list. */
static
@ -39,6 +40,7 @@ ibool
buf_flush_validate_low(void);
/*========================*/
/* out: TRUE if ok */
#endif /* UNIV_DEBUG */
/************************************************************************
Inserts a modified block into the flush list. */
@ -193,7 +195,7 @@ buf_flush_write_complete(
buf_pool->LRU_flush_ended++;
}
/* printf("n pending flush %lu\n",
/* fprintf(stderr, "n pending flush %lu\n",
buf_pool->n_flush[block->flush_type]); */
if ((buf_pool->n_flush[block->flush_type] == 0)
@ -420,8 +422,8 @@ buf_flush_write_block_low(
ut_ad(!ut_dulint_is_zero(block->newest_modification));
#ifdef UNIV_LOG_DEBUG
printf(
"Warning: cannot force log to disk in the log debug version!\n");
fputs("Warning: cannot force log to disk in the log debug version!\n",
stderr);
#else
/* Force the log to the disk before writing the modified block */
log_write_up_to(block->newest_modification, LOG_WAIT_ALL_GROUPS, TRUE);
@ -511,11 +513,13 @@ buf_flush_try_page(
rw_lock_s_lock_gen(&(block->lock), BUF_IO_WRITE);
}
#ifdef UNIV_DEBUG
if (buf_debug_prints) {
printf("Flushing page space %lu, page no %lu \n",
(ulong) block->space,
(ulong) block->offset);
fprintf(stderr,
"Flushing page space %lu, page no %lu \n",
(ulong) block->space, (ulong) block->offset);
}
#endif /* UNIV_DEBUG */
buf_flush_write_block_low(block);
@ -599,12 +603,14 @@ buf_flush_try_page(
rw_lock_s_lock_gen(&(block->lock), BUF_IO_WRITE);
#ifdef UNIV_DEBUG
if (buf_debug_prints) {
printf(
fprintf(stderr,
"Flushing single page space %lu, page no %lu \n",
(ulong) block->space,
(ulong) block->offset);
}
#endif /* UNIV_DEBUG */
buf_flush_write_block_low(block);
@ -645,7 +651,7 @@ buf_flush_try_neighbors(
high = offset + 1;
}
/* printf("Flush area: low %lu high %lu\n", low, high); */
/* fprintf(stderr, "Flush area: low %lu high %lu\n", low, high); */
if (high > fil_space_get_size(space)) {
high = fil_space_get_size(space);
@ -793,7 +799,7 @@ buf_flush_batch(
page_count +=
buf_flush_try_neighbors(space, offset,
flush_type);
/* printf(
/* fprintf(stderr,
"Flush type %lu, page no %lu, neighb %lu\n",
flush_type, offset,
page_count - old_page_count); */
@ -831,17 +837,16 @@ buf_flush_batch(
buf_flush_buffered_writes();
#ifdef UNIV_DEBUG
if (buf_debug_prints && page_count > 0) {
if (flush_type == BUF_FLUSH_LRU) {
printf("Flushed %lu pages in LRU flush\n",
(ulong) page_count);
} else if (flush_type == BUF_FLUSH_LIST) {
printf("Flushed %lu pages in flush list flush\n",
(ulong) page_count);
} else {
ut_error;
}
ut_a(flush_type == BUF_FLUSH_LRU
|| flush_type == BUF_FLUSH_LIST);
fprintf(stderr, flush_type == BUF_FLUSH_LRU
? "Flushed %lu pages in LRU flush\n"
: "Flushed %lu pages in flush list flush\n",
(ulong) page_count);
}
#endif /* UNIV_DEBUG */
return(page_count);
}
@ -933,6 +938,7 @@ buf_flush_free_margin(void)
}
}
#ifdef UNIV_DEBUG
/**********************************************************************
Validates the flush list. */
static
@ -982,3 +988,4 @@ buf_flush_validate(void)
return(ret);
}
#endif /* UNIV_DEBUG */

69
innobase/buf/buf0lru.c
View File

@ -97,13 +97,14 @@ scan_again:
}
if (block->space == id) {
#ifdef UNIV_DEBUG
if (buf_debug_prints) {
printf(
"Dropping space %lu page %lu\n",
(ulong) block->space,
(ulong) block->offset);
}
#endif
if (block->is_hashed) {
page_no = block->offset;
@ -207,12 +208,16 @@ buf_LRU_search_and_free_block(
while (block != NULL) {
ut_a(block->in_LRU_list);
if (buf_flush_ready_for_replace(block)) {
#ifdef UNIV_DEBUG
if (buf_debug_prints) {
printf(
fprintf(stderr,
"Putting space %lu page %lu to free list\n",
(ulong) block->space,
(ulong) block->offset);
}
#endif /* UNIV_DEBUG */
buf_LRU_block_remove_hashed_page(block);
mutex_exit(&(buf_pool->mutex));
@ -404,28 +409,21 @@ loop:
fprintf(stderr,
"InnoDB: Warning: difficult to find free blocks from\n"
"InnoDB: the buffer pool (%lu search iterations)! Consider\n"
"InnoDB: increasing the buffer pool size.\n",
(ulong) n_iterations);
fprintf(stderr,
"InnoDB: increasing the buffer pool size.\n"
"InnoDB: It is also possible that in your Unix version\n"
"InnoDB: fsync is very slow, or completely frozen inside\n"
"InnoDB: the OS kernel. Then upgrading to a newer version\n"
"InnoDB: of your operating system may help. Look at the\n"
"InnoDB: number of fsyncs in diagnostic info below.\n");
fprintf(stderr,
"InnoDB: Pending flushes (fsync) log: %lu; buffer pool: %lu\n",
(ulong) fil_n_pending_log_flushes,
(ulong) fil_n_pending_tablespace_flushes);
fprintf(stderr,
"InnoDB: %lu OS file reads, %lu OS file writes, %lu OS fsyncs\n",
(ulong) os_n_file_reads,
(ulong) os_n_file_writes,
(ulong) os_n_fsyncs);
fprintf(stderr,
"InnoDB: number of fsyncs in diagnostic info below.\n"
"InnoDB: Pending flushes (fsync) log: %lu; buffer pool: %lu\n"
"InnoDB: %lu OS file reads, %lu OS file writes, %lu OS fsyncs\n"
"InnoDB: Starting InnoDB Monitor to print further\n"
"InnoDB: diagnostics to the standard output.\n");
"InnoDB: diagnostics to the standard output.\n",
(ulong) n_iterations,
(ulong) fil_n_pending_log_flushes,
(ulong) fil_n_pending_tablespace_flushes,
(ulong) os_n_file_reads, (ulong) os_n_file_writes,
(ulong) os_n_fsyncs);
mon_value_was = srv_print_innodb_monitor;
started_monitor = TRUE;
@ -855,11 +853,12 @@ buf_LRU_block_remove_hashed_page(
(ulong) block);
}
#ifdef UNIV_DEBUG
buf_print();
buf_LRU_print();
buf_validate();
buf_LRU_validate();
#endif
ut_a(0);
}
@ -889,6 +888,7 @@ buf_LRU_block_free_hashed_page(
buf_LRU_block_free_non_file_page(block);
}
#ifdef UNIV_DEBUG
/**************************************************************************
Validates the LRU list. */
@ -975,7 +975,7 @@ buf_LRU_print(void)
ut_ad(buf_pool);
mutex_enter(&(buf_pool->mutex));
printf("Pool ulint clock %lu\n", (ulong) buf_pool->ulint_clock);
fprintf(stderr, "Pool ulint clock %lu\n", (ulong) buf_pool->ulint_clock);
block = UT_LIST_GET_FIRST(buf_pool->LRU);
@ -983,39 +983,40 @@ buf_LRU_print(void)
while (block != NULL) {
printf("BLOCK %lu ", (ulong) block->offset);
fprintf(stderr, "BLOCK %lu ", (ulong) block->offset);
if (block->old) {
printf("old ");
fputs("old ", stderr);
}
if (block->buf_fix_count) {
printf("buffix count %lu ", (ulong) block->buf_fix_count);
fprintf(stderr, "buffix count %lu ",
(ulong) block->buf_fix_count);
}
if (block->io_fix) {
printf("io_fix %lu ", (ulong) block->io_fix);
fprintf(stderr, "io_fix %lu ", (ulong) block->io_fix);
}
if (ut_dulint_cmp(block->oldest_modification,
ut_dulint_zero) > 0) {
printf("modif. ");
fputs("modif. ", stderr);
}
printf("LRU pos %lu ", (ulong) block->LRU_position);
frame = buf_block_get_frame(block);
printf("type %lu ", (ulong) fil_page_get_type(frame));
printf("index id %lu ", (ulong) ut_dulint_get_low(
btr_page_get_index_id(frame)));
fprintf(stderr, "LRU pos %lu type %lu index id %lu ",
(ulong) block->LRU_position,
(ulong) fil_page_get_type(frame),
(ulong) ut_dulint_get_low(btr_page_get_index_id(frame)));
block = UT_LIST_GET_NEXT(LRU, block);
len++;
if (len % 10 == 0) {
printf("\n");
if (++len == 10) {
len = 0;
putc('\n', stderr);
}
}
mutex_exit(&(buf_pool->mutex));
}
#endif /* UNIV_DEBUG */

31
innobase/buf/buf0rea.c
View File

@ -97,7 +97,8 @@ buf_read_page_low(
log mutex: the read must be handled before other reads
which might incur ibuf operations and thus write to the log */
printf("Log debug: reading replicate page in sync mode\n");
fputs("Log debug: reading replicate page in sync mode\n",
stderr);
sync = TRUE;
}
@ -117,7 +118,6 @@ buf_read_page_low(
or is being dropped; if we succeed in initing the page in the buffer
pool for read, then DISCARD cannot proceed until the read has
completed */
block = buf_page_init_for_read(err, mode, space, tablespace_version,
offset);
if (block == NULL) {
@ -125,11 +125,14 @@ buf_read_page_low(
return(0);
}
#ifdef UNIV_DEBUG
if (buf_debug_prints) {
printf("Posting read request for page %lu, sync %lu\n",
fprintf(stderr,
"Posting read request for page %lu, sync %lu\n",
(ulong) offset,
(ulong) sync);
}
#endif
ut_a(block->state == BUF_BLOCK_FILE_PAGE);
@ -281,12 +284,14 @@ buf_read_ahead_random(
os_aio_simulated_wake_handler_threads();
#ifdef UNIV_DEBUG
if (buf_debug_prints && (count > 0)) {
printf("Random read-ahead space %lu offset %lu pages %lu\n",
fprintf(stderr,
"Random read-ahead space %lu offset %lu pages %lu\n",
(ulong) space, (ulong) offset,
(ulong) count);
}
#endif /* UNIV_DEBUG */
return(count);
}
@ -566,11 +571,13 @@ buf_read_ahead_linear(
/* Flush pages from the end of the LRU list if necessary */
buf_flush_free_margin();
#ifdef UNIV_DEBUG
if (buf_debug_prints && (count > 0)) {
printf(
fprintf(stderr,
"LINEAR read-ahead space %lu offset %lu pages %lu\n",
(ulong) space, (ulong) offset, (ulong) count);
}
#endif /* UNIV_DEBUG */
return(count);
}
@ -629,9 +636,13 @@ buf_read_ibuf_merge_pages(
/* Flush pages from the end of the LRU list if necessary */
buf_flush_free_margin();
#ifdef UNIV_DEBUG
if (buf_debug_prints) {
printf("Ibuf merge read-ahead pages %lu\n", (ulong) n_stored);
fprintf(stderr,
"Ibuf merge read-ahead space %lu pages %lu\n",
(ulong) space, (ulong) n_stored);
}
#endif /* UNIV_DEBUG */
}
/************************************************************************
@ -695,8 +706,10 @@ buf_read_recv_pages(
/* Flush pages from the end of the LRU list if necessary */
buf_flush_free_margin();
#ifdef UNIV_DEBUG
if (buf_debug_prints) {
printf("Recovery applies read-ahead pages %lu\n",
(ulong) n_stored);
fprintf(stderr,
"Recovery applies read-ahead pages %lu\n", (ulong) n_stored);
}
#endif /* UNIV_DEBUG */
}

132
innobase/data/data0data.c
View File

@ -12,7 +12,6 @@ Created 5/30/1994 Heikki Tuuri
#include "data0data.ic"
#endif
#include "ut0rnd.h"
#include "rem0rec.h"
#include "rem0cmp.h"
#include "page0page.h"
@ -22,12 +21,10 @@ Created 5/30/1994 Heikki Tuuri
byte data_error; /* data pointers of tuple fields are initialized
to point here for error checking */
#ifdef UNIV_DEBUG
ulint data_dummy; /* this is used to fool the compiler in
dtuple_validate */
byte data_buf[8192]; /* used in generating test tuples */
ulint data_rnd = 756511;
#endif /* UNIV_DEBUG */
/* Some non-inlined functions used in the MySQL interface: */
void
@ -215,16 +212,15 @@ dtuple_check_typed_no_assert(
{
dfield_t* field;
ulint i;
char err_buf[1000];
if (dtuple_get_n_fields(tuple) > REC_MAX_N_FIELDS) {
fprintf(stderr,
"InnoDB: Error: index entry has %lu fields\n",
(ulong) dtuple_get_n_fields(tuple));
dtuple_sprintf(err_buf, 900, tuple);
fprintf(stderr,
"InnoDB: Tuple contents: %s\n", err_buf);
dump:
fputs("InnoDB: Tuple contents: ", stderr);
dtuple_print(stderr, tuple);
putc('\n', stderr);
return(FALSE);
}
@ -234,12 +230,7 @@ dtuple_check_typed_no_assert(
field = dtuple_get_nth_field(tuple, i);
if (!dfield_check_typed_no_assert(field)) {
dtuple_sprintf(err_buf, 900, tuple);
fprintf(stderr,
"InnoDB: Tuple contents: %s\n", err_buf);
return(FALSE);
goto dump;
}
}
@ -291,6 +282,7 @@ dtuple_check_typed(
return(TRUE);
}
#ifdef UNIV_DEBUG
/**************************************************************
Validates the consistency of a tuple which must be complete, i.e,
all fields must have been set. */
@ -338,6 +330,7 @@ dtuple_validate(
return(TRUE);
}
#endif /* UNIV_DEBUG */
/*****************************************************************
Pretty prints a dfield value according to its data type. */
@ -356,7 +349,7 @@ dfield_print(
data = dfield_get_data(dfield);
if (len == UNIV_SQL_NULL) {
printf("NULL");
fputs("NULL", stderr);
return;
}
@ -366,18 +359,12 @@ dfield_print(
if ((mtype == DATA_CHAR) || (mtype == DATA_VARCHAR)) {
for (i = 0; i < len; i++) {
if (isprint((char)(*data))) {
printf("%c", (char)*data);
} else {
printf(" ");
}
data++;
int c = *data++;
putc(isprint(c) ? c : ' ', stderr);
}
} else if (mtype == DATA_INT) {
ut_a(len == 4); /* only works for 32-bit integers */
printf("%i", (int)mach_read_from_4(data));
fprintf(stderr, "%d", (int)mach_read_from_4(data));
} else {
ut_error;
}
@ -402,7 +389,7 @@ dfield_print_also_hex(
data = dfield_get_data(dfield);
if (len == UNIV_SQL_NULL) {
printf("NULL");
fputs("NULL", stderr);
return;
}
@ -414,15 +401,12 @@ dfield_print_also_hex(
print_also_hex = FALSE;
for (i = 0; i < len; i++) {
if (isprint((char)(*data))) {
printf("%c", (char)*data);
} else {
int c = *data++;
if (!isprint(c)) {
print_also_hex = TRUE;
printf(" ");
c = ' ';
}
data++;
putc(c, stderr);
}
if (!print_also_hex) {
@ -430,18 +414,18 @@ dfield_print_also_hex(
return;
}
printf(" Hex: ");
fputs(" Hex: ", stderr);
data = dfield_get_data(dfield);
for (i = 0; i < len; i++) {
printf("%02lx", (ulong)*data);
fprintf(stderr, "%02lx", (ulint)*data);
data++;
}
} else if (mtype == DATA_INT) {
ut_a(len == 4); /* inly works for 32-bit integers */
printf("%i", (int)mach_read_from_4(data));
ut_a(len == 4); /* only works for 32-bit integers */
fprintf(stderr, "%d", (int)mach_read_from_4(data));
} else {
ut_error;
}
@ -453,6 +437,7 @@ The following function prints the contents of a tuple. */
void
dtuple_print(
/*=========*/
FILE* f, /* in: output stream */
dtuple_t* tuple) /* in: tuple */
{
dfield_t* field;
@ -461,73 +446,24 @@ dtuple_print(
n_fields = dtuple_get_n_fields(tuple);
printf("DATA TUPLE: %lu fields;\n", (ulong) n_fields);
fprintf(f, "DATA TUPLE: %lu fields;\n", (ulong) n_fields);
for (i = 0; i < n_fields; i++) {
printf(" %lu:", (ulong) i);
fprintf(f, " %lu:", (ulong) i);
field = dtuple_get_nth_field(tuple, i);
if (field->len != UNIV_SQL_NULL) {
ut_print_buf(field->data, field->len);
ut_print_buf(f, field->data, field->len);
} else {
printf(" SQL NULL");
fputs(" SQL NULL", f);
}
printf(";");
putc(';', f);
}
printf("\n");
dtuple_validate(tuple);
}
/**************************************************************
The following function prints the contents of a tuple to a buffer. */
ulint
dtuple_sprintf(
/*===========*/
/* out: printed length in bytes */
char* buf, /* in: print buffer */
ulint buf_len,/* in: buf length in bytes */
dtuple_t* tuple) /* in: tuple */
{
dfield_t* field;
ulint n_fields;
ulint len;
ulint i;
len = 0;
n_fields = dtuple_get_n_fields(tuple);
for (i = 0; i < n_fields; i++) {
if (len + 30 > buf_len) {
return(len);
}
len += sprintf(buf + len, " %lu:", (ulong) i);
field = dtuple_get_nth_field(tuple, i);
if (field->len != UNIV_SQL_NULL) {
if (5 * field->len + len + 30 > buf_len) {
return(len);
}
len += ut_sprintf_buf(buf + len, field->data,
field->len);
} else {
len += sprintf(buf + len, " SQL NULL");
}
len += sprintf(buf + len, ";");
}
return(len);
putc('\n', f);
ut_ad(dtuple_validate(tuple));
}
/******************************************************************
@ -561,7 +497,6 @@ dtuple_convert_big_rec(
ibool is_externally_stored;
ulint i;
ulint j;
char err_buf[1000];
ut_a(dtuple_check_typed_no_assert(entry));
@ -570,10 +505,9 @@ dtuple_convert_big_rec(
if (size > 1000000000) {
fprintf(stderr,
"InnoDB: Warning: tuple size very big: %lu\n", (ulong) size);
dtuple_sprintf(err_buf, 900, entry);
fprintf(stderr,
"InnoDB: Tuple contents: %s\n", err_buf);
fputs("InnoDB: Tuple contents: ", stderr);
dtuple_print(stderr, entry);
putc('\n', stderr);
}
heap = mem_heap_create(size + dtuple_get_n_fields(entry)

32
innobase/data/data0type.c
View File

@ -104,6 +104,7 @@ dtype_form_prtype(
return(old_prtype + (charset_coll << 16));
}
#ifdef UNIV_DEBUG
/*************************************************************************
Validates a data type structure. */
@ -122,6 +123,7 @@ dtype_validate(
return(TRUE);
}
#endif /* UNIV_DEBUG */
/*************************************************************************
Prints a data type structure. */
@ -140,19 +142,19 @@ dtype_print(
mtype = type->mtype;
prtype = type->prtype;
if (mtype == DATA_VARCHAR) {
printf("DATA_VARCHAR");
fputs("DATA_VARCHAR", stderr);
} else if (mtype == DATA_CHAR) {
printf("DATA_CHAR");
fputs("DATA_CHAR", stderr);
} else if (mtype == DATA_BINARY) {
printf("DATA_BINARY");
fputs("DATA_BINARY", stderr);
} else if (mtype == DATA_INT) {
printf("DATA_INT");
fputs("DATA_INT", stderr);
} else if (mtype == DATA_MYSQL) {
printf("DATA_MYSQL");
fputs("DATA_MYSQL", stderr);
} else if (mtype == DATA_SYS) {
printf("DATA_SYS");
fputs("DATA_SYS", stderr);
} else {
printf("type %lu", (ulong) mtype);
fprintf(stderr, "type %lu", (ulong) mtype);
}
len = type->len;
@ -160,24 +162,24 @@ dtype_print(
if ((type->mtype == DATA_SYS)
|| (type->mtype == DATA_VARCHAR)
|| (type->mtype == DATA_CHAR)) {
printf(" ");
putc(' ', stderr);
if (prtype == DATA_ROW_ID) {
printf("DATA_ROW_ID");
fputs("DATA_ROW_ID", stderr);
len = DATA_ROW_ID_LEN;
} else if (prtype == DATA_ROLL_PTR) {
printf("DATA_ROLL_PTR");
fputs("DATA_ROLL_PTR", stderr);
len = DATA_ROLL_PTR_LEN;
} else if (prtype == DATA_TRX_ID) {
printf("DATA_TRX_ID");
fputs("DATA_TRX_ID", stderr);
len = DATA_TRX_ID_LEN;
} else if (prtype == DATA_MIX_ID) {
printf("DATA_MIX_ID");
fputs("DATA_MIX_ID", stderr);
} else if (prtype == DATA_ENGLISH) {
printf("DATA_ENGLISH");
fputs("DATA_ENGLISH", stderr);
} else {
printf("prtype %lu", (ulong) mtype);
fprintf(stderr, "prtype %lu", (ulong) mtype);
}
}
printf(" len %lu prec %lu", (ulong) len, (ulong) type->prec);
fprintf(stderr, " len %lu prec %lu", (ulong) len, (ulong) type->prec);
}

3
innobase/dict/dict0boot.c
View File

@ -71,7 +71,8 @@ dict_hdr_get_new_id(
compile wrong */
if (0 == ut_dulint_cmp(id, ut_dulint_max)) {
printf("Max id\n");
/* TO DO: remove this code, or make it conditional */
ut_dbg_null_ptr = 0;
}
id = ut_dulint_add(id, 1);

236
innobase/dict/dict0crea.c
View File

@ -25,11 +25,6 @@ Created 1/8/1996 Heikki Tuuri
#include "trx0roll.h"
#include "usr0sess.h"
/* Maximum lengths of identifiers in MySQL, in bytes */
#define MAX_TABLE_NAME_LEN 64
#define MAX_COLUMN_NAME_LEN 64
#define MAX_IDENTIFIER_LEN 255
/*********************************************************************
Based on a table object, this function builds the entry to be inserted
in the SYS_TABLES system table. */
@ -37,67 +32,6 @@ static
dtuple_t*
dict_create_sys_tables_tuple(
/*=========================*/
/* out: the tuple which should be inserted */
dict_table_t* table, /* in: table */
mem_heap_t* heap); /* in: memory heap from which the memory for
the built tuple is allocated */
/*********************************************************************
Based on a table object, this function builds the entry to be inserted
in the SYS_COLUMNS system table. */
static
dtuple_t*
dict_create_sys_columns_tuple(
/*==========================*/
/* out: the tuple which should be inserted */
dict_table_t* table, /* in: table */
ulint i, /* in: column number */
mem_heap_t* heap); /* in: memory heap from which the memory for
the built tuple is allocated */
/*********************************************************************
Based on an index object, this function builds the entry to be inserted
in the SYS_INDEXES system table. */
static
dtuple_t*
dict_create_sys_indexes_tuple(
/*==========================*/
/* out: the tuple which should be inserted */
dict_index_t* index, /* in: index */
mem_heap_t* heap, /* in: memory heap from which the memory for
the built tuple is allocated */
trx_t* trx); /* in: transaction handle */
/*********************************************************************
Based on an index object, this function builds the entry to be inserted
in the SYS_FIELDS system table. */
static
dtuple_t*
dict_create_sys_fields_tuple(
/*=========================*/
/* out: the tuple which should be inserted */
dict_index_t* index, /* in: index */
ulint i, /* in: field number */
mem_heap_t* heap); /* in: memory heap from which the memory for
the built tuple is allocated */
/*********************************************************************
Creates the tuple with which the index entry is searched for
writing the index tree root page number, if such a tree is created. */
static
dtuple_t*
dict_create_search_tuple(
/*=====================*/
/* out: the tuple for search */
dtuple_t* tuple, /* in: the tuple inserted in the SYS_INDEXES
table */
mem_heap_t* heap); /* in: memory heap from which the memory for
the built tuple is allocated */
/*********************************************************************
Based on a table object, this function builds the entry to be inserted
in the SYS_TABLES system table. */
static
dtuple_t*
dict_create_sys_tables_tuple(
/*=========================*/
/* out: the tuple which should be inserted */
dict_table_t* table, /* in: table */
mem_heap_t* heap) /* in: memory heap from which the memory for
the built tuple is allocated */
@ -359,9 +293,8 @@ dict_create_sys_indexes_tuple(
/*==========================*/
/* out: the tuple which should be inserted */
dict_index_t* index, /* in: index */
mem_heap_t* heap, /* in: memory heap from which the memory for
mem_heap_t* heap) /* in: memory heap from which the memory for
the built tuple is allocated */
trx_t* trx) /* in: transaction handle */
{
dict_table_t* sys_indexes;
dict_table_t* table;
@ -369,7 +302,6 @@ dict_create_sys_indexes_tuple(
dfield_t* dfield;
byte* ptr;
UT_NOT_USED(trx);
#ifdef UNIV_SYNC_DEBUG
ut_ad(mutex_own(&(dict_sys->mutex)));
#endif /* UNIV_SYNC_DEBUG */
@ -415,7 +347,9 @@ dict_create_sys_indexes_tuple(
dfield_set_data(dfield, ptr, 4);
/* 7: SPACE --------------------------*/
ut_a(DICT_SYS_INDEXES_SPACE_NO_FIELD == 7);
#if DICT_SYS_INDEXES_SPACE_NO_FIELD != 7
#error "DICT_SYS_INDEXES_SPACE_NO_FIELD != 7"
#endif
dfield = dtuple_get_nth_field(entry, 5);
@ -425,7 +359,9 @@ dict_create_sys_indexes_tuple(
dfield_set_data(dfield, ptr, 4);
/* 8: PAGE_NO --------------------------*/
ut_a(DICT_SYS_INDEXES_PAGE_NO_FIELD == 8);
#if DICT_SYS_INDEXES_PAGE_NO_FIELD != 8
#error "DICT_SYS_INDEXES_PAGE_NO_FIELD != 8"
#endif
dfield = dtuple_get_nth_field(entry, 6);
@ -593,8 +529,7 @@ dict_build_index_def_step(
index->page_no = FIL_NULL;
row = dict_create_sys_indexes_tuple(index, node->heap,
thr_get_trx(thr));
row = dict_create_sys_indexes_tuple(index, node->heap);
node->ind_row = row;
ins_node_set_new_row(node->ind_def, row);
@ -630,7 +565,6 @@ ulint
dict_create_index_tree_step(
/*========================*/
/* out: DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
que_thr_t* thr, /* in: query thread */
ind_node_t* node) /* in: index create node */
{
dict_index_t* index;
@ -643,7 +577,6 @@ dict_create_index_tree_step(
#ifdef UNIV_SYNC_DEBUG
ut_ad(mutex_own(&(dict_sys->mutex)));
#endif /* UNIV_SYNC_DEBUG */
UT_NOT_USED(thr);
index = node->index;
table = node->table;
@ -1003,7 +936,7 @@ dict_create_index_step(
if (node->state == INDEX_CREATE_INDEX_TREE) {
err = dict_create_index_tree_step(thr, node);
err = dict_create_index_tree_step(node);
if (err != DB_SUCCESS) {
@ -1101,13 +1034,13 @@ dict_create_or_check_foreign_constraint_tables(void)
if (table1) {
fprintf(stderr,
"InnoDB: dropping incompletely created SYS_FOREIGN table\n");
row_drop_table_for_mysql((char *) "SYS_FOREIGN", trx);
row_drop_table_for_mysql((char*)"SYS_FOREIGN", trx, TRUE);
}
if (table2) {
fprintf(stderr,
"InnoDB: dropping incompletely created SYS_FOREIGN_COLS table\n");
row_drop_table_for_mysql((char *) "SYS_FOREIGN_COLS", trx);
row_drop_table_for_mysql((char*)"SYS_FOREIGN_COLS", trx, TRUE);
}
fprintf(stderr,
@ -1157,8 +1090,8 @@ dict_create_or_check_foreign_constraint_tables(void)
fprintf(stderr,
"InnoDB: dropping incompletely created SYS_FOREIGN tables\n");
row_drop_table_for_mysql((char *) "SYS_FOREIGN", trx);
row_drop_table_for_mysql((char *) "SYS_FOREIGN_COLS", trx);
row_drop_table_for_mysql((char*)"SYS_FOREIGN", trx, TRUE);
row_drop_table_for_mysql((char*)"SYS_FOREIGN_COLS", trx, TRUE);
error = DB_MUST_GET_MORE_FILE_SPACE;
}
@ -1207,11 +1140,22 @@ dict_create_add_foreigns_to_dictionary(
que_t* graph;
ulint number = start_id + 1;
ulint len;
ulint namelen;
ulint error;
char* ebuf = dict_foreign_err_buf;
FILE* ef = dict_foreign_err_file;
ulint i;
char buf[10000];
char* sql;
char* sqlend;
/* This procedure builds an InnoDB stored procedure which will insert
the necessary rows into SYS_FOREIGN and SYS_FOREIGN_COLS. */
static const char str1[] = "PROCEDURE ADD_FOREIGN_DEFS_PROC () IS\n"
"BEGIN\n"
"INSERT INTO SYS_FOREIGN VALUES(";
static const char str2[] = ");\n";
static const char str3[] =
"INSERT INTO SYS_FOREIGN_COLS VALUES(";
static const char str4[] =
"COMMIT WORK;\n"
"END;\n";
#ifdef UNIV_SYNC_DEBUG
ut_ad(mutex_own(&(dict_sys->mutex)));
@ -1231,58 +1175,75 @@ loop:
return(DB_SUCCESS);
}
/* Build an InnoDB stored procedure which will insert the necessary
rows to SYS_FOREIGN and SYS_FOREIGN_COLS */
len = 0;
len += sprintf(buf,
"PROCEDURE ADD_FOREIGN_DEFS_PROC () IS\n"
"BEGIN\n");
namelen = strlen(table->name);
ut_a(namelen < MAX_TABLE_NAME_LEN);
if (foreign->id == NULL) {
/* Generate a new constraint id */
foreign->id = mem_heap_alloc(foreign->heap, namelen + 20);
ulint namelen = strlen(table->name);
char* id = mem_heap_alloc(foreign->heap, namelen + 20);
/* no overflow if number < 1e13 */
sprintf(foreign->id, "%s_ibfk_%lu", table->name, (ulong) number);
number++;
sprintf(id, "%s_ibfk_%lu", table->name, (ulong) number++);
foreign->id = id;
}
ut_a(strlen(foreign->id) < MAX_IDENTIFIER_LEN);
ut_a(len < (sizeof buf)
- 46 - 2 * MAX_TABLE_NAME_LEN - MAX_IDENTIFIER_LEN - 20);
len += sprintf(buf + len,
"INSERT INTO SYS_FOREIGN VALUES('%s', '%s', '%s', %lu);\n",
foreign->id,
table->name,
foreign->referenced_table_name,
(ulong) (foreign->n_fields
+ (foreign->type << 24)));
len = (sizeof str1) + (sizeof str2) + (sizeof str4) - 3
+ 9/* ' and , chars */ + 10/* 32-bit integer */
+ ut_strlenq(foreign->id, '\'') * (foreign->n_fields + 1)
+ ut_strlenq(table->name, '\'')
+ ut_strlenq(foreign->referenced_table_name, '\'');
for (i = 0; i < foreign->n_fields; i++) {
ut_a(len < (sizeof buf)
- 51 - 2 * MAX_COLUMN_NAME_LEN
- MAX_IDENTIFIER_LEN - 20);
len += sprintf(buf + len,
"INSERT INTO SYS_FOREIGN_COLS VALUES('%s', %lu, '%s', '%s');\n",
foreign->id,
(ulong) i,
foreign->foreign_col_names[i],
foreign->referenced_col_names[i]);
len += 9/* ' and , chars */ + 10/* 32-bit integer */
+ (sizeof str3) + (sizeof str2) - 2
+ ut_strlenq(foreign->foreign_col_names[i], '\'')
+ ut_strlenq(foreign->referenced_col_names[i], '\'');
}
ut_a(len < (sizeof buf) - 19);
len += sprintf(buf + len,"COMMIT WORK;\nEND;\n");
sql = sqlend = mem_alloc(len + 1);
graph = pars_sql(buf);
/* INSERT INTO SYS_FOREIGN VALUES(...); */
memcpy(sqlend, str1, (sizeof str1) - 1);
sqlend += (sizeof str1) - 1;
*sqlend++ = '\'';
sqlend = ut_strcpyq(sqlend, '\'', foreign->id);
*sqlend++ = '\'', *sqlend++ = ',', *sqlend++ = '\'';
sqlend = ut_strcpyq(sqlend, '\'', table->name);
*sqlend++ = '\'', *sqlend++ = ',', *sqlend++ = '\'';
sqlend = ut_strcpyq(sqlend, '\'', foreign->referenced_table_name);
*sqlend++ = '\'', *sqlend++ = ',';
sqlend += sprintf(sqlend, "%010lu",
foreign->n_fields + (foreign->type << 24));
memcpy(sqlend, str2, (sizeof str2) - 1);
sqlend += (sizeof str2) - 1;
for (i = 0; i < foreign->n_fields; i++) {
/* INSERT INTO SYS_FOREIGN_COLS VALUES(...); */
memcpy(sqlend, str3, (sizeof str3) - 1);
sqlend += (sizeof str3) - 1;
*sqlend++ = '\'';
sqlend = ut_strcpyq(sqlend, '\'', foreign->id);
*sqlend++ = '\''; *sqlend++ = ',';
sqlend += sprintf(sqlend, "%010lu", (ulong) i);
*sqlend++ = ','; *sqlend++ = '\'';
sqlend = ut_strcpyq(sqlend, '\'',
foreign->foreign_col_names[i]);
*sqlend++ = '\''; *sqlend++ = ','; *sqlend++ = '\'';
sqlend = ut_strcpyq(sqlend, '\'',
foreign->referenced_col_names[i]);
*sqlend++ = '\'';
memcpy(sqlend, str2, (sizeof str2) - 1);
sqlend += (sizeof str2) - 1;
}
memcpy(sqlend, str4, sizeof str4);
sqlend += sizeof str4;
ut_a(sqlend == sql + len + 1);
graph = pars_sql(sql);
ut_a(graph);
mem_free(sql);
graph->trx = trx;
trx->graph = NULL;
@ -1298,14 +1259,17 @@ loop:
if (error == DB_DUPLICATE_KEY) {
mutex_enter(&dict_foreign_err_mutex);
ut_sprintf_timestamp(ebuf);
ut_a(strlen(ebuf) < DICT_FOREIGN_ERR_BUF_LEN
- MAX_TABLE_NAME_LEN - MAX_IDENTIFIER_LEN - 201);
sprintf(ebuf + strlen(ebuf),
" Error in foreign key constraint creation for table %s.\n"
"A foreign key constraint of name %s\n"
"already exists (note that internally InnoDB adds 'databasename/'\n"
"in front of the user-defined constraint name).\n", table->name, foreign->id);
rewind(ef);
ut_print_timestamp(ef);
fputs(" Error in foreign key constraint creation for table ",
ef);
ut_print_name(ef, table->name);
fputs(".\nA foreign key constraint of name ", ef);
ut_print_name(ef, foreign->id);
fputs("\nalready exists."
" (Note that internally InnoDB adds 'databasename/'\n"
"in front of the user-defined constraint name).\n",
ef);
mutex_exit(&dict_foreign_err_mutex);
@ -1318,12 +1282,12 @@ loop:
"InnoDB: internal error number %lu\n", (ulong) error);
mutex_enter(&dict_foreign_err_mutex);
ut_sprintf_timestamp(ebuf);
ut_a(strlen(ebuf) < DICT_FOREIGN_ERR_BUF_LEN
- MAX_TABLE_NAME_LEN - 124);
sprintf(ebuf + strlen(ebuf),
" Internal error in foreign key constraint creation for table %s.\n"
"See the MySQL .err log in the datadir for more information.\n", table->name);
ut_print_timestamp(ef);
fputs(" Internal error in foreign key constraint creation"
" for table ", ef);
ut_print_name(ef, table->name);
fputs(".\n"
"See the MySQL .err log in the datadir for more information.\n", ef);
mutex_exit(&dict_foreign_err_mutex);
return(error);

1233
innobase/dict/dict0dict.c
View File

File diff suppressed because it is too large Load Diff

159
innobase/dict/dict0load.c
View File

@ -40,7 +40,6 @@ dict_get_first_table_name_in_db(
rec_t* rec;
byte* field;
ulint len;
char* table_name;
mtr_t mtr;
#ifdef UNIV_SYNC_DEBUG
@ -92,9 +91,7 @@ loop:
/* We found one */
table_name = mem_alloc(len + 1);
ut_memcpy(table_name, field, len);
table_name[len] = '\0';
char* table_name = mem_strdupl(field, len);
btr_pcur_close(&pcur);
mtr_commit(&mtr);
@ -124,7 +121,6 @@ dict_print(void)
byte* field;
ulint len;
mtr_t mtr;
char table_name[10000];
mutex_enter(&(dict_sys->mutex));
@ -157,18 +153,19 @@ loop:
/* We found one */
ut_memcpy(table_name, field, len);
table_name[len] = '\0';
char* table_name = mem_strdupl(field, len);
btr_pcur_store_position(&pcur, &mtr);
mtr_commit(&mtr);
table = dict_table_get_low(table_name);
mem_free(table_name);
if (table == NULL) {
fprintf(stderr, "InnoDB: Failed to load table %s\n",
table_name);
fputs("InnoDB: Failed to load table ", stderr);
ut_print_namel(stderr, field, len);
putc('\n', stderr);
} else {
/* The table definition was corrupt if there
is no index */
@ -300,7 +297,6 @@ dict_load_columns(
byte* field;
ulint len;
byte* buf;
char* name_buf;
char* name;
ulint mtype;
ulint prtype;
@ -351,12 +347,7 @@ dict_load_columns(
dict_table_get_first_index(sys_columns), 4))->name));
field = rec_get_nth_field(rec, 4, &len);
name_buf = mem_heap_alloc(heap, len + 1);
ut_memcpy(name_buf, field, len);
name_buf[len] = '\0';
name = name_buf;
name = mem_heap_strdupl(heap, field, len);
field = rec_get_nth_field(rec, 5, &len);
mtype = mach_read_from_4(field);
@ -393,6 +384,27 @@ dict_load_columns(
mtr_commit(&mtr);
}
/************************************************************************
Report that an index field or index for a table has been delete marked. */
static
void
dict_load_report_deleted_index(
char* name, /* in: table name */
ulint field) /* in: index field, or ULINT_UNDEFINED */
{
fputs("InnoDB: Error: data dictionary entry"
" for table ", stderr);
ut_print_name(stderr, name);
fputs(" is corrupt!\n", stderr);
if (field != ULINT_UNDEFINED) {
fprintf(stderr,
"InnoDB: Index field %lu is delete marked.\n", field);
}
else {
fputs("InnoDB: An index is delete marked.\n", stderr);
}
}
/************************************************************************
Loads definitions for index fields. */
static
@ -408,7 +420,6 @@ dict_load_fields(
btr_pcur_t pcur;
dtuple_t* tuple;
dfield_t* dfield;
char* col_name;
ulint pos_and_prefix_len;
ulint prefix_len;
rec_t* rec;
@ -446,10 +457,7 @@ dict_load_fields(
ut_a(btr_pcur_is_on_user_rec(&pcur, &mtr));
if (rec_get_deleted_flag(rec)) {
fprintf(stderr,
"InnoDB: Error: data dictionary entry for table %s is corrupt!\n"
"InnoDB: An index field is delete marked.\n",
table->name);
dict_load_report_deleted_index(table->name, i);
}
field = rec_get_nth_field(rec, 0, &len);
@ -487,11 +495,8 @@ dict_load_fields(
field = rec_get_nth_field(rec, 4, &len);
col_name = mem_heap_alloc(heap, len + 1);
ut_memcpy(col_name, field, len);
col_name[len] = '\0';
dict_mem_index_add_field(index, col_name, 0, prefix_len);
dict_mem_index_add_field(index,
mem_heap_strdupl(heap, field, len), 0, prefix_len);
btr_pcur_move_to_next_user_rec(&pcur, &mtr);
}
@ -575,10 +580,8 @@ dict_load_indexes(
}
if (rec_get_deleted_flag(rec)) {
fprintf(stderr,
"InnoDB: Error: data dictionary entry for table %s is corrupt!\n"
"InnoDB: An index is delete marked.\n",
table->name);
dict_load_report_deleted_index(table->name,
ULINT_UNDEFINED);
btr_pcur_close(&pcur);
mtr_commit(&mtr);
@ -596,10 +599,7 @@ dict_load_indexes(
dict_table_get_first_index(sys_indexes), 4))->name));
field = rec_get_nth_field(rec, 4, &name_len);
name_buf = mem_heap_alloc(heap, name_len + 1);
ut_memcpy(name_buf, field, name_len);
name_buf[name_len] = '\0';
name_buf = mem_heap_strdupl(heap, field, name_len);
field = rec_get_nth_field(rec, 5, &len);
n_fields = mach_read_from_4(field);
@ -620,10 +620,12 @@ dict_load_indexes(
if (page_no == FIL_NULL) {
fprintf(stderr,
"InnoDB: Error: trying to load index %s for table %s\n"
"InnoDB: but the index tree has been freed!\n",
name_buf, table->name);
fputs("InnoDB: Error: trying to load index ", stderr);
ut_print_name(stderr, name_buf);
fputs(" for table ", stderr);
ut_print_name(stderr, table->name);
fputs("\n"
"InnoDB: but the index tree has been freed!\n", stderr);
btr_pcur_close(&pcur);
mtr_commit(&mtr);
@ -634,10 +636,12 @@ dict_load_indexes(
if ((type & DICT_CLUSTERED) == 0
&& NULL == dict_table_get_first_index(table)) {
fprintf(stderr,
"InnoDB: Error: trying to load index %s for table %s\n"
"InnoDB: but the first index was not clustered!\n",
name_buf, table->name);
fputs("InnoDB: Error: trying to load index ", stderr);
ut_print_namel(stderr, name_buf, name_len);
fputs(" for table ", stderr);
ut_print_name(stderr, table->name);
fputs("\n"
"InnoDB: but the first index is not clustered!\n", stderr);
btr_pcur_close(&pcur);
mtr_commit(&mtr);
@ -648,7 +652,7 @@ dict_load_indexes(
if (is_sys_table
&& ((type & DICT_CLUSTERED)
|| ((table == dict_sys->sys_tables)
&& (name_len == ut_strlen("ID_IND"))
&& (name_len == (sizeof "ID_IND") - 1)
&& (0 == ut_memcmp(name_buf, (char*) "ID_IND",
name_len))))) {
@ -702,7 +706,6 @@ dict_load_table(
rec_t* rec;
byte* field;
ulint len;
char* buf;
ulint space;
ulint n_cols;
ulint err;
@ -802,15 +805,13 @@ dict_load_table(
if (table->type == DICT_TABLE_CLUSTER_MEMBER) {
ut_error;
#if 0 /* clustered tables have not been implemented yet */
field = rec_get_nth_field(rec, 6, &len);
table->mix_id = mach_read_from_8(field);
field = rec_get_nth_field(rec, 8, &len);
buf = mem_heap_alloc(heap, len);
ut_memcpy(buf, field, len);
table->cluster_name = buf;
table->cluster_name = mem_heap_strdupl(heap, field, len);
#endif
}
if ((table->type == DICT_TABLE_CLUSTER)
@ -879,7 +880,6 @@ dict_load_table_on_id(
byte* field;
ulint len;
dict_table_t* table;
char* name;
mtr_t mtr;
#ifdef UNIV_SYNC_DEBUG
@ -942,13 +942,8 @@ dict_load_table_on_id(
/* Now we get the table name from the record */
field = rec_get_nth_field(rec, 1, &len);
name = mem_heap_alloc(heap, len + 1);
ut_memcpy(name, field, len);
name[len] = '\0';
/* Load the table definition to memory */
table = dict_load_table(name);
table = dict_load_table(mem_heap_strdupl(heap, field, len));
btr_pcur_close(&pcur);
mtr_commit(&mtr);
@ -995,7 +990,6 @@ dict_load_foreign_cols(
btr_pcur_t pcur;
dtuple_t* tuple;
dfield_t* dfield;
char* col_name;
rec_t* rec;
byte* field;
ulint len;
@ -1040,20 +1034,12 @@ dict_load_foreign_cols(
ut_a(i == mach_read_from_4(field));
field = rec_get_nth_field(rec, 4, &len);
col_name = mem_heap_alloc(foreign->heap, len + 1);
ut_memcpy(col_name, field, len);
col_name[len] = '\0';
foreign->foreign_col_names[i] = col_name;
foreign->foreign_col_names[i] =
mem_heap_strdupl(foreign->heap, field, len);
field = rec_get_nth_field(rec, 5, &len);
col_name = mem_heap_alloc(foreign->heap, len + 1);
ut_memcpy(col_name, field, len);
col_name[len] = '\0';
foreign->referenced_col_names[i] = col_name;
foreign->referenced_col_names[i] =
mem_heap_strdupl(foreign->heap, field, len);
btr_pcur_move_to_next_user_rec(&pcur, &mtr);
}
@ -1110,8 +1096,10 @@ dict_load_foreign(
|| rec_get_deleted_flag(rec)) {
/* Not found */
fprintf(stderr,
"InnoDB: Error A: cannot load foreign constraint %s\n", id);
fputs("InnoDB: Error A: cannot load foreign constraint ",
stderr);
ut_print_name(stderr, id);
putc('\n', stderr);
btr_pcur_close(&pcur);
mtr_commit(&mtr);
@ -1125,8 +1113,10 @@ dict_load_foreign(
/* Check if the id in record is the searched one */
if (len != ut_strlen(id) || ut_memcmp(id, field, len) != 0) {
fprintf(stderr,
"InnoDB: Error B: cannot load foreign constraint %s\n", id);
fputs("InnoDB: Error B: cannot load foreign constraint ",
stderr);
ut_print_name(stderr, id);
putc('\n', stderr);
btr_pcur_close(&pcur);
mtr_commit(&mtr);
@ -1151,23 +1141,15 @@ dict_load_foreign(
foreign->type = foreign->n_fields >> 24;
foreign->n_fields = foreign->n_fields & 0xFFFFFFUL;
foreign->id = mem_heap_alloc(foreign->heap, ut_strlen(id) + 1);
ut_memcpy(foreign->id, id, ut_strlen(id) + 1);
foreign->id = mem_heap_strdup(foreign->heap, id);
field = rec_get_nth_field(rec, 3, &len);
foreign->foreign_table_name = mem_heap_alloc(foreign->heap, 1 + len);
ut_memcpy(foreign->foreign_table_name, field, len);
foreign->foreign_table_name[len] = '\0';
foreign->foreign_table_name =
mem_heap_strdupl(foreign->heap, field, len);
field = rec_get_nth_field(rec, 4, &len);
foreign->referenced_table_name = mem_heap_alloc(foreign->heap,
1 + len);
ut_memcpy(foreign->referenced_table_name, field, len);
foreign->referenced_table_name[len] = '\0';
foreign->referenced_table_name =
mem_heap_strdupl(foreign->heap, field, len);
btr_pcur_close(&pcur);
mtr_commit(&mtr);
@ -1281,10 +1263,7 @@ loop:
/* Now we get a foreign key constraint id */
field = rec_get_nth_field(rec, 1, &len);
id = mem_heap_alloc(heap, len + 1);
ut_memcpy(id, field, len);
id[len] = '\0';
id = mem_heap_strdupl(heap, field, len);
btr_pcur_store_position(&pcur, &mtr);

71
innobase/dict/dict0mem.c
View File

@ -49,9 +49,7 @@ dict_mem_table_create(
table->heap = heap;
str = mem_heap_alloc(heap, 1 + ut_strlen(name));
ut_strcpy(str, name);
str = mem_heap_strdup(heap, name);
table->type = DICT_TABLE_ORDINARY;
table->name = str;
@ -148,7 +146,6 @@ dict_mem_table_add_col(
ulint len, /* in: length */
ulint prec) /* in: precision */
{
char* str;
dict_col_t* col;
dtype_t* type;
@ -159,12 +156,8 @@ dict_mem_table_add_col(
col = dict_table_get_nth_col(table, table->n_def - 1);
str = mem_heap_alloc(table->heap, 1 + ut_strlen(name));
ut_strcpy(str, name);
col->ind = table->n_def - 1;
col->name = str;
col->name = mem_heap_strdup(table->heap, name);
col->table = table;
col->ord_part = 0;
@ -190,7 +183,6 @@ dict_mem_index_create(
ulint type, /* in: DICT_UNIQUE, DICT_CLUSTERED, ... ORed */
ulint n_fields) /* in: number of fields */
{
char* str;
dict_index_t* index;
mem_heap_t* heap;
@ -201,13 +193,9 @@ dict_mem_index_create(
index->heap = heap;
str = mem_heap_alloc(heap, 1 + ut_strlen(index_name));
ut_strcpy(str, index_name);
index->type = type;
index->space = space;
index->name = str;
index->name = mem_heap_strdup(heap, index_name);
index->table_name = table_name;
index->table = NULL;
index->n_def = 0;
@ -303,56 +291,3 @@ dict_mem_index_free(
{
mem_heap_free(index->heap);
}
/**************************************************************************
Creates a procedure memory object. */
dict_proc_t*
dict_mem_procedure_create(
/*======================*/
/* out, own: procedure object */
char* name, /* in: procedure name */
char* sql_string, /* in: procedure definition as an SQL
string */
que_fork_t* graph) /* in: parsed procedure graph */
{
dict_proc_t* proc;
proc_node_t* proc_node;
mem_heap_t* heap;
char* str;
ut_ad(name);
heap = mem_heap_create(128);
proc = mem_heap_alloc(heap, sizeof(dict_proc_t));
proc->heap = heap;
str = mem_heap_alloc(heap, 1 + ut_strlen(name));
ut_strcpy(str, name);
proc->name = str;
str = mem_heap_alloc(heap, 1 + ut_strlen(sql_string));
ut_strcpy(str, sql_string);
proc->sql_string = str;
UT_LIST_INIT(proc->graphs);
/* UT_LIST_ADD_LAST(graphs, proc->graphs, graph); */
#ifdef UNIV_DEBUG
UT_LIST_VALIDATE(graphs, que_t, proc->graphs);
#endif
proc->mem_fix = 0;
proc_node = que_fork_get_child(graph);
proc_node->dict_proc = proc;
return(proc);
}

60
innobase/eval/eval0eval.c
View File

@ -311,12 +311,13 @@ eval_predefined_2(
arg = que_node_get_next(arg);
}
printf("\n");
putc('\n', stderr);
} else if (func == PARS_ASSERT_TOKEN) {
if (!eval_node_get_ibool_val(arg1)) {
printf("SQL assertion fails in a stored procedure!\n");
fputs("SQL assertion fails in a stored procedure!\n",
stderr);
}
ut_a(eval_node_get_ibool_val(arg1));
@ -667,7 +668,6 @@ eval_predefined(
{
que_node_t* arg1;
lint int_val;
byte* str1;
byte* data;
int func;
@ -681,21 +681,63 @@ eval_predefined(
} else if (func == PARS_TO_CHAR_TOKEN) {
/* Convert number to character string as a
signed decimal integer. */
ulint uint_val;
int int_len;
int_val = eval_node_get_int_val(arg1);
data = eval_node_ensure_val_buf(func_node, 11);
/* Determine the length of the string. */
sprintf((char*)data, "%10li", int_val);
if (int_val == 0) {
int_len = 1; /* the number 0 occupies 1 byte */
} else {
int_len = 0;
if (int_val < 0) {
uint_val = ((ulint) -int_val - 1) + 1;
int_len++; /* reserve space for minus sign */
} else {
uint_val = (ulint) int_val;
}
for (; uint_val > 0; int_len++) {
uint_val /= 10;
}
}
dfield_set_len(que_node_get_val(func_node), 10);
/* allocate the string */
data = eval_node_ensure_val_buf(func_node, int_len + 1);
/* add terminating NUL character */
data[int_len] = 0;
/* convert the number */
if (int_val == 0) {
data[0] = '0';
} else {
int tmp;
if (int_val < 0) {
data[0] = '-'; /* preceding minus sign */
uint_val = ((ulint) -int_val - 1) + 1;
} else {
uint_val = (ulint) int_val;
}
for (tmp = int_len; uint_val > 0; uint_val /= 10) {
data[--tmp] = '0' + (uint_val % 10);
}
}
dfield_set_len((dfield_t*) que_node_get_val(func_node),
int_len);
return;
} else if (func == PARS_TO_NUMBER_TOKEN) {
str1 = dfield_get_data(que_node_get_val(arg1));
int_val = atoi((char*)str1);
int_val = atoi((char*)
dfield_get_data(que_node_get_val(arg1)));
} else if (func == PARS_SYSDATE_TOKEN) {
int_val = (lint)ut_time();

39
innobase/fil/fil0fil.c
View File

@ -86,7 +86,7 @@ the count drops to zero. */
/* When mysqld is run, the default directory "." is the mysqld datadir,
but in the MySQL Embedded Server Library and ibbackup it is not the default
directory, and we must set the base file path explicitly */
char* fil_path_to_mysql_datadir = (char*)".";
const char* fil_path_to_mysql_datadir = ".";
ulint fil_n_pending_log_flushes = 0;
ulint fil_n_pending_tablespace_flushes = 0;
@ -399,7 +399,6 @@ fil_node_create(
fil_system_t* system = fil_system;
fil_node_t* node;
fil_space_t* space;
char* name2;
ut_a(system);
ut_a(name);
@ -408,11 +407,7 @@ fil_node_create(
node = mem_alloc(sizeof(fil_node_t));
name2 = mem_alloc(ut_strlen(name) + 1);
ut_strcpy(name2, name);
node->name = name2;
node->name = mem_strdup(name);
node->open = FALSE;
ut_a(!is_raw || srv_start_raw_disk_in_use);
@ -433,7 +428,7 @@ fil_node_create(
fprintf(stderr,
" InnoDB: Error: Could not find tablespace %lu for\n"
"InnoDB: file %s from the tablespace memory cache.\n", (ulong) id, name);
mem_free(name2);
mem_free(node->name);
mem_free(node);
@ -816,7 +811,6 @@ fil_space_create(
{
fil_system_t* system = fil_system;
fil_space_t* space;
char* name2;
ulint namesake_id;
try_again:
/*printf(
@ -881,11 +875,7 @@ try_again:
space = mem_alloc(sizeof(fil_space_t));
name2 = mem_alloc(ut_strlen(name) + 1);
ut_strcpy(name2, name);
space->name = name2;
space->name = mem_strdup(name);
space->id = id;
system->tablespace_version++;
@ -2737,7 +2727,7 @@ fil_load_single_table_tablespaces(void)
/* The datadir of MySQL is always the default directory of mysqld */
dir = os_file_opendir(fil_path_to_mysql_datadir, TRUE);
dir = os_file_opendir((char*) fil_path_to_mysql_datadir, TRUE);
if (dir == NULL) {
@ -2749,7 +2739,7 @@ fil_load_single_table_tablespaces(void)
/* Scan all directories under the datadir. They are the database
directories of MySQL. */
ret = os_file_readdir_next_file(fil_path_to_mysql_datadir, dir,
ret = os_file_readdir_next_file((char*) fil_path_to_mysql_datadir, dir,
&dbinfo);
while (ret == 0) {
/* printf("Looking at %s in datadir\n", dbinfo.name); */
@ -2810,7 +2800,7 @@ next_file_item:
}
next_datadir_item:
ret = os_file_readdir_next_file(fil_path_to_mysql_datadir,
ret = os_file_readdir_next_file((char*) fil_path_to_mysql_datadir,
dir, &dbinfo);
}
@ -3726,7 +3716,7 @@ fil_aio_wait(
ut_ad(fil_validate());
if (os_aio_use_native_aio) {
srv_io_thread_op_info[segment] = (char *) "handle native aio";
srv_set_io_thread_op_info(segment, "native aio handle");
#ifdef WIN_ASYNC_IO
ret = os_aio_windows_handle(segment, 0, (void**) &fil_node,
&message, &type);
@ -3737,7 +3727,7 @@ fil_aio_wait(
ut_error;
#endif
} else {
srv_io_thread_op_info[segment] =(char *)"handle simulated aio";
srv_set_io_thread_op_info(segment, "simulated aio handle");
ret = os_aio_simulated_handle(segment, (void**) &fil_node,
&message, &type);
@ -3745,7 +3735,7 @@ fil_aio_wait(
ut_a(ret);
srv_io_thread_op_info[segment] = (char *) "complete io for fil node";
srv_set_io_thread_op_info(segment, "complete io for fil node");
mutex_enter(&(system->mutex));
@ -3762,11 +3752,10 @@ fil_aio_wait(
open, and use a special i/o thread to serve insert buffer requests. */
if (buf_pool_is_block(message)) {
srv_io_thread_op_info[segment] =
(char *) "complete io for buf page";
srv_set_io_thread_op_info(segment, "complete io for buf page");
buf_page_io_complete(message);
} else {
srv_io_thread_op_info[segment] =(char *) "complete io for log";
srv_set_io_thread_op_info(segment, "complete io for log");
log_io_complete(message);
}
}
@ -3847,7 +3836,9 @@ retry:
mutex_exit(&(system->mutex));
/* printf("Flushing to file %s\n", node->name); */
/* fprintf(stderr, "Flushing to file %s\n",
node->name); */
os_file_flush(file);
mutex_enter(&(system->mutex));

99
innobase/fsp/fsp0fsp.c
View File

@ -1426,7 +1426,7 @@ fsp_alloc_free_page(
hint % FSP_EXTENT_SIZE, mtr);
if (free == ULINT_UNDEFINED) {
ut_print_buf(((byte*)descr) - 500, 1000);
ut_print_buf(stderr, ((byte*)descr) - 500, 1000);
ut_error;
}
@ -1507,11 +1507,10 @@ fsp_free_page(
xdes_t* descr;
ulint state;
ulint frag_n_used;
char buf[1000];
ut_ad(mtr);
/* printf("Freeing page %lu in space %lu\n", page, space); */
/* fprintf(stderr, "Freeing page %lu in space %lu\n", page, space); */
header = fsp_get_space_header(space, mtr);
@ -1524,9 +1523,9 @@ fsp_free_page(
"InnoDB: Error: File space extent descriptor of page %lu has state %lu\n",
(ulong) page,
(ulong) state);
ut_sprintf_buf(buf, ((byte*)descr) - 50, 200);
fprintf(stderr, "InnoDB: Dump of descriptor: %s\n", buf);
fputs("InnoDB: Dump of descriptor: ", stderr);
ut_print_buf(stderr, ((byte*)descr) - 50, 200);
putc('\n', stderr);
if (state == XDES_FREE) {
/* We put here some fault tolerance: if the page
@ -1538,14 +1537,12 @@ fsp_free_page(
ut_error;
}
if (xdes_get_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, mtr)
== TRUE) {
if (xdes_get_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, mtr)) {
fprintf(stderr,
"InnoDB: Error: File space extent descriptor of page %lu says it is free\n",
(ulong) page);
ut_sprintf_buf(buf, ((byte*)descr) - 50, 200);
fprintf(stderr, "InnoDB: Dump of descriptor: %s\n", buf);
"InnoDB: Error: File space extent descriptor of page %lu says it is free\n"
"InnoDB: Dump of descriptor: ", (ulong) page);
ut_print_buf(stderr, ((byte*)descr) - 50, 200);
putc('\n', stderr);
/* We put here some fault tolerance: if the page
is already free, return without doing anything! */
@ -1603,7 +1600,7 @@ fsp_free_extent(
if (xdes_get_state(descr, mtr) == XDES_FREE) {
ut_print_buf(((byte*)descr) - 500, 1000);
ut_print_buf(stderr, (byte*)descr - 500, 1000);
ut_error;
}
@ -2949,7 +2946,6 @@ fseg_free_page_low(
dulint descr_id;
dulint seg_id;
ulint i;
char errbuf[200];
ut_ad(seg_inode && mtr);
ut_ad(mach_read_from_4(seg_inode + FSEG_MAGIC_N) ==
@ -2963,22 +2959,22 @@ fseg_free_page_low(
descr = xdes_get_descriptor(space, page, mtr);
ut_a(descr);
if (xdes_get_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, mtr)
!= FALSE) {
ut_sprintf_buf(errbuf, descr, 40);
fprintf(stderr,
"InnoDB: Dump of the tablespace extent descriptor: %s\n", errbuf);
if (xdes_get_bit(descr, XDES_FREE_BIT, page % FSP_EXTENT_SIZE, mtr)) {
fputs("InnoDB: Dump of the tablespace extent descriptor: ",
stderr);
ut_print_buf(stderr, descr, 40);
fprintf(stderr,
fprintf(stderr, "\n"
"InnoDB: Serious error! InnoDB is trying to free page %lu\n"
"InnoDB: though it is already marked as free in the tablespace!\n"
"InnoDB: The tablespace free space info is corrupt.\n"
"InnoDB: You may need to dump your InnoDB tables and recreate the whole\n"
"InnoDB: database!\n", (ulong) page);
fprintf(stderr,
crash:
fputs(
"InnoDB: If the InnoDB recovery crashes here, see section 6.1\n"
"InnoDB: of http://www.innodb.com/ibman.html about forcing recovery.\n");
"InnoDB: of http://www.innodb.com/ibman.php about forcing recovery.\n",
stderr);
ut_error;
}
@ -3018,12 +3014,12 @@ fseg_free_page_low(
ut_dulint_get_low(seg_id));
*/
if (0 != ut_dulint_cmp(descr_id, seg_id)) {
ut_sprintf_buf(errbuf, descr, 40);
fprintf(stderr,
"InnoDB: Dump of the tablespace extent descriptor: %s\n", errbuf);
ut_sprintf_buf(errbuf, seg_inode, 40);
fprintf(stderr,
"InnoDB: Dump of the segment inode: %s\n", errbuf);
fputs("InnoDB: Dump of the tablespace extent descriptor: ",
stderr);
ut_print_buf(stderr, descr, 40);
fputs("\nInnoDB: Dump of the segment inode: ", stderr);
ut_print_buf(stderr, seg_inode, 40);
putc('\n', stderr);
fprintf(stderr,
"InnoDB: Serious error: InnoDB is trying to free space %lu page %lu,\n"
@ -3034,11 +3030,7 @@ fseg_free_page_low(
(ulong) ut_dulint_get_low(descr_id),
(ulong) ut_dulint_get_high(seg_id),
(ulong) ut_dulint_get_low(seg_id));
fprintf(stderr,
"InnoDB: If the InnoDB recovery crashes here, see section 6.1\n"
"InnoDB: of http://www.innodb.com/ibman.html about forcing recovery.\n");
ut_error;
goto crash;
}
not_full_n_used = mtr_read_ulint(seg_inode + FSEG_NOT_FULL_N_USED,
@ -3485,6 +3477,7 @@ fseg_validate_low(
return(TRUE);
}
#ifdef UNIV_DEBUG
/***********************************************************************
Validates a segment. */
@ -3509,6 +3502,7 @@ fseg_validate(
return(ret);
}
#endif /* UNIV_DEBUG */
/***********************************************************************
Writes info of a segment. */
@ -3551,17 +3545,16 @@ fseg_print_low(
n_not_full = flst_get_len(inode + FSEG_NOT_FULL, mtr);
n_full = flst_get_len(inode + FSEG_FULL, mtr);
printf(
"SEGMENT id %lu %lu space %lu; page %lu; res %lu used %lu; full ext %lu\n",
(ulong) seg_id_high, (ulong) seg_id_low, (ulong) space,
(ulong) page_no, (ulong) reserved, (ulong) used,
(ulong) n_full);
printf(
"fragm pages %lu; free extents %lu; not full extents %lu: pages %lu\n",
fprintf(stderr,
"SEGMENT id %lu %lu space %lu; page %lu; res %lu used %lu; full ext %lu\n"
"fragm pages %lu; free extents %lu; not full extents %lu: pages %lu\n",
(ulong) seg_id_high, (ulong) seg_id_low, (ulong) space, (ulong) page_no,
(ulong) reserved, (ulong) used, (ulong) n_full,
(ulong) n_frag, (ulong) n_free, (ulong) n_not_full,
(ulong) n_used);
}
#ifdef UNIV_DEBUG
/***********************************************************************
Writes info of a segment. */
@ -3582,6 +3575,7 @@ fseg_print(
fseg_print_low(inode, mtr);
}
#endif /* UNIV_DEBUG */
/***********************************************************************
Validates the file space system and its segments. */
@ -3862,16 +3856,15 @@ fsp_print(
seg_id_low = ut_dulint_get_low(d_var);
seg_id_high = ut_dulint_get_high(d_var);
printf("FILE SPACE INFO: id %lu\n", (ulong) space);
printf("size %lu, free limit %lu, free extents %lu\n",
(ulong) size, (ulong) free_limit, (ulong) n_free);
printf(
"not full frag extents %lu: used pages %lu, full frag extents %lu\n",
(ulong) n_free_frag, (ulong) frag_n_used, (ulong) n_full_frag);
printf("first seg id not used %lu %lu\n", (ulong) seg_id_high,
(ulong) seg_id_low);
fprintf(stderr,
"FILE SPACE INFO: id %lu\n"
"size %lu, free limit %lu, free extents %lu\n"
"not full frag extents %lu: used pages %lu, full frag extents %lu\n"
"first seg id not used %lu %lu\n",
(long) space,
(ulong) size, (ulong) free_limit, (ulong) n_free,
(ulong) n_free_frag, (ulong) frag_n_used, (ulong) n_full_frag,
(ulong) seg_id_high, (ulong) seg_id_low);
mtr_commit(&mtr);
@ -3950,5 +3943,5 @@ fsp_print(
mtr_commit(&mtr2);
printf("NUMBER of file segments: %lu\n", (ulong) n_segs);
fprintf(stderr, "NUMBER of file segments: %lu\n", (ulong) n_segs);
}

7
innobase/fut/fut0lst.c
View File

@ -490,6 +490,7 @@ flst_validate(
return(TRUE);
}
#ifdef UNIV_DEBUG
/************************************************************************
Prints info of a file-based list. */
@ -509,9 +510,11 @@ flst_print(
len = flst_get_len(base, mtr);
printf("FILE-BASED LIST:\n");
printf("Base node in space %lu page %lu byte offset %lu; len %lu\n",
fprintf(stderr,
"FILE-BASED LIST:\n"
"Base node in space %lu page %lu byte offset %lu; len %lu\n",
(ulong) buf_frame_get_space_id(frame),
(ulong) buf_frame_get_page_no(frame),
(ulong) (base - frame), (ulong) len);
}
#endif /* UNIV_DEBUG */

40
innobase/ha/ha0ha.c
View File

@ -317,23 +317,14 @@ Prints info of a hash table. */
void
ha_print_info(
/*==========*/
char* buf, /* in/out: buffer where to print */
char* buf_end,/* in: buffer end */
FILE* file, /* in: file where to print */
hash_table_t* table) /* in: hash table */
{
hash_cell_t* cell;
/* ha_node_t* node;
ulint nodes = 0;
ulint len = 0;
ulint max_len = 0; */
ulint cells = 0;
ulint n_bufs;
ulint i;
if (buf_end - buf < 200) {
return;
}
for (i = 0; i < hash_get_n_cells(table); i++) {
cell = hash_get_nth_cell(table, i);
@ -341,33 +332,12 @@ ha_print_info(
if (cell->node) {
cells++;
/*
len = 0;
node = cell->node;
for (;;) {
len++;
nodes++;
if (ha_chain_get_next(table, node) == NULL) {
break;
}
node = node->next;
}
if (len > max_len) {
max_len = len;
}
*/
}
}
buf += sprintf(buf,
"Hash table size %lu, used cells %lu", (ulong) hash_get_n_cells(table),
(ulong) cells);
fprintf(file,
"Hash table size %lu, used cells %lu",
(ulong) hash_get_n_cells(table), (ulong) cells);
if (table->heaps == NULL && table->heap != NULL) {
@ -380,6 +350,6 @@ ha_print_info(
n_bufs++;
}
buf += sprintf(buf, ", node heap has %lu buffer(s)\n", (ulong) n_bufs);
fprintf(file, ", node heap has %lu buffer(s)\n", (ulong) n_bufs);
}
}

172
innobase/ibuf/ibuf0ibuf.c
View File

@ -131,9 +131,10 @@ access order rules. */
#define IBUF_POOL_SIZE_PER_MAX_SIZE 2
/* The insert buffer control structure */
ibuf_t* ibuf = NULL;
ibuf_t* ibuf = NULL;
ulint ibuf_rnd = 986058871;
static
ulint ibuf_rnd = 986058871;
ulint ibuf_flush_count = 0;
@ -142,9 +143,9 @@ ulint ibuf_flush_count = 0;
#define IBUF_COUNT_N_PAGES 2000
/* Buffered entry counts for file pages, used in debugging */
ulint* ibuf_counts[IBUF_COUNT_N_SPACES];
static ulint* ibuf_counts[IBUF_COUNT_N_SPACES];
ibool ibuf_counts_inited = FALSE;
static ibool ibuf_counts_inited = FALSE;
/* The start address for an insert buffer bitmap page bitmap */
#define IBUF_BITMAP PAGE_DATA
@ -158,15 +159,18 @@ ibool ibuf_counts_inited = FALSE;
/* Number of bits describing a single page */
#define IBUF_BITS_PER_PAGE 4
#if IBUF_BITS_PER_PAGE % 2
# error "IBUF_BITS_PER_PAGE must be an even number!"
#endif
/* The mutex used to block pessimistic inserts to ibuf trees */
mutex_t ibuf_pessimistic_insert_mutex;
static mutex_t ibuf_pessimistic_insert_mutex;
/* The mutex protecting the insert buffer structs */
mutex_t ibuf_mutex;
static mutex_t ibuf_mutex;
/* The mutex protecting the insert buffer bitmaps */
mutex_t ibuf_bitmap_mutex;
static mutex_t ibuf_bitmap_mutex;
/* The area in pages from which contract looks for page numbers for merge */
#define IBUF_MERGE_AREA 8
@ -197,13 +201,15 @@ because ibuf merge is done to a page when it is read in, and it is
still physically like the index page even if the index would have been
dropped! So, there seems to be no problem. */
#ifdef UNIV_DEBUG
/**********************************************************************
Validates the ibuf data structures when the caller owns ibuf_mutex. */
static
ibool
ibuf_validate_low(void);
/*===================*/
/* out: TRUE if ok */
#endif /* UNIV_DEBUG */
/**********************************************************************
Sets the flag in the current OS thread local storage denoting that it is
@ -326,9 +332,9 @@ ibuf_count_get(
return(*(ibuf_counts[space] + page_no));
}
#ifdef UNIV_IBUF_DEBUG
/**********************************************************************
Sets the ibuf count for a given page. */
#ifdef UNIV_IBUF_DEBUG
static
void
ibuf_count_set(
@ -437,7 +443,7 @@ ibuf_data_sizes_update(
ibuf->size = ibuf->size + data->size - old_size;
/* printf("ibuf size %lu, space ibuf size %lu\n", ibuf->size,
/* fprintf(stderr, "ibuf size %lu, space ibuf size %lu\n", ibuf->size,
data->size); */
}
@ -468,7 +474,7 @@ ibuf_data_init_for_space(
#ifdef UNIV_LOG_DEBUG
if (space % 2 == 1) {
printf("No ibuf op in replicate space\n");
fputs("No ibuf op in replicate space\n", stderr);
return(NULL);
}
@ -766,7 +772,8 @@ ibuf_set_free_bits_low(
bitmap_page = ibuf_bitmap_get_map_page(buf_frame_get_space_id(page),
buf_frame_get_page_no(page), mtr);
#ifdef UNIV_IBUF_DEBUG
/* printf("Setting page no %lu free bits to %lu should be %lu\n",
/* fprintf(stderr,
"Setting page no %lu free bits to %lu should be %lu\n",
buf_frame_get_page_no(page), val,
ibuf_index_page_calc_free(page)); */
@ -820,7 +827,7 @@ ibuf_set_free_bits(
buf_frame_get_page_no(page),
IBUF_BITMAP_FREE, &mtr);
if (old_val != max_val) {
/* printf(
/* fprintf(stderr,
"Ibuf: page %lu old val %lu max val %lu\n",
buf_frame_get_page_no(page), old_val, max_val); */
}
@ -829,7 +836,7 @@ ibuf_set_free_bits(
#endif
}
#ifdef UNIV_IBUF_DEBUG
/* printf("Setting page no %lu free bits to %lu should be %lu\n",
/* fprintf(stderr, "Setting page no %lu free bits to %lu should be %lu\n",
buf_frame_get_page_no(page), val,
ibuf_index_page_calc_free(page)); */
@ -1014,7 +1021,7 @@ ibuf_page_low(
#ifdef UNIV_LOG_DEBUG
if (space % 2 != 0) {
printf("No ibuf in a replicate space\n");
fputs("No ibuf in a replicate space\n", stderr);
return(FALSE);
}
@ -1735,7 +1742,8 @@ ibuf_free_excess_pages(
/* Not yet initialized */
#ifdef UNIV_DEBUG
/*printf("Ibuf for space %lu not yet initialized\n", space); */
/*fprintf(stderr,
"Ibuf for space %lu not yet initialized\n", space); */
#endif
return;
@ -1933,7 +1941,7 @@ ibuf_get_merge_page_nos(
#ifdef UNIV_IBUF_DEBUG
ut_a(*n_stored <= IBUF_MAX_N_PAGES_MERGED);
#endif
/* printf("Ibuf merge batch %lu pages %lu volume\n", *n_stored,
/* fprintf(stderr, "Ibuf merge batch %lu pages %lu volume\n", *n_stored,
sum_volumes); */
return(sum_volumes);
}
@ -2044,8 +2052,8 @@ loop:
space_ids, space_versions, page_nos,
&n_stored);
#ifdef UNIV_IBUF_DEBUG
/* printf("Ibuf contract sync %lu pages %lu volume %lu\n", sync,
n_stored, sum_sizes); */
/* fprintf(stderr, "Ibuf contract sync %lu pages %lu volume %lu\n",
sync, n_stored, sum_sizes); */
#endif
ibuf_exit();
@ -2431,7 +2439,7 @@ ibuf_insert_low(
mutex_exit(&ibuf_mutex);
#ifdef UNIV_IBUF_DEBUG
printf("Ibuf too big\n");
fputs("Ibuf too big\n", stderr);
#endif
/* Use synchronous contract (== TRUE) */
ibuf_contract(TRUE);
@ -2664,8 +2672,8 @@ ibuf_insert(
if (err == DB_SUCCESS) {
#ifdef UNIV_IBUF_DEBUG
/* printf("Ibuf insert for page no %lu of index %s\n", page_no,
index->name); */
/* fprintf(stderr, "Ibuf insert for page no %lu of index %s\n",
page_no, index->name); */
#endif
return(TRUE);
@ -2693,7 +2701,6 @@ ibuf_insert_to_index_page(
rec_t* rec;
page_t* bitmap_page;
ulint old_bits;
char errbuf[1000];
ut_ad(ibuf_inside());
ut_ad(dtuple_check_typed(entry));
@ -2703,17 +2710,17 @@ ibuf_insert_to_index_page(
fprintf(stderr,
"InnoDB: Trying to insert a record from the insert buffer to an index page\n"
"InnoDB: but the number of fields does not match!\n%s\n", errbuf);
"InnoDB: but the number of fields does not match!\n");
buf_page_print(page);
dtuple_sprintf(errbuf, 900, entry);
dtuple_print(stderr, entry);
fprintf(stderr,
fputs(
"InnoDB: The table where where this index record belongs\n"
"InnoDB: is now probably corrupt. Please run CHECK TABLE on\n"
"InnoDB: your tables.\n"
"InnoDB: Send a detailed bug report to mysql@lists.mysql.com!\n");
"InnoDB: Send a detailed bug report to mysql@lists.mysql.com!\n", stderr);
return;
}
@ -2743,14 +2750,14 @@ ibuf_insert_to_index_page(
"InnoDB: Error: Insert buffer insert fails; page free %lu, dtuple size %lu\n",
(ulong) page_get_max_insert_size(page, 1),
(ulong) rec_get_converted_size(entry));
dtuple_sprintf(errbuf, 900, entry);
fprintf(stderr,
"InnoDB: Cannot insert index record %s\n"
"InnoDB: The table where where this index record belongs\n"
fputs("InnoDB: Cannot insert index record ",
stderr);
dtuple_print(stderr, entry);
fputs(
"\nInnoDB: The table where where this index record belongs\n"
"InnoDB: is now probably corrupt. Please run CHECK TABLE on\n"
"InnoDB: that table.\n", errbuf);
"InnoDB: that table.\n", stderr);
bitmap_page = ibuf_bitmap_get_map_page(
buf_frame_get_space_id(page),
buf_frame_get_page_no(page),
@ -2762,8 +2769,8 @@ ibuf_insert_to_index_page(
fprintf(stderr, "Bitmap bits %lu\n", (ulong) old_bits);
fprintf(stderr,
"InnoDB: Send a detailed bug report to mysql@lists.mysql.com!\n");
fputs(
"InnoDB: Send a detailed bug report to mysql@lists.mysql.com!\n", stderr);
}
}
}
@ -2826,23 +2833,21 @@ ibuf_delete_rec(
if (!success) {
fprintf(stderr,
"InnoDB: ERROR: Send the output to mysql@lists.mysql.com\n"
"InnoDB: ibuf cursor restoration fails!\n"
"InnoDB: ibuf record inserted to space %lu page %lu\n", (ulong) space,
(ulong) page_no);
"InnoDB: ERROR: Send the output to mysql@lists.mysql.com\n"
"InnoDB: ibuf cursor restoration fails!\n"
"InnoDB: ibuf record inserted to page %lu\n", (ulong) page_no);
fflush(stderr);
rec_print(btr_pcur_get_rec(pcur));
rec_print(pcur->old_rec);
dtuple_print(search_tuple);
rec_print(stderr, btr_pcur_get_rec(pcur));
rec_print(stderr, pcur->old_rec);
dtuple_print(stderr, search_tuple);
rec_print(page_rec_get_next(btr_pcur_get_rec(pcur)));
fflush(stdout);
rec_print(stderr, page_rec_get_next(btr_pcur_get_rec(pcur)));
fflush(stderr);
btr_pcur_commit_specify_mtr(pcur, mtr);
fprintf(stderr,
"InnoDB: Validating insert buffer tree:\n");
fputs("InnoDB: Validating insert buffer tree:\n", stderr);
ut_a(btr_validate_tree(ibuf_data->index->tree));
fprintf(stderr, "InnoDB: ibuf tree ok\n");
@ -2902,20 +2907,16 @@ ibuf_merge_or_delete_for_page(
dtuple_t* entry;
dtuple_t* search_tuple;
rec_t* ibuf_rec;
ibool closed;
buf_block_t* block;
page_t* bitmap_page;
ibuf_data_t* ibuf_data;
ibool success;
ulint n_inserts;
#ifdef UNIV_IBUF_DEBUG
ulint volume;
ulint old_bits;
ulint new_bits;
dulint max_trx_id;
#endif
ibool tablespace_being_deleted = FALSE;
ibool corruption_noticed = FALSE;
mtr_t mtr;
char err_buf[500];
if (srv_force_recovery >= SRV_FORCE_NO_IBUF_MERGE) {
@ -2925,7 +2926,7 @@ ibuf_merge_or_delete_for_page(
#ifdef UNIV_LOG_DEBUG
if (space % 2 != 0) {
printf("No ibuf operation in a replicate space\n");
fputs("No ibuf operation in a replicate space\n", stderr);
return;
}
@ -3004,8 +3005,8 @@ ibuf_merge_or_delete_for_page(
mtr_start(&mtr);
fprintf(stderr,
" InnoDB: Dump of the ibuf bitmap page:\n");
fputs(" InnoDB: Dump of the ibuf bitmap page:\n",
stderr);
bitmap_page = ibuf_bitmap_get_map_page(space, page_no,
&mtr);
@ -3013,7 +3014,7 @@ ibuf_merge_or_delete_for_page(
mtr_commit(&mtr);
fprintf(stderr, "\nInnoDB: Dump of the page:\n");
fputs("\nInnoDB: Dump of the page:\n", stderr);
buf_page_print(page);
@ -3032,12 +3033,14 @@ ibuf_merge_or_delete_for_page(
}
n_inserts = 0;
#ifdef UNIV_IBUF_DEBUG
volume = 0;
#endif
loop:
mtr_start(&mtr);
if (page) {
success = buf_page_get_known_nowait(RW_X_LATCH, page,
ibool success = buf_page_get_known_nowait(RW_X_LATCH, page,
BUF_KEEP_OLD,
IB__FILE__, __LINE__,
&mtr);
@ -3072,9 +3075,9 @@ loop:
}
if (corruption_noticed) {
rec_sprintf(err_buf, 450, ibuf_rec);
fprintf(stderr,
"InnoDB: Discarding record\n %s\n from the insert buffer!\n\n", err_buf);
fputs("InnoDB: Discarding record\n ", stderr);
rec_print(stderr, ibuf_rec);
fputs("\n from the insert buffer!\n\n", stderr);
} else if (page) {
/* Now we have at pcur a record which should be
inserted to the index page; NOTE that the call below
@ -3082,7 +3085,7 @@ loop:
keep the latch to the ibuf_rec page until the
insertion is finished! */
max_trx_id = page_get_max_trx_id(
dulint max_trx_id = page_get_max_trx_id(
buf_frame_align(ibuf_rec));
page_update_max_trx_id(page, max_trx_id);
@ -3099,9 +3102,8 @@ loop:
n_inserts++;
/* Delete the record from ibuf */
closed = ibuf_delete_rec(space, page_no, &pcur, search_tuple,
&mtr);
if (closed) {
if (ibuf_delete_rec(space, page_no, &pcur, search_tuple,
&mtr)) {
/* Deletion was pessimistic and mtr was committed:
we start from the beginning again */
@ -3127,12 +3129,12 @@ reset_bit:
bitmap_page = ibuf_bitmap_get_map_page(space, page_no, &mtr);
ibuf_bitmap_page_set_bits(bitmap_page, page_no,
IBUF_BITMAP_BUFFERED, FALSE, &mtr);
if (page) {
old_bits = ibuf_bitmap_page_get_bits(bitmap_page,
page_no, IBUF_BITMAP_FREE, &mtr);
new_bits = ibuf_index_page_calc_free(page);
if (page) {
ulint old_bits = ibuf_bitmap_page_get_bits(bitmap_page,
page_no, IBUF_BITMAP_FREE, &mtr);
ulint new_bits = ibuf_index_page_calc_free(page);
#ifdef UNIV_IBUF_DEBUG
/* printf("Old bits %lu new bits %lu max size %lu\n",
/* fprintf(stderr, "Old bits %lu new bits %lu max size %lu\n",
old_bits, new_bits,
page_get_max_insert_size_after_reorganize(page, 1)); */
#endif
@ -3144,7 +3146,8 @@ reset_bit:
}
}
#ifdef UNIV_IBUF_DEBUG
/* printf("Ibuf merge %lu records volume %lu to page no %lu\n",
/* fprintf(stderr,
"Ibuf merge %lu records volume %lu to page no %lu\n",
n_inserts, volume, page_no); */
#endif
mtr_commit(&mtr);
@ -3276,9 +3279,10 @@ leave_loop:
mem_heap_free(heap);
}
#ifdef UNIV_DEBUG
/**********************************************************************
Validates the ibuf data structures when the caller owns ibuf_mutex. */
static
ibool
ibuf_validate_low(void)
/*===================*/
@ -3305,6 +3309,7 @@ ibuf_validate_low(void)
return(TRUE);
}
#endif /* UNIV_DEBUG */
/**********************************************************************
Looks if the insert buffer is empty. */
@ -3362,36 +3367,36 @@ Prints info of ibuf. */
void
ibuf_print(
/*=======*/
char* buf, /* in/out: buffer where to print */
char* buf_end)/* in: buffer end */
FILE* file) /* in: file where to print */
{
ibuf_data_t* data;
#ifdef UNIV_IBUF_DEBUG
ulint i;
#endif
if (buf_end - buf < 500) {
return;
}
mutex_enter(&ibuf_mutex);
data = UT_LIST_GET_FIRST(ibuf->data_list);
while (data) {
buf += sprintf(buf,
fprintf(file,
"Ibuf for space %lu: size %lu, free list len %lu, seg size %lu,",
(ulong) data->space, (ulong) data->size,
(ulong) data->free_list_len,
(ulong) data->seg_size);
if (data->empty) {
buf += sprintf(buf, " is empty\n");
fputs(" is empty\n", file);
} else {
buf += sprintf(buf, " is not empty\n");
fputs(" is not empty\n", file);
}
buf += sprintf(buf,
fprintf(file,
"Ibuf for space %lu: size %lu, free list len %lu, seg size %lu,\n"
"%lu inserts, %lu merged recs, %lu merges\n",
(ulong) data->space,
(ulong) data->size,
(ulong) data->free_list_len,
(ulong) data->seg_size,
(ulong) data->n_inserts,
(ulong) data->n_merged_recs,
(ulong) data->n_merges);
@ -3399,7 +3404,8 @@ ibuf_print(
for (i = 0; i < IBUF_COUNT_N_PAGES; i++) {
if (ibuf_count_get(data->space, i) > 0) {
printf("Ibuf count for page %lu is %lu\n",
fprintf(stderr,
"Ibuf count for page %lu is %lu\n",
(ulong) i,
(ulong) ibuf_count_get(data->space, i));
}

2
innobase/include/btr0btr.h
View File

@ -392,6 +392,7 @@ btr_page_free_low(
page_t* page, /* in: page to be freed, x-latched */
ulint level, /* in: page level */
mtr_t* mtr); /* in: mtr */
#ifdef UNIV_DEBUG
/*****************************************************************
Prints size info of a B-tree. */
@ -408,6 +409,7 @@ btr_print_tree(
dict_tree_t* tree, /* in: tree */
ulint width); /* in: print this many entries from start
and end */
#endif /* UNIV_DEBUG */
/****************************************************************
Checks the size and number of fields in a record based on the definition of
the index. */

13
innobase/include/buf0buf.h
View File

@ -54,9 +54,11 @@ Created 11/5/1995 Heikki Tuuri
#define BUF_KEEP_OLD 52
extern buf_pool_t* buf_pool; /* The buffer pool of the database */
#ifdef UNIV_DEBUG
extern ibool buf_debug_prints;/* If this is set TRUE, the program
prints info whenever read or flush
occurs */
#endif /* UNIV_DEBUG */
/************************************************************************
Creates the buffer pool. */
@ -476,12 +478,14 @@ buf_pool_is_block(
/*==============*/
/* out: TRUE if pointer to block */
void* ptr); /* in: pointer to memory */
#ifdef UNIV_DEBUG
/*************************************************************************
Validates the buffer pool data structure. */
ibool
buf_validate(void);
/*==============*/
#endif /* UNIV_DEBUG */
/************************************************************************
Prints a page to stderr. */
@ -507,8 +511,7 @@ Prints info of the buffer i/o. */
void
buf_print_io(
/*=========*/
char* buf, /* in/out: buffer where to print */
char* buf_end);/* in: buffer end */
FILE* file); /* in: file where to print */
/*************************************************************************
Returns the ratio in percents of modified pages in the buffer pool /
database pages in the buffer pool. */
@ -894,7 +897,7 @@ struct buf_pool_struct{
ulint n_pend_reads; /* number of pending read operations */
time_t last_printout_time; /* when buf_print was last time
time_t last_printout_time; /* when buf_print_io was last time
called */
ulint n_pages_read; /* number read operations */
ulint n_pages_written;/* number write operations */
@ -909,10 +912,10 @@ struct buf_pool_struct{
ulint n_pages_awe_remapped; /* if AWE is enabled, the
number of remaps of blocks to
buffer frames */
ulint n_page_gets_old;/* n_page_gets when buf_print was
ulint n_page_gets_old;/* n_page_gets when buf_print_io was
last time called: used to calculate
hit rate */
ulint n_pages_read_old;/* n_pages_read when buf_print was
ulint n_pages_read_old;/* n_pages_read when buf_print_io was
last time called */
ulint n_pages_written_old;/* number write operations */
ulint n_pages_created_old;/* number of pages created in

20
innobase/include/buf0buf.ic
View File

@ -11,10 +11,6 @@ Created 11/5/1995 Heikki Tuuri
#include "buf0rea.h"
#include "mtr0mtr.h"
extern ulint buf_dbg_counter; /* This is used to insert validation
operations in execution in the
debug version */
/************************************************************************
Recommends a move of a block to the start of the LRU list if there is danger
of dropping from the buffer pool. NOTE: does not reserve the buffer pool
@ -215,14 +211,14 @@ buf_block_align(
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Error: trying to access a stray pointer %lx\n"
"InnoDB: buf pool start is at %lx, end at %lx\n"
"InnoDB: Error: trying to access a stray pointer %p\n"
"InnoDB: buf pool start is at %p, end at %p\n"
"InnoDB: Probable reason is database corruption or memory\n"
"InnoDB: corruption. If this happens in an InnoDB database recovery,\n"
"InnoDB: you can look from section 6.1 at http://www.innodb.com/ibman.html\n"
"InnoDB: how to force recovery.\n",
(long)ptr, (long)frame_zero,
(long)(buf_pool->high_end));
ptr, frame_zero,
buf_pool->high_end);
ut_error;
}
@ -251,14 +247,14 @@ buf_frame_align(
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Error: trying to access a stray pointer %lx\n"
"InnoDB: buf pool start is at %lx, end at %lx\n"
"InnoDB: Error: trying to access a stray pointer %p\n"
"InnoDB: buf pool start is at %p, end at %p\n"
"InnoDB: Probable reason is database corruption or memory\n"
"InnoDB: corruption. If this happens in an InnoDB database recovery,\n"
"InnoDB: you can look from section 6.1 at http://www.innodb.com/ibman.html\n"
"InnoDB: how to force recovery.\n",
(long)ptr, (long)(buf_pool->frame_zero),
(long)(buf_pool->high_end));
ptr, buf_pool->frame_zero,
buf_pool->high_end);
ut_error;
}

2
innobase/include/buf0flu.h
View File

@ -97,6 +97,7 @@ buf_flush_ready_for_replace(
/* out: TRUE if can replace immediately */
buf_block_t* block); /* in: buffer control block, must be in state
BUF_BLOCK_FILE_PAGE and in the LRU list */
#ifdef UNIV_DEBUG
/**********************************************************************
Validates the flush list. */
@ -104,6 +105,7 @@ ibool
buf_flush_validate(void);
/*====================*/
/* out: TRUE if ok */
#endif /* UNIV_DEBUG */
/* When buf_flush_free_margin is called, it tries to make this many blocks
available to replacement in the free list and at the end of the LRU list (to

2
innobase/include/buf0lru.h
View File

@ -112,6 +112,7 @@ void
buf_LRU_make_block_old(
/*===================*/
buf_block_t* block); /* in: control block */
#ifdef UNIV_DEBUG
/**************************************************************************
Validates the LRU list. */
@ -124,6 +125,7 @@ Prints the LRU list. */
void
buf_LRU_print(void);
/*===============*/
#endif /* UNIV_DEBUG */
#ifndef UNIV_NONINL
#include "buf0lru.ic"

13
innobase/include/data0data.h
View File

@ -294,6 +294,7 @@ dtuple_check_typed_no_assert(
/*=========================*/
/* out: TRUE if ok */
dtuple_t* tuple); /* in: tuple */
#ifdef UNIV_DEBUG
/**************************************************************
Validates the consistency of a tuple which must be complete, i.e,
all fields must have been set. */
@ -303,6 +304,7 @@ dtuple_validate(
/*============*/
/* out: TRUE if ok */
dtuple_t* tuple); /* in: tuple */
#endif /* UNIV_DEBUG */
/*****************************************************************
Pretty prints a dfield value according to its data type. */
@ -324,16 +326,7 @@ The following function prints the contents of a tuple. */
void
dtuple_print(
/*=========*/
dtuple_t* tuple); /* in: tuple */
/**************************************************************
The following function prints the contents of a tuple to a buffer. */
ulint
dtuple_sprintf(
/*===========*/
/* out: printed length in bytes */
char* buf, /* in: print buffer */
ulint buf_len,/* in: buf length in bytes */
FILE* f, /* in: output stream */
dtuple_t* tuple); /* in: tuple */
/******************************************************************
Moves parts of long fields in entry to the big record vector so that

4
innobase/include/data0data.ic
View File

@ -299,7 +299,7 @@ dtuple_get_data_size(
ut_ad(tuple);
ut_ad(dtuple_check_typed(tuple));
ut_ad(tuple->magic_n = DATA_TUPLE_MAGIC_N);
ut_ad(tuple->magic_n == DATA_TUPLE_MAGIC_N);
n_fields = tuple->n_fields;
@ -355,7 +355,7 @@ dtuple_fold(
ulint fold;
ut_ad(tuple);
ut_ad(tuple->magic_n = DATA_TUPLE_MAGIC_N);
ut_ad(tuple->magic_n == DATA_TUPLE_MAGIC_N);
ut_ad(dtuple_check_typed(tuple));
fold = ut_fold_dulint(tree_id);

2
innobase/include/data0type.h
View File

@ -305,6 +305,7 @@ dtype_new_read_for_order_and_null_size(
/*===================================*/
dtype_t* type, /* in: type struct */
byte* buf); /* in: buffer for stored type order info */
#ifdef UNIV_DEBUG
/*************************************************************************
Validates a data type structure. */
@ -313,6 +314,7 @@ dtype_validate(
/*===========*/
/* out: TRUE if ok */
dtype_t* type); /* in: type struct to validate */
#endif /* UNIV_DEBUG */
/*************************************************************************
Prints a data type structure. */

113
innobase/include/dict0dict.h
View File

@ -32,20 +32,21 @@ Get the database name length in a table name. */
ulint
dict_get_db_name_len(
/*=================*/
/* out: database name length */
char* name); /* in: table name in the form dbname '/' tablename */
/* out: database name length */
const char* name); /* in: table name in the form
dbname '/' tablename */
/*************************************************************************
Accepts a specified string. Comparisons are case-insensitive. */
char*
const char*
dict_accept(
/*========*/
/* out: if string was accepted, the pointer
is moved after that, else ptr is returned */
char* ptr, /* in: scan from this */
const char* string,/* in: accept only this string as the next
non-whitespace string */
ibool* success);/* out: TRUE if accepted */
/* out: if string was accepted, the pointer
is moved after that, else ptr is returned */
const char* ptr, /* in: scan from this */
const char* string, /* in: accept only this string as the next
non-whitespace string */
ibool* success);/* out: TRUE if accepted */
/************************************************************************
Decrements the count of open MySQL handles to a table. */
@ -69,41 +70,6 @@ database directories. */
void
dict_load_space_id_list(void);
/*=========================*/
/**************************************************************************
Returns a stored procedure object and memoryfixes it. */
UNIV_INLINE
dict_proc_t*
dict_procedure_get(
/*===============*/
/* out: procedure, NULL if does not exist */
char* proc_name, /* in: table name */
trx_t* trx); /* in: transaction handle or NULL */
/**************************************************************************
Adds a stored procedure object to the dictionary cache. */
void
dict_procedure_add_to_cache(
/*========================*/
dict_proc_t* proc); /* in: procedure */
/**************************************************************************
Reserves a parsed copy of a stored procedure to execute. If there are no
free parsed copies left at the moment, parses a new copy. Takes the copy off
the list of copies: the copy must be returned there with
dict_procedure_release_parsed_copy. */
que_t*
dict_procedure_reserve_parsed_copy(
/*===============================*/
/* out: the query graph */
dict_proc_t* proc); /* in: dictionary procedure node */
/**************************************************************************
Releases a parsed copy of an executed stored procedure. Puts the copy to the
list of copies. */
void
dict_procedure_release_parsed_copy(
/*===============================*/
que_t* graph); /* in: query graph of a stored procedure */
/*************************************************************************
Gets the column data type. */
UNIV_INLINE
@ -270,7 +236,7 @@ dict_foreign_parse_drop_constraints(
dict_table_t* table, /* in: table */
ulint* n, /* out: number of constraints
to drop */
char*** constraints_to_drop); /* out: id's of the
const char*** constraints_to_drop); /* out: id's of the
constraints to drop */
/**************************************************************************
Returns a table object and memoryfixes it. NOTE! This is a high-level
@ -354,19 +320,20 @@ dict_table_get_index_noninline(
dict_table_t* table, /* in: table */
char* name); /* in: index name */
/**************************************************************************
Prints a table definition. */
void
dict_table_print(
/*=============*/
dict_table_t* table); /* in: table */
/**************************************************************************
Prints a table data. */
void
dict_table_print_low(
/*=================*/
dict_table_t* table); /* in: table */
#ifdef UNIV_DEBUG
/**************************************************************************
Prints a table definition. */
void
dict_table_print(
/*=============*/
dict_table_t* table); /* in: table */
/**************************************************************************
Prints a table data when we know the table name. */
@ -374,8 +341,9 @@ void
dict_table_print_by_name(
/*=====================*/
char* name);
#endif /* UNIV_DEBUG */
/**************************************************************************
Sprintfs to a string info on foreign keys of a table. */
Outputs info on foreign keys of a table. */
void
dict_print_info_on_foreign_keys(
@ -384,19 +352,23 @@ dict_print_info_on_foreign_keys(
a format suitable to be inserted into
a CREATE TABLE, otherwise in the format
of SHOW TABLE STATUS */
char* str, /* in/out: pointer to a string */
ulint len, /* in: space in str available for info */
FILE* file, /* in: file where to print */
dict_table_t* table); /* in: table */
/**************************************************************************
Sprintfs to a string info on a foreign key of a table in a format suitable
for CREATE TABLE. */
char*
Outputs info on a foreign key of a table in a format suitable for
CREATE TABLE. */
void
dict_print_info_on_foreign_key_in_create_format(
/*============================================*/
/* out: how far in buf we printed */
dict_foreign_t* foreign,/* in: foreign key constraint */
char* buf); /* in: buffer of at least 5000 bytes */
FILE* file, /* in: file where to print */
dict_foreign_t* foreign);/* in: foreign key constraint */
/************************************************************************
Displays the names of the index and the table. */
void
dict_index_name_print(
/*==================*/
FILE* file, /* in: output stream */
const dict_index_t* index); /* in: index to print */
/************************************************************************
Gets the first index on the table (the clustered index). */
UNIV_INLINE
@ -899,14 +871,21 @@ Releases the dictionary system mutex for MySQL. */
void
dict_mutex_exit_for_mysql(void);
/*===========================*/
/************************************************************************
Checks if the database name in two table names is the same. */
/* The following len must be at least 10000 bytes! */
#define DICT_FOREIGN_ERR_BUF_LEN 10000
ibool
dict_tables_have_same_db(
/*=====================*/
/* out: TRUE if same db name */
const char* name1, /* in: table name in the form
dbname '/' tablename */
const char* name2); /* in: table name in the form
dbname '/' tablename */
/* Buffers for storing detailed information about the latest foreign key
and unique key errors */
extern char* dict_foreign_err_buf;
extern char* dict_unique_err_buf;
extern FILE* dict_foreign_err_file;
extern mutex_t dict_foreign_err_mutex; /* mutex protecting the buffers */
extern dict_sys_t* dict_sys; /* the dictionary system */
@ -932,8 +911,6 @@ struct dict_sys_struct{
hash_table_t* table_id_hash; /* hash table of the tables, based
on id */
hash_table_t* col_hash; /* hash table of the columns */
hash_table_t* procedure_hash; /* hash table of the stored
procedures */
UT_LIST_BASE_NODE_T(dict_table_t)
table_LRU; /* LRU list of tables */
ulint size; /* varying space in bytes occupied

31
innobase/include/dict0dict.ic
View File

@ -581,37 +581,6 @@ dict_table_get_low(
return(table);
}
/**************************************************************************
Returns a stored procedure object and memoryfixes it. */
UNIV_INLINE
dict_proc_t*
dict_procedure_get(
/*===============*/
/* out: procedure, NULL if does not exist */
char* proc_name, /* in: table name */
trx_t* trx) /* in: transaction handle or NULL */
{
dict_proc_t* proc;
ulint name_fold;
UT_NOT_USED(trx);
mutex_enter(&(dict_sys->mutex));
/* Look for the table name in the hash table */
name_fold = ut_fold_string(proc_name);
HASH_SEARCH(name_hash, dict_sys->procedure_hash, name_fold, proc,
ut_strcmp(proc->name, proc_name) == 0);
if (proc != NULL) {
proc->mem_fix++;
}
mutex_exit(&(dict_sys->mutex));
return(proc);
}
/**************************************************************************
Returns a table object, based on table id, and memoryfixes it. */
UNIV_INLINE

30
innobase/include/dict0mem.h
View File

@ -132,18 +132,6 @@ dict_foreign_t*
dict_mem_foreign_create(void);
/*=========================*/
/* out, own: foreign constraint struct */
/**************************************************************************
Creates a procedure memory object. */
dict_proc_t*
dict_mem_procedure_create(
/*======================*/
/* out, own: procedure object */
char* name, /* in: procedure name */
char* sql_string, /* in: procedure definition as an SQL
string */
que_fork_t* graph); /* in: parsed procedure graph */
/* Data structure for a column in a table */
struct dict_col_struct{
@ -427,24 +415,6 @@ struct dict_table_struct{
#endif /* UNIV_DEBUG */
};
/* Data structure for a stored procedure */
struct dict_proc_struct{
mem_heap_t* heap; /* memory heap */
char* name; /* procedure name */
char* sql_string;
/* procedure definition as an SQL string:
we can produce more parsed instances of the
procedure by parsing this string */
hash_node_t name_hash;
/* hash chain node */
UT_LIST_BASE_NODE_T(que_fork_t) graphs;
/* list of parsed instances of the procedure:
there may be many of them, and they are
recycled */
ulint mem_fix;/* count of how many times this struct
has been fixed in memory */
};
#ifndef UNIV_NONINL
#include "dict0mem.ic"
#endif

1
innobase/include/dict0types.h
View File

@ -15,7 +15,6 @@ typedef struct dict_field_struct dict_field_t;
typedef struct dict_index_struct dict_index_t;
typedef struct dict_tree_struct dict_tree_t;
typedef struct dict_table_struct dict_table_t;
typedef struct dict_proc_struct dict_proc_t;
typedef struct dict_foreign_struct dict_foreign_t;
/* A cluster object is a table object with the type field set to

2
innobase/include/fil0fil.h
View File

@ -19,7 +19,7 @@ Created 10/25/1995 Heikki Tuuri
/* When mysqld is run, the default directory "." is the mysqld datadir, but in
ibbackup we must set it explicitly; the patgh must NOT contain the trailing
'/' or '\' */
extern char* fil_path_to_mysql_datadir;
extern const char* fil_path_to_mysql_datadir;
/* Initial size of a single-table tablespace in pages */
#define FIL_IBD_FILE_INITIAL_SIZE 4

2
innobase/include/fsp0fsp.h
View File

@ -332,6 +332,7 @@ void
fsp_print(
/*======*/
ulint space); /* in: space id */
#ifdef UNIV_DEBUG
/***********************************************************************
Validates a segment. */
@ -349,6 +350,7 @@ fseg_print(
/*=======*/
fseg_header_t* header, /* in: segment header */
mtr_t* mtr); /* in: mtr */
#endif /* UNIV_DEBUG */
/* Flags for fsp_reserve_free_extents */
#define FSP_NORMAL 1000000

3
innobase/include/fut0lst.h
View File

@ -181,6 +181,7 @@ flst_validate(
/* out: TRUE if ok */
flst_base_node_t* base, /* in: pointer to base node of list */
mtr_t* mtr1); /* in: mtr */
#ifdef UNIV_DEBUG
/************************************************************************
Prints info of a file-based list. */
@ -189,7 +190,7 @@ flst_print(
/*=======*/
flst_base_node_t* base, /* in: pointer to base node of list */
mtr_t* mtr); /* in: mtr */
#endif /* UNIV_DEBUG */
#ifndef UNIV_NONINL
#include "fut0lst.ic"

3
innobase/include/ha0ha.h
View File

@ -127,8 +127,7 @@ Prints info of a hash table. */
void
ha_print_info(
/*==========*/
char* buf, /* in/out: buffer where to print */
char* buf_end,/* in: buffer end */
FILE* file, /* in: file where to print */
hash_table_t* table); /* in: hash table */
/* The hash table external chain node */

29
innobase/include/ha0ha.ic
View File

@ -131,35 +131,6 @@ ha_search_and_get_data(
return(NULL);
}
/*****************************************************************
Returns the next matching hash table node in chain. */
UNIV_INLINE
ha_node_t*
ha_next(
/*====*/
/* out: pointer to the next hash table node
in chain with the fold value, NULL if not
found */
ha_node_t* node) /* in: hash table node */
{
ulint fold;
fold = node->fold;
node = ha_chain_get_next(node);
while (node) {
if (node->fold == fold) {
return(node);
}
node = ha_chain_get_next(node);
}
return(NULL);
}
/*************************************************************
Looks for an element when we know the pointer to the data. */
UNIV_INLINE

3
innobase/include/ibuf0ibuf.h
View File

@ -290,8 +290,7 @@ Prints info of ibuf. */
void
ibuf_print(
/*=======*/
char* buf, /* in/out: buffer where to print */
char* buf_end);/* in: buffer end */
FILE* file); /* in: file where to print */
#define IBUF_HEADER_PAGE_NO FSP_IBUF_HEADER_PAGE_NO
#define IBUF_TREE_ROOT_PAGE_NO FSP_IBUF_TREE_ROOT_PAGE_NO

17
innobase/include/lock0lock.h
View File

@ -19,7 +19,11 @@ Created 5/7/1996 Heikki Tuuri
#include "read0types.h"
#include "hash0hash.h"
#ifdef UNIV_DEBUG
extern ibool lock_print_waits;
#endif /* UNIV_DEBUG */
/* Buffer for storing information about the most recent deadlock error */
extern FILE* lock_latest_err_file;
/*************************************************************************
Gets the size of a lock struct. */
@ -453,6 +457,7 @@ lock_check_trx_id_sanity(
dict_index_t* index, /* in: clustered index */
ibool has_kernel_mutex);/* in: TRUE if the caller owns the
kernel mutex */
#ifdef UNIV_DEBUG
/*************************************************************************
Validates the lock queue on a single record. */
@ -462,14 +467,14 @@ lock_rec_queue_validate(
/* out: TRUE if ok */
rec_t* rec, /* in: record to look at */
dict_index_t* index); /* in: index, or NULL if not known */
#endif /* UNIV_DEBUG */
/*************************************************************************
Prints info of a table lock. */
void
lock_table_print(
/*=============*/
char* buf, /* in/out: buffer where to print, must be at least
500 bytes */
FILE* file, /* in: file where to print */
lock_t* lock); /* in: table type lock */
/*************************************************************************
Prints info of a record lock. */
@ -477,8 +482,7 @@ Prints info of a record lock. */
void
lock_rec_print(
/*===========*/
char* buf, /* in/out: buffer where to print, must be at least
500 bytes */
FILE* file, /* in: file where to print */
lock_t* lock); /* in: record type lock */
/*************************************************************************
Prints info of locks for all transactions. */
@ -486,8 +490,8 @@ Prints info of locks for all transactions. */
void
lock_print_info(
/*============*/
char* buf, /* in/out: buffer where to print */
char* buf_end);/* in: buffer end */
FILE* file); /* in: file where to print */
#ifdef UNIV_DEBUG
/*************************************************************************
Validates the lock queue on a table. */
@ -512,6 +516,7 @@ ibool
lock_validate(void);
/*===============*/
/* out: TRUE if ok */
#endif /* UNIV_DEBUG */
/* The lock system */
extern lock_sys_t* lock_sys;

4
innobase/include/log0log.h
View File

@ -366,7 +366,6 @@ Writes a buffer to a log file group. */
void
log_group_write_buf(
/*================*/
ulint type, /* in: LOG_FLUSH or LOG_RECOVER */
log_group_t* group, /* in: log group */
byte* buf, /* in: buffer */
ulint len, /* in: buffer len; must be divisible
@ -513,8 +512,7 @@ Prints info of the log. */
void
log_print(
/*======*/
char* buf, /* in/out: buffer where to print */
char* buf_end);/* in: buffer end */
FILE* file); /* in: file where to print */
/**********************************************************
Peeks the current lsn. */

4
innobase/include/mem0dbg.h
View File

@ -31,6 +31,7 @@ check fields at the both ends of the field. */
#define MEM_SPACE_NEEDED(N) ut_calc_align((N), UNIV_MEM_ALIGNMENT)
#endif
#ifdef UNIV_DEBUG
/*******************************************************************
Checks a memory heap for consistency and prints the contents if requested.
Outputs the sum of sizes of buffers given to the user (only in
@ -60,6 +61,7 @@ mem_heap_validate_or_print(
ulint* n_blocks); /* out: number of blocks in the heap,
if a NULL pointer is passed as this
argument, it is ignored */
#endif /* UNIV_DEBUG */
#ifdef UNIV_MEM_DEBUG
/******************************************************************
Prints the contents of a memory heap. */
@ -69,6 +71,7 @@ mem_heap_print(
/*===========*/
mem_heap_t* heap); /* in: memory heap */
#endif /* UNIV_MEM_DEBUG */
#ifdef UNIV_DEBUG
/******************************************************************
Checks that an object is a memory heap (or a block of it) */
@ -85,6 +88,7 @@ mem_heap_validate(
/*==============*/
/* out: TRUE if ok */
mem_heap_t* heap); /* in: memory heap */
#endif /* UNIV_DEBUG */
#ifdef UNIV_MEM_DEBUG
/*********************************************************************
TRUE if no memory is currently allocated. */

3
innobase/include/mem0dbg.ic
View File

@ -56,6 +56,7 @@ mem_hash_insert(
mem_heap_t* heap, /* in: the created heap */
char* file_name, /* in: file name of creation */
ulint line); /* in: line where created */
#ifdef UNIV_MEM_DEBUG
/*******************************************************************
Removes a memory heap (which is going to be freed by the caller)
from the list of live memory heaps. Returns the size of the heap
@ -71,7 +72,7 @@ mem_hash_remove(
mem_heap_t* heap, /* in: the heap to be freed */
char* file_name, /* in: file name of freeing */
ulint line); /* in: line where freed */
#endif /* UNIV_MEM_DEBUG */
void
mem_field_header_set_len(byte* field, ulint len);

53
innobase/include/mem0mem.h
View File

@ -271,6 +271,59 @@ mem_realloc(
ulint n, /* in: desired number of bytes */
char* file_name,/* in: file name where called */
ulint line); /* in: line where called */
/**************************************************************************
Duplicates a NUL-terminated string. */
UNIV_INLINE
char*
mem_strdup(
/*=======*/
/* out, own: a copy of the string,
must be deallocated with mem_free */
const char* str); /* in: string to be copied */
/**************************************************************************
Makes a NUL-terminated copy of a nonterminated string. */
UNIV_INLINE
char*
mem_strdupl(
/*========*/
/* out, own: a copy of the string,
must be deallocated with mem_free */
const char* str, /* in: string to be copied */
ulint len); /* in: length of str, in bytes */
/**************************************************************************
Makes a NUL-terminated quoted copy of a NUL-terminated string. */
UNIV_INLINE
char*
mem_strdupq(
/*========*/
/* out, own: a quoted copy of the string,
must be deallocated with mem_free */
const char* str, /* in: string to be copied */
char q); /* in: quote character */
/**************************************************************************
Duplicates a NUL-terminated string, allocated from a memory heap. */
UNIV_INLINE
char*
mem_heap_strdup(
/*============*/
/* out, own: a copy of the string */
mem_heap_t* heap, /* in: memory heap where string is allocated */
const char* str); /* in: string to be copied */
/**************************************************************************
Makes a NUL-terminated copy of a nonterminated string,
allocated from a memory heap. */
UNIV_INLINE
char*
mem_heap_strdupl(
/*=============*/
/* out, own: a copy of the string */
mem_heap_t* heap, /* in: memory heap where string is allocated */
const char* str, /* in: string to be copied */
ulint len); /* in: length of str, in bytes */
#ifdef MEM_PERIODIC_CHECK
/**********************************************************************
Goes through the list of all allocated mem blocks, checks their magic

96
innobase/include/mem0mem.ic
View File

@ -579,3 +579,99 @@ mem_realloc(
return(mem_alloc_func(n, file_name, line));
}
/**************************************************************************
Duplicates a NUL-terminated string. */
UNIV_INLINE
char*
mem_strdup(
/*=======*/
/* out, own: a copy of the string,
must be deallocated with mem_free */
const char* str) /* in: string to be copied */
{
ulint len = strlen(str) + 1;
return(memcpy(mem_alloc(len), str, len));
}
/**************************************************************************
Makes a NUL-terminated copy of a nonterminated string. */
UNIV_INLINE
char*
mem_strdupl(
/*========*/
/* out, own: a copy of the string,
must be deallocated with mem_free */
const char* str, /* in: string to be copied */
ulint len) /* in: length of str, in bytes */
{
char* s = mem_alloc(len + 1);
s[len] = 0;
return(memcpy(s, str, len));
}
/**************************************************************************
Makes a NUL-terminated quoted copy of a NUL-terminated string. */
UNIV_INLINE
char*
mem_strdupq(
/*========*/
/* out, own: a quoted copy of the string,
must be deallocated with mem_free */
const char* str, /* in: string to be copied */
char q) /* in: quote character */
{
char* dst;
char* d;
const char* s = str;
int len = strlen(str) + 3;
/* calculate the number of quote characters in the string */
while((s = strchr(s, q)) != NULL) {
s++;
len++;
}
/* allocate the quoted string, and copy it */
d = dst = mem_alloc(len);
*d++ = q;
s = str;
while(*s) {
if ((*d++ = *s++) == q) {
*d++ = q;
}
}
*d++ = q;
*d++ = '\0';
ut_ad(len == d - dst);
return(dst);
}
/**************************************************************************
Duplicates a NUL-terminated string, allocated from a memory heap. */
UNIV_INLINE
char*
mem_heap_strdup(
/*============*/
/* out, own: a copy of the string */
mem_heap_t* heap, /* in: memory heap where string is allocated */
const char* str) /* in: string to be copied */
{
ulint len = strlen(str) + 1;
return(memcpy(mem_heap_alloc(heap, len), str, len));
}
/**************************************************************************
Makes a NUL-terminated copy of a nonterminated string,
allocated from a memory heap. */
UNIV_INLINE
char*
mem_heap_strdupl(
/*=============*/
/* out, own: a copy of the string */
mem_heap_t* heap, /* in: memory heap where string is allocated */
const char* str, /* in: string to be copied */
ulint len) /* in: length of str, in bytes */
{
char* s = mem_heap_alloc(heap, len + 1);
s[len] = 0;
return(memcpy(s, str, len));
}

3
innobase/include/mem0pool.h
View File

@ -85,6 +85,7 @@ Releases the mem pool mutex. */
void
mem_pool_mutex_exit(void);
/*=====================*/
#ifdef UNIV_DEBUG
/************************************************************************
Validates a memory pool. */
@ -101,7 +102,7 @@ mem_pool_print_info(
/*================*/
FILE* outfile,/* in: output file to write to */
mem_pool_t* pool); /* in: memory pool */
#endif /* UNIV_DEBUG */
#ifndef UNIV_NONINL
#include "mem0pool.ic"

3
innobase/include/mtr0log.ic
View File

@ -171,7 +171,8 @@ mlog_write_initial_log_record_fast(
mtr->n_log_recs++;
#ifdef UNIV_LOG_DEBUG
/* printf("Adding to mtr log record type %lu space %lu page no %lu\n",
/* fprintf(stderr,
"Adding to mtr log record type %lu space %lu page no %lu\n",
type, space, offset); */
#endif

2
innobase/include/mtr0mtr.h
View File

@ -256,6 +256,7 @@ mtr_memo_contains(
mtr_t* mtr, /* in: mtr */
void* object, /* in: object to search */
ulint type); /* in: type of object */
#ifdef UNIV_DEBUG
/*************************************************************
Prints info of an mtr handle. */
@ -263,6 +264,7 @@ void
mtr_print(
/*======*/
mtr_t* mtr); /* in: mtr */
#endif /* UNIV_DEBUG */
/*######################################################################*/
#define MTR_BUF_MEMO_SIZE 200 /* number of slots in memo */

3
innobase/include/os0file.h
View File

@ -647,8 +647,7 @@ Prints info of the aio arrays. */
void
os_aio_print(
/*=========*/
char* buf, /* in/out: buffer where to print */
char* buf_end);/* in: buffer end */
FILE* file); /* in: file where to print */
/**************************************************************************
Refreshes the statistics used to print per-second averages. */

2
innobase/include/pars0opt.h
View File

@ -43,6 +43,7 @@ opt_find_all_cols(
to add new found columns */
plan_t* plan, /* in: plan or NULL */
que_node_t* exp); /* in: expression or condition */
#ifdef UNIV_SQL_DEBUG
/************************************************************************
Prints info of a query plan. */
@ -50,6 +51,7 @@ void
opt_print_query_plan(
/*=================*/
sel_node_t* sel_node); /* in: select node */
#endif /* UNIV_SQL_DEBUG */
#ifndef UNIV_NONINL
#include "pars0opt.ic"

19
innobase/include/pars0pars.h
View File

@ -87,13 +87,6 @@ pars_get_lex_chars(
int max_size); /* in: maximum number of characters which fit
in the buffer */
/*****************************************************************
Instructs the lexical analyzer to stop when it receives the EOF integer. */
int
yywrap(void);
/*========*/
/* out: returns TRUE */
/*****************************************************************
Called by yyparse on error. */
void
@ -456,18 +449,6 @@ struct proc_node_struct{
sym_node_t* param_list; /* input and output parameters */
que_node_t* stat_list; /* statement list */
sym_tab_t* sym_tab; /* symbol table of this procedure */
dict_proc_t* dict_proc; /* stored procedure node in the
dictionary cache, if defined */
};
/* Stored procedure call node */
struct call_node_struct{
que_common_t common; /* type: QUE_NODE_CALL */
sym_node_t* proc_name; /* stored procedure name */
dict_proc_t* procedure_def; /* pointer to a stored procedure graph
in the dictionary stored procedure
cache */
sym_tab_t* sym_tab; /* symbol table of this query */
};
/* elsif-element node */

3
innobase/include/pars0sym.h
View File

@ -127,9 +127,6 @@ struct sym_node_struct{
dict_table_t* table; /* table definition
if a table id or a
column id */
dict_proc_t* procedure_def; /* stored procedure
definition, if a
stored procedure name */
ulint col_no; /* column number if a
column */
sel_buf_t* prefetch_buf; /* NULL, or a buffer

1
innobase/include/pars0types.h
View File

@ -15,7 +15,6 @@ typedef struct pars_res_word_struct pars_res_word_t;
typedef struct func_node_struct func_node_t;
typedef struct order_node_struct order_node_t;
typedef struct proc_node_struct proc_node_t;
typedef struct call_node_struct call_node_t;
typedef struct elsif_node_struct elsif_node_t;
typedef struct if_node_struct if_node_t;
typedef struct while_node_struct while_node_t;

11
innobase/include/rem0rec.h
View File

@ -390,16 +390,7 @@ Prints a physical record. */
void
rec_print(
/*======*/
rec_t* rec); /* in: physical record */
/*******************************************************************
Prints a physical record to a buffer. */
ulint
rec_sprintf(
/*========*/
/* out: printed length in bytes */
char* buf, /* in: buffer to print to */
ulint buf_len,/* in: buffer length */
FILE* file, /* in: file where to print */
rec_t* rec); /* in: physical record */
#define REC_INFO_BITS 6 /* This is single byte bit-field */

2
innobase/include/rem0rec.ic
View File

@ -190,7 +190,7 @@ rec_set_bit_field_2(
+ (REC_N_OWNED_MASK << (8 * (REC_N_OWNED - 3)))
+ (REC_INFO_BITS_MASK << (8 * (REC_INFO_BITS - 3))));
if (m != ut_dbg_zero + 0xFFFFFFFFUL) {
printf("Sum of masks %lx\n", m);
fprintf(stderr, "Sum of masks %lx\n", m);
ut_error;
}
}

4
innobase/include/row0mysql.h
View File

@ -337,7 +337,9 @@ row_drop_table_for_mysql(
/*=====================*/
/* out: error code or DB_SUCCESS */
char* name, /* in: table name */
trx_t* trx); /* in: transaction handle */
trx_t* trx, /* in: transaction handle */
ibool drop_db);/* in: TRUE=dropping whole database */
/*************************************************************************
Discards the tablespace of a table which stored in an .ibd file. Discarding
means that this function deletes the .ibd file and assigns a new table id for

5
innobase/include/row0sel.ic
View File

@ -77,12 +77,9 @@ open_step(
if (err != DB_SUCCESS) {
/* SQL error detected */
printf("SQL error %lu\n", (unsigned long) err);
fprintf(stderr, "SQL error %lu\n", (ulong) err);
ut_error;
que_thr_handle_error(thr, err, NULL, 0);
return(NULL);
}
thr->run_node = que_node_get_parent(node);

3
innobase/include/row0uins.h
View File

@ -26,8 +26,7 @@ ulint
row_undo_ins(
/*=========*/
/* out: DB_SUCCESS */
undo_node_t* node, /* in: row undo node */
que_thr_t* thr); /* in: query thread */
undo_node_t* node); /* in: row undo node */
#ifndef UNIV_NONINL

3
innobase/include/row0undo.h
View File

@ -41,8 +41,7 @@ row_undo_search_clust_to_pcur(
/* out: TRUE if found; NOTE the node->pcur
must be closed by the caller, regardless of
the return value */
undo_node_t* node, /* in: row undo node */
que_thr_t* thr); /* in: query thread */
undo_node_t* node); /* in: row undo node */
/***************************************************************
Undoes a row operation in a table. This is a high-level function used
in SQL execution graphs. */

10
innobase/include/row0upd.ic
View File

@ -84,10 +84,12 @@ upd_field_set_field_no(
if (field_no >= dict_index_get_n_fields(index)) {
fprintf(stderr,
"InnoDB: Error: trying to access field %lu in table %s\n"
"InnoDB: index %s, but index has only %lu fields\n",
(unsigned long) field_no, index->table_name, index->name,
(unsigned long) dict_index_get_n_fields(index));
"InnoDB: Error: trying to access field %lu in ",
(ulong) field_no);
dict_index_name_print(stderr, index);
fprintf(stderr, "\n"
"InnoDB: but index only has %lu fields\n",
(ulong) dict_index_get_n_fields(index));
}
dtype_copy(dfield_get_type(&(upd_field->new_val)),

27
innobase/include/srv0srv.h
View File

@ -32,6 +32,11 @@ at a time */
/* This is set to TRUE if the MySQL user has set it in MySQL */
extern ibool srv_lower_case_table_names;
/* Mutex for locking srv_monitor_file */
extern mutex_t srv_monitor_file_mutex;
/* Temporary file for innodb monitor output */
extern FILE* srv_monitor_file;
/* Server parameters which are read from the initfile */
extern char* srv_data_home;
@ -162,8 +167,8 @@ extern mutex_t* kernel_mutex_temp;/* mutex protecting the server, trx structs,
/* Array of English strings describing the current state of an
i/o handler thread */
extern char* srv_io_thread_op_info[];
extern char* srv_io_thread_function[];
extern const char* srv_io_thread_op_info[];
extern const char* srv_io_thread_function[];
typedef struct srv_sys_struct srv_sys_t;
@ -241,6 +246,15 @@ srv_get_thread_type(void);
/*=====================*/
/* out: SRV_COM, ... */
/*************************************************************************
Sets the info describing an i/o thread current state. */
void
srv_set_io_thread_op_info(
/*======================*/
ulint i, /* in: the 'segment' of the i/o thread */
const char* str); /* in: constant char string describing the
state */
/*************************************************************************
Releases threads of the type given from suspension in the thread table.
NOTE! The server mutex has to be reserved by the caller! */
@ -366,13 +380,12 @@ srv_error_monitor_thread(
void* arg); /* in: a dummy parameter required by
os_thread_create */
/**********************************************************************
Sprintfs to a buffer the output of the InnoDB Monitor. */
Outputs to a file the output of the InnoDB Monitor. */
void
srv_sprintf_innodb_monitor(
/*=======================*/
char* buf, /* in/out: buffer which must be at least 4 kB */
ulint len); /* in: length of the buffer */
srv_printf_innodb_monitor(
/*======================*/
FILE* file); /* in: output stream */
/* Types for the threads existing in the system. Threads of types 4 - 9

3
innobase/include/sync0arr.h
View File

@ -114,8 +114,7 @@ Prints info of the wait array. */
void
sync_array_print_info(
/*==================*/
char* buf, /* in/out: buffer where to print */
char* buf_end,/* in: buffer end */
FILE* file, /* in: file where to print */
sync_array_t* arr); /* in: wait array */

2
innobase/include/sync0rw.h
View File

@ -85,6 +85,7 @@ void
rw_lock_free(
/*=========*/
rw_lock_t* lock); /* in: rw-lock */
#ifdef UNIV_DEBUG
/**********************************************************************
Checks that the rw-lock has been initialized and that there are no
simultaneous shared and exclusive locks. */
@ -93,6 +94,7 @@ ibool
rw_lock_validate(
/*=============*/
rw_lock_t* lock);
#endif /* UNIV_DEBUG */
/******************************************************************
NOTE! The following macros should be used in rw s-locking, not the
corresponding function. */

24
innobase/include/sync0sync.h
View File

@ -65,6 +65,15 @@ NOTE! The following macro should be used in mutex locking, not the
corresponding function. */
#define mutex_enter(M) mutex_enter_func((M), IB__FILE__, __LINE__)
/**********************************************************************
A noninlined function that reserves a mutex. In ha_innodb.cc we have disabled
inlining of InnoDB functions, and no inlined functions should be called from
there. That is why we need to duplicate the inlined function here. */
void
mutex_enter_noninline(
/*==================*/
mutex_t* mutex); /* in: mutex */
/******************************************************************
NOTE! The following macro should be used in mutex locking, not the
corresponding function. */
@ -105,6 +114,13 @@ mutex_exit(
/*=======*/
mutex_t* mutex); /* in: pointer to mutex */
/**********************************************************************
Releases a mutex. */
void
mutex_exit_noninline(
/*=================*/
mutex_t* mutex); /* in: mutex */
/**********************************************************************
Returns TRUE if no mutex or rw-lock is currently locked.
Works only in the debug version. */
@ -119,16 +135,15 @@ Prints wait info of the sync system. */
void
sync_print_wait_info(
/*=================*/
char* buf, /* in/out: buffer where to print */
char* buf_end); /* in: buffer end */
FILE* file); /* in: file where to print */
/***********************************************************************
Prints info of the sync system. */
void
sync_print(
/*=======*/
char* buf, /* in/out: buffer where to print */
char* buf_end); /* in: buffer end */
FILE* file); /* in: file where to print */
#ifdef UNIV_DEBUG
/**********************************************************************
Checks that the mutex has been initialized. */
@ -136,6 +151,7 @@ ibool
mutex_validate(
/*===========*/
mutex_t* mutex);
#endif /* UNIV_DEBUG */
/**********************************************************************
Sets the mutex latching level field. */

4
innobase/include/trx0sys.h
View File

@ -270,8 +270,9 @@ the magic number shows it valid. */
void
trx_sys_print_mysql_binlog_offset(void);
/*===================================*/
#ifdef UNIV_HOTBACKUP
/*********************************************************************
Prints to stdout the MySQL binlog info in the system header if the
Prints to stderr the MySQL binlog info in the system header if the
magic number shows it valid. */
void
@ -279,6 +280,7 @@ trx_sys_print_mysql_binlog_offset_from_page(
/*========================================*/
byte* page); /* in: buffer containing the trx system header page,
i.e., page number TRX_SYS_PAGE_NO in the tablespace */
#endif /* UNIV_HOTBACKUP */
/*********************************************************************
Prints to stderr the MySQL master log offset info in the trx system header if
the magic number shows it valid. */

3
innobase/include/trx0trx.h
View File

@ -280,8 +280,7 @@ own the kernel mutex. */
void
trx_print(
/*======*/
char* buf, /* in/out: buffer where to print, must be at least
800 bytes */
FILE* f, /* in: output stream */
trx_t* trx); /* in: transaction */

16
innobase/include/ut0byte.h
View File

@ -235,21 +235,19 @@ Copies a string to a memory location, setting characters to lower case. */
void
ut_cpy_in_lower_case(
/*=================*/
char* dest, /* in: destination */
char* source, /* in: source */
ulint len); /* in: string length */
char* dest, /* in: destination */
const char* source, /* in: source */
ulint len); /* in: string length */
/****************************************************************
Compares two strings when converted to lower case. */
int
ut_cmp_in_lower_case(
/*=================*/
/* out: -1, 0, 1 if str1 < str2, str1 == str2,
str1 > str2, respectively */
char* str1, /* in: string1 */
char* str2, /* in: string2 */
ulint len); /* in: length of both strings */
/* out: -1, 0, 1 if str1 < str2, str1 == str2,
str1 > str2, respectively */
const char* str1, /* in: string1 */
const char* str2); /* in: string2 */
#ifndef UNIV_NONINL
#include "ut0byte.ic"

42
innobase/include/ut0mem.h
View File

@ -85,6 +85,39 @@ UNIV_INLINE
int
ut_strcmp(void* str1, void* str2);
/**************************************************************************
Determine the length of a string when it is quoted with ut_strcpyq(). */
UNIV_INLINE
ulint
ut_strlenq(
/*=======*/
/* out: length of the string when quoted */
const char* str, /* in: null-terminated string */
char q); /* in: the quote character */
/**************************************************************************
Make a quoted copy of a string. */
char*
ut_strcpyq(
/*=======*/
/* out: pointer to end of dest */
char* dest, /* in: output buffer */
char q, /* in: the quote character */
const char* src); /* in: null-terminated string */
/**************************************************************************
Make a quoted copy of a fixed-length string. */
char*
ut_memcpyq(
/*=======*/
/* out: pointer to end of dest */
char* dest, /* in: output buffer */
char q, /* in: the quote character */
const char* src, /* in: string to be quoted */
ulint len); /* in: length of src */
/**************************************************************************
Catenates two strings into newly allocated memory. The memory must be freed
using mem_free. */
@ -95,6 +128,7 @@ ut_str_catenate(
/* out, own: catenated null-terminated string */
char* str1, /* in: null-terminated string */
char* str2); /* in: null-terminated string */
/**************************************************************************
Return a copy of the given string. The returned string must be freed
using mem_free. */
@ -104,14 +138,6 @@ ut_strdup(
/*======*/
/* out, own: cnull-terminated string */
char* str); /* in: null-terminated string */
/**************************************************************************
Checks if a null-terminated string contains a certain character. */
ibool
ut_str_contains(
/*============*/
char* str, /* in: null-terminated string */
char c); /* in: character */
#ifndef UNIV_NONINL
#include "ut0mem.ic"

20
innobase/include/ut0mem.ic
View File

@ -48,3 +48,23 @@ ut_strcmp(void* str1, void* str2)
return(strcmp((char*)str1, (char*)str2));
}
/**************************************************************************
Determine the length of a string when it is quoted with ut_strcpyq(). */
UNIV_INLINE
ulint
ut_strlenq(
/*=======*/
/* out: length of the string when quoted */
const char* str, /* in: null-terminated string */
char q) /* in: the quote character */
{
ulint len;
for (len = 0; *str; len++, str++) {
if (*str == q) {
len++;
}
}
return(len);
}

46
innobase/include/ut0ut.h
View File

@ -61,7 +61,9 @@ ut_fprintf(
negative in case of an error */
FILE* stream, /* in: stream where to print */
const char* format, /* in: format of prints */
...); /* in: arguments to be printed */
...) /* in: arguments to be printed */
__attribute__((__format__ (__printf__, 2, 3)));
/************************************************************
Gets the high 32 bits in a ulint. That is makes a shift >> 32,
but since there seem to be compiler bugs in both gcc and Visual C++,
@ -200,7 +202,7 @@ ut_print_timestamp(
/*===============*/
FILE* file); /* in: file where to print */
/**************************************************************
Sprintfs a timestamp to a buffer. */
Sprintfs a timestamp to a buffer, 13..14 chars plus terminating NUL. */
void
ut_sprintf_timestamp(
@ -238,19 +240,37 @@ Prints the contents of a memory buffer in hex and ascii. */
void
ut_print_buf(
/*=========*/
byte* buf, /* in: memory buffer */
ulint len); /* in: length of the buffer */
/*****************************************************************
Prints the contents of a memory buffer in hex and ascii. */
FILE* file, /* in: file where to print */
const byte* buf, /* in: memory buffer */
ulint len); /* in: length of the buffer */
ulint
ut_sprintf_buf(
/*===========*/
/* out: printed length in bytes */
char* str, /* in: buffer to print to */
byte* buf, /* in: memory buffer */
ulint len); /* in: length of the buffer */
/**************************************************************************
Outputs a NUL-terminated string, quoted as an SQL identifier. */
void
ut_print_name(
/*==========*/
FILE* f, /* in: output stream */
const char* name); /* in: name to print */
/**************************************************************************
Outputs a fixed-length string, quoted as an SQL identifier. */
void
ut_print_namel(
/*==========*/
FILE* f, /* in: output stream */
const char* name, /* in: name to print */
ulint namelen);/* in: length of name */
/**************************************************************************
Catenate files. */
void
ut_copy_file(
/*=========*/
FILE* dest, /* in: output file */
FILE* src); /* in: input file to be appended to output */
#ifndef UNIV_NONINL
#include "ut0ut.ic"

322
innobase/lock/lock0lock.c
View File

@ -266,7 +266,9 @@ waiting, in its lock queue. Solution: We can copy the locks as gap type
locks, so that also the waiting locks are transformed to granted gap type
locks on the inserted record. */
#ifdef UNIV_DEBUG
ibool lock_print_waits = FALSE;
#endif /* UNIV_DEBUG */
/* The lock system */
lock_sys_t* lock_sys = NULL;
@ -310,7 +312,7 @@ struct lock_struct{
/* We store info on the latest deadlock error to this buffer. InnoDB
Monitor will then fetch it and print */
ibool lock_deadlock_found = FALSE;
char* lock_latest_err_buf; /* We allocate 5000 bytes for this */
FILE* lock_latest_err_file;
/* Flags for recursive deadlock search */
#define LOCK_VICTIM_IS_START 1
@ -356,7 +358,6 @@ lock_check_trx_id_sanity(
ibool has_kernel_mutex)/* in: TRUE if the caller owns the
kernel mutex */
{
char err_buf[500];
ibool is_ok = TRUE;
if (!has_kernel_mutex) {
@ -367,14 +368,16 @@ lock_check_trx_id_sanity(
trx id counter */
if (ut_dulint_cmp(trx_id, trx_sys->max_trx_id) >= 0) {
rec_sprintf(err_buf, 400, rec);
ut_print_timestamp(stderr);
fprintf(stderr,
"InnoDB: Error: transaction id associated with record\n%s\n"
"InnoDB: in table %s index %s\n"
fputs(" InnoDB: Error: transaction id associated"
" with record\n",
stderr);
rec_print(stderr, rec);
fputs("InnoDB: in ", stderr);
dict_index_name_print(stderr, index);
fprintf(stderr, "\n"
"InnoDB: is %lu %lu which is higher than the global trx id counter %lu %lu!\n"
"InnoDB: The table is corrupt. You have to do dump + drop + reimport.\n",
err_buf, index->table_name, index->name,
(ulong) ut_dulint_get_high(trx_id),
(ulong) ut_dulint_get_low(trx_id),
(ulong) ut_dulint_get_high(trx_sys->max_trx_id),
@ -481,7 +484,7 @@ lock_sys_create(
/* hash_create_mutexes(lock_sys->rec_hash, 2, SYNC_REC_LOCK); */
lock_latest_err_buf = mem_alloc(5000);
lock_latest_err_file = tmpfile();
}
/*************************************************************************
@ -1326,6 +1329,7 @@ lock_rec_has_expl(
return(NULL);
}
#ifdef UNIV_DEBUG
/*************************************************************************
Checks if some other transaction has a lock request in the queue. */
static
@ -1368,6 +1372,7 @@ lock_rec_other_has_expl_req(
return(NULL);
}
#endif /* UNIV_DEBUG */
/*************************************************************************
Checks if some other transaction has a conflicting explicit lock request
@ -1620,11 +1625,12 @@ lock_rec_enqueue_waiting(
if (trx->dict_operation) {
ut_print_timestamp(stderr);
fprintf(stderr,
fputs(
" InnoDB: Error: a record lock wait happens in a dictionary operation!\n"
"InnoDB: Table name %s. Send a bug report to mysql@lists.mysql.com\n",
index->table_name);
"InnoDB: Table name ", stderr);
ut_print_name(stderr, index->table_name);
fputs(". Send a bug report to mysql@lists.mysql.com\n",
stderr);
}
/* Enqueue the lock request that will wait to be granted */
@ -1655,11 +1661,13 @@ index->table_name);
ut_a(que_thr_stop(thr));
#ifdef UNIV_DEBUG
if (lock_print_waits) {
printf("Lock wait for trx %lu in index %s\n",
(ulong) ut_dulint_get_low(trx->id),
index->name);
fprintf(stderr, "Lock wait for trx %lu in index ",
(ulong) ut_dulint_get_low(trx->id));
ut_print_name(stderr, index->name);
}
#endif /* UNIV_DEBUG */
return(DB_LOCK_WAIT);
}
@ -1995,10 +2003,12 @@ lock_grant(
lock->trx->auto_inc_lock = lock;
}
#ifdef UNIV_DEBUG
if (lock_print_waits) {
printf("Lock wait for trx %lu ends\n",
fprintf(stderr, "Lock wait for trx %lu ends\n",
(ulong) ut_dulint_get_low(lock->trx->id));
}
#endif /* UNIV_DEBUG */
/* If we are resolving a deadlock by choosing another transaction
as a victim, then our original transaction may not be in the
@ -2386,7 +2396,7 @@ lock_move_reorganize_page(
/* if ((page_cur_get_rec(&cur1) == sup)
&& lock_get_wait(lock)) {
printf(
fprintf(stderr,
"---\n--\n!!!Lock reorg: supr type %lu\n",
lock->type_mode);
} */
@ -2902,7 +2912,6 @@ lock_deadlock_occurs(
trx_t* mark_trx;
ulint ret;
ulint cost = 0;
char* err_buf;
ut_ad(trx && lock);
#ifdef UNIV_SYNC_DEBUG
@ -2940,14 +2949,8 @@ retry:
lock_deadlock_found = TRUE;
err_buf = lock_latest_err_buf + strlen(lock_latest_err_buf);
ut_a(err_buf <= lock_latest_err_buf + 4000);
err_buf += sprintf(err_buf,
"*** WE ROLL BACK TRANSACTION (2)\n");
ut_a(strlen(lock_latest_err_buf) < 4100);
fputs("*** WE ROLL BACK TRANSACTION (2)\n",
lock_latest_err_file);
return(TRUE);
}
@ -2979,7 +2982,6 @@ lock_deadlock_recursive(
lock_t* lock;
ulint bit_no = ULINT_UNDEFINED;
trx_t* lock_trx;
char* err_buf;
ulint ret;
ut_a(trx && start && wait_lock);
@ -3037,72 +3039,51 @@ lock_deadlock_recursive(
if (lock_trx == start) {
/* We came back to the recursion starting
point: a deadlock detected */
FILE* ef = lock_latest_err_file;
err_buf = lock_latest_err_buf;
rewind(ef);
ut_print_timestamp(ef);
ut_sprintf_timestamp(err_buf);
err_buf += strlen(err_buf);
fputs("\n*** (1) TRANSACTION:\n", ef);
err_buf += sprintf(err_buf,
"\n*** (1) TRANSACTION:\n");
trx_print(ef, wait_lock->trx);
trx_print(err_buf, wait_lock->trx);
err_buf += strlen(err_buf);
err_buf += sprintf(err_buf,
"*** (1) WAITING FOR THIS LOCK TO BE GRANTED:\n");
ut_a(err_buf <= lock_latest_err_buf + 4000);
fputs(
"*** (1) WAITING FOR THIS LOCK TO BE GRANTED:\n", ef);
if (lock_get_type(wait_lock) == LOCK_REC) {
lock_rec_print(err_buf, wait_lock);
err_buf += strlen(err_buf);
lock_rec_print(ef, wait_lock);
} else {
lock_table_print(err_buf, wait_lock);
err_buf += strlen(err_buf);
lock_table_print(ef, wait_lock);
}
ut_a(err_buf <= lock_latest_err_buf + 4000);
err_buf += sprintf(err_buf,
"*** (2) TRANSACTION:\n");
fputs("*** (2) TRANSACTION:\n", ef);
trx_print(err_buf, lock->trx);
err_buf += strlen(err_buf);
trx_print(ef, lock->trx);
err_buf += sprintf(err_buf,
"*** (2) HOLDS THE LOCK(S):\n");
ut_a(err_buf <= lock_latest_err_buf + 4000);
fputs("*** (2) HOLDS THE LOCK(S):\n", ef);
if (lock_get_type(lock) == LOCK_REC) {
lock_rec_print(err_buf, lock);
err_buf += strlen(err_buf);
lock_rec_print(ef, lock);
} else {
lock_table_print(err_buf, lock);
err_buf += strlen(err_buf);
lock_table_print(ef, lock);
}
ut_a(err_buf <= lock_latest_err_buf + 4000);
err_buf += sprintf(err_buf,
"*** (2) WAITING FOR THIS LOCK TO BE GRANTED:\n");
ut_a(err_buf <= lock_latest_err_buf + 4000);
fputs(
"*** (2) WAITING FOR THIS LOCK TO BE GRANTED:\n", ef);
if (lock_get_type(start->wait_lock)
== LOCK_REC) {
lock_rec_print(err_buf,
start->wait_lock);
err_buf += strlen(err_buf);
lock_rec_print(ef, start->wait_lock);
} else {
lock_table_print(err_buf,
start->wait_lock);
err_buf += strlen(err_buf);
lock_table_print(ef, start->wait_lock);
}
#ifdef UNIV_DEBUG
if (lock_print_waits) {
printf("Deadlock detected\n");
fputs("Deadlock detected\n", stderr);
}
#endif /* UNIV_DEBUG */
if (ut_dulint_cmp(wait_lock->trx->undo_no,
start->undo_no) >= 0) {
@ -3116,14 +3097,12 @@ lock_deadlock_recursive(
lock_deadlock_found = TRUE;
ut_a(err_buf <= lock_latest_err_buf + 4000);
/* Let us choose the transaction of wait_lock
as a victim to try to avoid deadlocking our
recursion starting point transaction */
err_buf += sprintf(err_buf,
"*** WE ROLL BACK TRANSACTION (1)\n");
fputs("*** WE ROLL BACK TRANSACTION (1)\n",
ef);
wait_lock->trx->was_chosen_as_deadlock_victim
= TRUE;
@ -3282,11 +3261,12 @@ lock_table_enqueue_waiting(
if (trx->dict_operation) {
ut_print_timestamp(stderr);
fprintf(stderr,
fputs(
" InnoDB: Error: a table lock wait happens in a dictionary operation!\n"
"InnoDB: Table name %s. Send a bug report to mysql@lists.mysql.com\n",
table->name);
"InnoDB: Table name ", stderr);
ut_print_name(stderr, table->name);
fputs(". Send a bug report to mysql@lists.mysql.com\n",
stderr);
}
/* Enqueue the lock request that will wait to be granted */
@ -3704,8 +3684,7 @@ Prints info of a table lock. */
void
lock_table_print(
/*=============*/
char* buf, /* in/out: buffer where to print, must be at least
500 bytes */
FILE* file, /* in: file where to print */
lock_t* lock) /* in: table type lock */
{
#ifdef UNIV_SYNC_DEBUG
@ -3713,30 +3692,30 @@ lock_table_print(
#endif /* UNIV_SYNC_DEBUG */
ut_a(lock_get_type(lock) == LOCK_TABLE);
buf += sprintf(buf, "TABLE LOCK table %s trx id %lu %lu",
lock->un_member.tab_lock.table->name,
fputs("TABLE LOCK table ", file);
ut_print_name(file, lock->un_member.tab_lock.table->name);
fprintf(file, " trx id %lu %lu",
(ulong) (lock->trx)->id.high, (ulong) (lock->trx)->id.low);
if (lock_get_mode(lock) == LOCK_S) {
buf += sprintf(buf, " lock mode S");
fputs(" lock mode S", file);
} else if (lock_get_mode(lock) == LOCK_X) {
buf += sprintf(buf, " lock_mode X");
fputs(" lock mode X", file);
} else if (lock_get_mode(lock) == LOCK_IS) {
buf += sprintf(buf, " lock_mode IS");
fputs(" lock mode IS", file);
} else if (lock_get_mode(lock) == LOCK_IX) {
buf += sprintf(buf, " lock_mode IX");
fputs(" lock mode IX", file);
} else if (lock_get_mode(lock) == LOCK_AUTO_INC) {
buf += sprintf(buf, " lock_mode AUTO-INC");
fputs(" lock mode AUTO-INC", file);
} else {
buf += sprintf(buf,
" unknown lock_mode %lu", (ulong) lock_get_mode(lock));
fprintf(file, " unknown lock mode %lu", (ulong) lock_get_mode(lock));
}
if (lock_get_wait(lock)) {
buf += sprintf(buf, " waiting");
fputs(" waiting", file);
}
buf += sprintf(buf, "\n");
putc('\n', file);
}
/*************************************************************************
@ -3745,16 +3724,13 @@ Prints info of a record lock. */
void
lock_rec_print(
/*===========*/
char* buf, /* in/out: buffer where to print, must be at least
500 bytes */
FILE* file, /* in: file where to print */
lock_t* lock) /* in: record type lock */
{
page_t* page;
ulint space;
ulint page_no;
ulint i;
ulint count = 0;
char* buf_start = buf;
mtr_t mtr;
#ifdef UNIV_SYNC_DEBUG
@ -3765,42 +3741,41 @@ lock_rec_print(
space = lock->un_member.rec_lock.space;
page_no = lock->un_member.rec_lock.page_no;
buf += sprintf(buf, "RECORD LOCKS space id %lu page no %lu n bits %lu",
fprintf(file, "RECORD LOCKS space id %lu page no %lu n bits %lu ",
(ulong) space, (ulong) page_no,
(ulong) lock_rec_get_n_bits(lock));
buf += sprintf(buf, " table %s index %s trx id %lu %lu",
lock->index->table->name, lock->index->name,
dict_index_name_print(file, lock->index);
fprintf(file, " trx id %lu %lu",
(ulong) (lock->trx)->id.high,
(ulong) (lock->trx)->id.low);
if (lock_get_mode(lock) == LOCK_S) {
buf += sprintf(buf, " lock mode S");
fputs(" lock mode S", file);
} else if (lock_get_mode(lock) == LOCK_X) {
buf += sprintf(buf, " lock_mode X");
fputs(" lock_mode X", file);
} else {
ut_error;
}
if (lock_rec_get_gap(lock)) {
buf += sprintf(buf, " locks gap before rec");
fputs(" locks gap before rec", file);
}
if (lock_rec_get_rec_not_gap(lock)) {
buf += sprintf(buf, " locks rec but not gap");
fputs(" locks rec but not gap", file);
}
if (lock_rec_get_insert_intention(lock)) {
buf += sprintf(buf, " insert intention");
fputs(" insert intention", file);
}
if (lock_get_wait(lock)) {
buf += sprintf(buf, " waiting");
fputs(" waiting", file);
}
mtr_start(&mtr);
buf += sprintf(buf, "\n");
putc('\n', file);
/* If the page is not in the buffer pool, we cannot load it
because we have the kernel mutex and ibuf operations would
@ -3830,29 +3805,16 @@ lock_rec_print(
for (i = 0; i < lock_rec_get_n_bits(lock); i++) {
if (buf - buf_start > 300) {
buf += sprintf(buf,
"Suppressing further record lock prints for this page\n");
mtr_commit(&mtr);
return;
}
if (lock_rec_get_nth_bit(lock, i)) {
buf += sprintf(buf, "Record lock, heap no %lu ",
(ulong) i);
fprintf(file, "Record lock, heap no %lu ", (ulong) i);
if (page) {
buf += rec_sprintf(buf, 120,
rec_print(file,
page_find_rec_with_heap_no(page, i));
*buf = '\0';
}
buf += sprintf(buf, "\n");
count++;
putc('\n', file);
}
}
@ -3894,8 +3856,7 @@ Prints info of locks for all transactions. */
void
lock_print_info(
/*============*/
char* buf, /* in/out: buffer where to print */
char* buf_end)/* in: buffer end */
FILE* file) /* in: file where to print */
{
lock_t* lock;
trx_t* trx;
@ -3908,79 +3869,47 @@ lock_print_info(
ulint i;
mtr_t mtr;
if (buf_end - buf < 600) {
sprintf(buf, "... output truncated!\n");
return;
}
lock_mutex_enter_kernel();
if (lock_deadlock_found) {
buf += sprintf(buf,
fputs(
"------------------------\n"
"LATEST DETECTED DEADLOCK\n"
"------------------------\n");
"------------------------\n", file);
if ((ulint)(buf_end - buf)
< 100 + strlen(lock_latest_err_buf)) {
lock_mutex_exit_kernel();
sprintf(buf, "... output truncated!\n");
return;
}
buf += sprintf(buf, "%s", lock_latest_err_buf);
ut_copy_file(file, lock_latest_err_file);
}
if (buf_end - buf < 600) {
lock_mutex_exit_kernel();
sprintf(buf, "... output truncated!\n");
return;
}
buf += sprintf(buf,
fputs(
"------------\n"
"TRANSACTIONS\n"
"------------\n");
"------------\n", file);
buf += sprintf(buf, "Trx id counter %lu %lu\n",
fprintf(file, "Trx id counter %lu %lu\n",
(ulong) ut_dulint_get_high(trx_sys->max_trx_id),
(ulong) ut_dulint_get_low(trx_sys->max_trx_id));
buf += sprintf(buf,
fprintf(file,
"Purge done for trx's n:o < %lu %lu undo n:o < %lu %lu\n",
(ulong) ut_dulint_get_high(purge_sys->purge_trx_no),
(ulong) ut_dulint_get_low(purge_sys->purge_trx_no),
(ulong) ut_dulint_get_high(purge_sys->purge_undo_no),
(ulong) ut_dulint_get_low(purge_sys->purge_undo_no));
buf += sprintf(buf,
fprintf(file,
"Total number of lock structs in row lock hash table %lu\n",
(ulong) lock_get_n_rec_locks());
buf += sprintf(buf, "LIST OF TRANSACTIONS FOR EACH SESSION:\n");
fprintf(file, "LIST OF TRANSACTIONS FOR EACH SESSION:\n");
/* First print info on non-active transactions */
trx = UT_LIST_GET_FIRST(trx_sys->mysql_trx_list);
while (trx) {
if (buf_end - buf < 900) {
lock_mutex_exit_kernel();
sprintf(buf, "... output truncated!\n");
return;
}
if (trx->conc_state == TRX_NOT_STARTED) {
buf += sprintf(buf, "---");
trx_print(buf, trx);
buf += strlen(buf);
fputs("---", file);
trx_print(file, trx);
}
trx = UT_LIST_GET_NEXT(mysql_trx_list, trx);
@ -4004,33 +3933,17 @@ loop:
if (trx == NULL) {
lock_mutex_exit_kernel();
/* lock_validate(); */
return;
}
if (buf_end - buf < 900) {
lock_mutex_exit_kernel();
sprintf(buf, "... output truncated!\n");
ut_ad(lock_validate());
return;
}
if (nth_lock == 0) {
buf += sprintf(buf, "---");
trx_print(buf, trx);
buf += strlen(buf);
if (buf_end - buf < 500) {
lock_mutex_exit_kernel();
sprintf(buf, "... output truncated!\n");
return;
}
fputs("---", file);
trx_print(file, trx);
if (trx->read_view) {
buf += sprintf(buf,
fprintf(file,
"Trx read view will not see trx with id >= %lu %lu, sees < %lu %lu\n",
(ulong) ut_dulint_get_high(trx->read_view->low_limit_id),
(ulong) ut_dulint_get_low(trx->read_view->low_limit_id),
@ -4039,19 +3952,17 @@ loop:
}
if (trx->que_state == TRX_QUE_LOCK_WAIT) {
buf += sprintf(buf,
fprintf(file,
"------- TRX HAS BEEN WAITING %lu SEC FOR THIS LOCK TO BE GRANTED:\n",
(ulong)difftime(time(NULL), trx->wait_started));
if (lock_get_type(trx->wait_lock) == LOCK_REC) {
lock_rec_print(buf, trx->wait_lock);
lock_rec_print(file, trx->wait_lock);
} else {
lock_table_print(buf, trx->wait_lock);
lock_table_print(file, trx->wait_lock);
}
buf += strlen(buf);
buf += sprintf(buf,
"------------------\n");
fputs("------------------\n", file);
}
}
@ -4079,13 +3990,6 @@ loop:
goto loop;
}
if (buf_end - buf < 500) {
lock_mutex_exit_kernel();
sprintf(buf, "... output truncated!\n");
return;
}
if (lock_get_type(lock) == LOCK_REC) {
space = lock->un_member.rec_lock.space;
page_no = lock->un_member.rec_lock.page_no;
@ -4106,22 +4010,21 @@ loop:
goto loop;
}
lock_rec_print(buf, lock);
lock_rec_print(file, lock);
} else {
ut_ad(lock_get_type(lock) == LOCK_TABLE);
lock_table_print(buf, lock);
lock_table_print(file, lock);
}
buf += strlen(buf);
load_page_first = TRUE;
nth_lock++;
if (nth_lock >= 10) {
buf += sprintf(buf,
"10 LOCKS PRINTED FOR THIS TRX: SUPPRESSING FURTHER PRINTS\n");
fputs(
"10 LOCKS PRINTED FOR THIS TRX: SUPPRESSING FURTHER PRINTS\n",
file);
nth_trx++;
nth_lock = 0;
@ -4132,6 +4035,7 @@ loop:
goto loop;
}
#ifdef UNIV_DEBUG
/*************************************************************************
Validates the lock queue on a table. */
@ -4338,8 +4242,8 @@ loop:
index = lock->index;
rec = page_find_rec_with_heap_no(page, i);
printf("Validating %lu %lu\n", (ulong) space,
(ulong) page_no);
fprintf(stderr,
"Validating %lu %lu\n", (ulong) space, (ulong) page_no);
lock_mutex_exit_kernel();
@ -4442,6 +4346,7 @@ lock_validate(void)
return(TRUE);
}
#endif /* UNIV_DEBUG */
/*============ RECORD LOCK CHECKS FOR ROW OPERATIONS ====================*/
@ -4598,7 +4503,6 @@ lock_clust_rec_modify_check_and_lock(
dict_index_t* index, /* in: clustered index */
que_thr_t* thr) /* in: query thread */
{
trx_t* trx;
ulint err;
if (flags & BTR_NO_LOCKING_FLAG) {
@ -4608,8 +4512,6 @@ lock_clust_rec_modify_check_and_lock(
ut_ad(index->type & DICT_CLUSTERED);
trx = thr_get_trx(thr);
lock_mutex_enter_kernel();
ut_ad(lock_table_has(thr_get_trx(thr), index->table, LOCK_IX));

94
innobase/log/log0log.c
View File

@ -511,7 +511,8 @@ log_group_calc_lsn_offset(
ut_a(offset < (((ib_longlong) 1) << 32)); /* offset must be < 4 GB */
/* printf("Offset is %lu gr_lsn_offset is %lu difference is %lu\n",
/* fprintf(stderr,
"Offset is %lu gr_lsn_offset is %lu difference is %lu\n",
(ulint)offset,(ulint)gr_lsn_size_offset, (ulint)difference);
*/
@ -931,8 +932,8 @@ log_group_check_flush_completion(
if (!log_sys->one_flushed && group->n_pending_writes == 0) {
#ifdef UNIV_LOG_DEBUG
if (log_debug_writes) {
printf("Log flushed first to group %lu\n",
(ulong) group->id);
fprintf(stderr,
"Log flushed first to group %lu\n", (ulong) group->id);
}
#endif /* UNIV_LOG_DEBUG */
@ -945,7 +946,7 @@ log_group_check_flush_completion(
#ifdef UNIV_LOG_DEBUG
if (log_debug_writes && (group->n_pending_writes == 0)) {
printf("Log flushed to group %lu\n", (ulong) group->id);
fprintf(stderr, "Log flushed to group %lu\n", (ulong) group->id);
}
#endif /* UNIV_LOG_DEBUG */
@ -1068,7 +1069,6 @@ static
void
log_group_file_header_flush(
/*========================*/
ulint type, /* in: LOG_FLUSH or LOG_RECOVER */
log_group_t* group, /* in: log group */
ulint nth_file, /* in: header to the nth file in the
log file space */
@ -1077,9 +1077,6 @@ log_group_file_header_flush(
{
byte* buf;
ulint dest_offset;
UT_NOT_USED(type);
#ifdef UNIV_SYNC_DEBUG
ut_ad(mutex_own(&(log_sys->mutex)));
#endif /* UNIV_SYNC_DEBUG */
@ -1098,9 +1095,9 @@ log_group_file_header_flush(
#ifdef UNIV_LOG_DEBUG
if (log_debug_writes) {
printf(
"Writing log file header to group %lu file %lu\n",
(ulong) group->id, (ulong) nth_file);
fprintf(stderr,
"Writing log file header to group %lu file %lu\n",
(ulong) group->id, (ulong) nth_file);
}
#endif /* UNIV_LOG_DEBUG */
@ -1134,7 +1131,6 @@ Writes a buffer to a log file group. */
void
log_group_write_buf(
/*================*/
ulint type, /* in: LOG_FLUSH or LOG_RECOVER */
log_group_t* group, /* in: log group */
byte* buf, /* in: buffer */
ulint len, /* in: buffer len; must be divisible
@ -1175,7 +1171,7 @@ loop:
&& write_header) {
/* We start to write a new log file instance in the group */
log_group_file_header_flush(type, group,
log_group_file_header_flush(group,
next_offset / group->file_size, start_lsn);
}
@ -1190,15 +1186,14 @@ loop:
#ifdef UNIV_LOG_DEBUG
if (log_debug_writes) {
printf(
fprintf(stderr,
"Writing log file segment to group %lu offset %lu len %lu\n"
"start lsn %lu %lu\n",
"start lsn %lu %lu\n"
"First block n:o %lu last block n:o %lu\n",
(ulong) group->id, (ulong) next_offset,
(ulong) write_len,
(ulong) ut_dulint_get_high(start_lsn),
(ulong) ut_dulint_get_low(start_lsn));
printf(
"First block n:o %lu last block n:o %lu\n",
(ulong) ut_dulint_get_low(start_lsn).
(ulong) log_block_get_hdr_no(buf),
(ulong) log_block_get_hdr_no(
buf + write_len - OS_FILE_LOG_BLOCK_SIZE));
@ -1279,7 +1274,7 @@ loop:
ut_ad(loop_count < 5);
if (loop_count > 2) {
/* printf("Log loop count %lu\n", loop_count); */
/* fprintf(stderr, "Log loop count %lu\n", loop_count); */
}
mutex_enter(&(log_sys->mutex));
@ -1342,7 +1337,8 @@ loop:
#ifdef UNIV_LOG_DEBUG
if (log_debug_writes) {
printf("Writing log from %lu %lu up to lsn %lu %lu\n",
fprintf(stderr,
"Writing log from %lu %lu up to lsn %lu %lu\n",
(ulong) ut_dulint_get_high(log_sys->written_to_all_lsn),
(ulong) ut_dulint_get_low(log_sys->written_to_all_lsn),
(ulong) ut_dulint_get_high(log_sys->lsn),
@ -1396,7 +1392,7 @@ loop:
/* Do the write to the log files */
while (group) {
log_group_write_buf(LOG_FLUSH, group,
log_group_write_buf(group,
log_sys->buf + area_start,
area_end - area_start,
ut_dulint_align_down(log_sys->written_to_all_lsn,
@ -1762,11 +1758,11 @@ log_reset_first_header_and_checkpoint(
lsn = ut_dulint_add(start, LOG_BLOCK_HDR_SIZE);
/* Write the label of ibbackup --restore */
sprintf((char*) hdr_buf + LOG_FILE_WAS_CREATED_BY_HOT_BACKUP,
strcpy((char*) hdr_buf + LOG_FILE_WAS_CREATED_BY_HOT_BACKUP,
"ibbackup ");
ut_sprintf_timestamp(
(char*) hdr_buf + LOG_FILE_WAS_CREATED_BY_HOT_BACKUP
+ strlen("ibbackup "));
(char*) hdr_buf + (LOG_FILE_WAS_CREATED_BY_HOT_BACKUP
+ (sizeof "ibbackup ") - 1));
buf = hdr_buf + LOG_CHECKPOINT_1;
mach_write_to_8(buf + LOG_CHECKPOINT_NO, ut_dulint_zero);
@ -1909,7 +1905,7 @@ log_checkpoint(
#ifdef UNIV_LOG_DEBUG
if (log_debug_writes) {
printf("Making checkpoint no %lu at lsn %lu %lu\n",
fprintf(stderr, "Making checkpoint no %lu at lsn %lu %lu\n",
(ulong) ut_dulint_get_low(log_sys->next_checkpoint_no),
(ulong) ut_dulint_get_high(oldest_lsn),
(ulong) ut_dulint_get_low(oldest_lsn));
@ -2137,13 +2133,13 @@ void
log_archived_file_name_gen(
/*=======================*/
char* buf, /* in: buffer where to write */
ulint id, /* in: group id */
ulint id __attribute__((unused)),
/* in: group id;
currently we only archive the first group */
ulint file_no)/* in: file number */
{
ut_a(0);
UT_NOT_USED(id); /* Currently we only archive the first group */
sprintf(buf, "%sib_arch_log_%010lu", srv_arch_dir, (ulong) file_no);
}
@ -2292,18 +2288,17 @@ loop:
if (!ret) {
fprintf(stderr,
"InnoDB: Cannot create or open archive log file %s.\n",
name);
fprintf(stderr, "InnoDB: Cannot continue operation.\n"
"InnoDB: Check that the log archive directory exists,\n"
"InnoDB: you have access rights to it, and\n"
"InnoDB: there is space available.\n");
exit(1);
"InnoDB: Cannot create or open archive log file %s.\n"
"InnoDB: Cannot continue operation.\n"
"InnoDB: Check that the log archive directory exists,\n"
"InnoDB: you have access rights to it, and\n"
"InnoDB: there is space available.\n", name);
exit(1);
}
#ifdef UNIV_LOG_DEBUG
if (log_debug_writes) {
printf("Created archive file %s\n", name);
fprintf(stderr, "Created archive file %s\n", name);
}
#endif /* UNIV_LOG_DEBUG */
@ -2334,7 +2329,7 @@ loop:
#ifdef UNIV_LOG_DEBUG
if (log_debug_writes) {
printf(
fprintf(stderr,
"Archiving starting at lsn %lu %lu, len %lu to group %lu\n",
(ulong) ut_dulint_get_high(start_lsn),
(ulong) ut_dulint_get_low(start_lsn),
@ -2437,7 +2432,8 @@ log_archive_write_complete_groups(void)
#ifdef UNIV_LOG_DEBUG
if (log_debug_writes && trunc_files) {
printf("Complete file(s) archived to group %lu\n",
fprintf(stderr,
"Complete file(s) archived to group %lu\n",
(ulong) group->id);
}
#endif /* UNIV_LOG_DEBUG */
@ -2465,7 +2461,7 @@ log_archive_write_complete_groups(void)
#ifdef UNIV_LOG_DEBUG
if (log_debug_writes) {
printf("Archiving writes completed\n");
fputs("Archiving writes completed\n", stderr);
}
#endif /* UNIV_LOG_DEBUG */
}
@ -2488,7 +2484,7 @@ log_archive_check_completion_low(void)
#ifdef UNIV_LOG_DEBUG
if (log_debug_writes) {
printf("Archiving read completed\n");
fputs("Archiving read completed\n", stderr);
}
#endif /* UNIV_LOG_DEBUG */
@ -2640,7 +2636,8 @@ loop:
#ifdef UNIV_LOG_DEBUG
if (log_debug_writes) {
printf("Archiving from lsn %lu %lu to lsn %lu %lu\n",
fprintf(stderr,
"Archiving from lsn %lu %lu to lsn %lu %lu\n",
(ulong) ut_dulint_get_high(log_sys->archived_lsn),
(ulong) ut_dulint_get_low(log_sys->archived_lsn),
(ulong) ut_dulint_get_high(limit_lsn),
@ -2755,7 +2752,7 @@ log_archive_close_groups(
#ifdef UNIV_LOG_DEBUG
if (log_debug_writes) {
printf(
fprintf(stderr,
"Incrementing arch file no to %lu in log group %lu\n",
(ulong) group->archived_file_no + 2,
(ulong) group->id);
@ -3313,20 +3310,15 @@ Prints info of the log. */
void
log_print(
/*======*/
char* buf, /* in/out: buffer where to print */
char* buf_end)/* in: buffer end */
FILE* file) /* in: file where to print */
{
double time_elapsed;
time_t current_time;
if (buf_end - buf < 300) {
return;
}
mutex_enter(&(log_sys->mutex));
buf += sprintf(buf, "Log sequence number %lu %lu\n"
fprintf(file,
"Log sequence number %lu %lu\n"
"Log flushed up to %lu %lu\n"
"Last checkpoint at %lu %lu\n",
(ulong) ut_dulint_get_high(log_sys->lsn),
@ -3340,7 +3332,7 @@ log_print(
time_elapsed = 0.001 + difftime(current_time,
log_sys->last_printout_time);
buf += sprintf(buf,
fprintf(file,
"%lu pending log writes, %lu pending chkp writes\n"
"%lu log i/o's done, %.2f log i/o's/second\n",
(ulong) log_sys->n_pending_writes,

128
innobase/log/log0recv.c
View File

@ -288,8 +288,7 @@ recv_truncate_group(
len = ut_dulint_minus(end_lsn, start_lsn);
log_group_write_buf(LOG_RECOVER, group, log_sys->buf, len,
start_lsn, 0);
log_group_write_buf(group, log_sys->buf, len, start_lsn, 0);
if (ut_dulint_cmp(end_lsn, finish_lsn) >= 0) {
return;
@ -345,8 +344,7 @@ recv_copy_group(
len = ut_dulint_minus(end_lsn, start_lsn);
log_group_write_buf(LOG_RECOVER, group, log_sys->buf, len,
start_lsn, 0);
log_group_write_buf(group, log_sys->buf, len, start_lsn, 0);
if (ut_dulint_cmp(end_lsn, recovered_lsn) >= 0) {
@ -541,7 +539,7 @@ recv_find_max_checkpoint(
"InnoDB: the problem may be that during an earlier attempt you managed\n"
"InnoDB: to create the InnoDB data files, but log file creation failed.\n"
"InnoDB: If that is the case, please refer to section 3.1 of\n"
"InnoDB: http://www.innodb.com/ibman.html\n");
"InnoDB: http://www.innodb.com/ibman.php\n");
return(DB_ERROR);
}
@ -609,7 +607,7 @@ recv_read_cp_info_for_backup(
*fsp_limit = 1000000000;
}
/* printf("fsp limit %lu MB\n", *fsp_limit); */
/* fprintf(stderr, "fsp limit %lu MB\n", *fsp_limit); */
*cp_no = mach_read_from_8(cp_buf + LOG_CHECKPOINT_NO);
@ -685,7 +683,7 @@ recv_scan_log_seg_for_backup(
if (no != log_block_convert_lsn_to_no(*scanned_lsn)
|| !log_block_checksum_is_ok_or_old_format(log_block)) {
/*
printf(
fprintf(stderr,
"Log block n:o %lu, scanned lsn n:o %lu\n",
no, log_block_convert_lsn_to_no(*scanned_lsn));
*/
@ -693,7 +691,7 @@ recv_scan_log_seg_for_backup(
log_block += OS_FILE_LOG_BLOCK_SIZE;
/*
printf(
fprintf(stderr,
"Next log block n:o %lu\n",
log_block_get_hdr_no(log_block));
*/
@ -710,7 +708,8 @@ recv_scan_log_seg_for_backup(
/* Garbage from a log buffer flush which was made
before the most recent database recovery */
/*
printf("Scanned cp n:o %lu, block cp n:o %lu\n",
fprintf(stderr,
"Scanned cp n:o %lu, block cp n:o %lu\n",
*scanned_checkpoint_no,
log_block_get_checkpoint_no(log_block));
*/
@ -728,7 +727,8 @@ recv_scan_log_seg_for_backup(
if (data_len < OS_FILE_LOG_BLOCK_SIZE) {
/* Log data ends here */
/* printf("Log block data len %lu\n", data_len); */
/* fprintf(stderr, "Log block data len %lu\n",
data_len); */
break;
}
@ -939,7 +939,7 @@ recv_add_to_hash_table(
recv_fold(space, page_no), recv_addr);
recv_sys->n_addrs++;
/* printf("Inserting log rec for space %lu, page %lu\n",
/* fprintf(stderr, "Inserting log rec for space %lu, page %lu\n",
space, page_no); */
}
@ -1057,7 +1057,7 @@ recv_recover_page(
return;
}
/* printf("Recovering space %lu, page %lu\n", space, page_no); */
/* fprintf(stderr, "Recovering space %lu, page %lu\n", space, page_no); */
recv_addr->state = RECV_BEING_PROCESSED;
@ -1248,7 +1248,7 @@ recv_read_in_area(
buf_read_recv_pages(FALSE, space, page_nos, n);
/*
printf("Recv pages at %lu n %lu\n", page_nos[0], n);
fprintf(stderr, "Recv pages at %lu n %lu\n", page_nos[0], n);
*/
return(n);
}
@ -1311,9 +1311,9 @@ loop:
if (recv_addr->state == RECV_NOT_PROCESSED) {
if (!has_printed) {
ut_print_timestamp(stderr);
fprintf(stderr,
fputs(
" InnoDB: Starting an apply batch of log records to the database...\n"
"InnoDB: Progress in percents: ");
"InnoDB: Progress in percents: ",stderr);
has_printed = TRUE;
}
@ -1431,9 +1431,9 @@ recv_apply_log_recs_for_backup(void)
page = recv_backup_application_page;
printf(
fputs(
"InnoDB: Starting an apply batch of log records to the database...\n"
"InnoDB: Progress in percents: ");
"InnoDB: Progress in percents: ", stderr);
n_hash_cells = hash_get_n_cells(recv_sys->addr_hash);
@ -1445,7 +1445,7 @@ recv_apply_log_recs_for_backup(void)
if (!fil_tablespace_exists_in_mem(recv_addr->space)) {
/*
printf(
fprintf(stderr,
"InnoDB: Warning: cannot apply log record to tablespace %lu page %lu,\n"
"InnoDB: because tablespace with that id does not exist.\n",
recv_addr->space, recv_addr->page_no);
@ -1478,7 +1478,7 @@ recv_apply_log_recs_for_backup(void)
recv_addr->space,
recv_addr->page_no + 1);
if (!success) {
printf(
fprintf(stderr,
"InnoDB: Fatal error: cannot extend tablespace %lu to hold %lu pages\n",
recv_addr->space, recv_addr->page_no);
@ -1492,9 +1492,9 @@ recv_apply_log_recs_for_backup(void)
recv_addr->page_no, 0, UNIV_PAGE_SIZE,
page, NULL);
if (error != DB_SUCCESS) {
printf(
fprintf(stderr,
"InnoDB: Fatal error: cannot read from tablespace %lu page number %lu\n",
recv_addr->space, recv_addr->page_no);
(ulong) recv_addr->space, (ulong) recv_addr->page_no);
exit(1);
}
@ -1519,8 +1519,9 @@ skip_this_recv_addr:
if ((100 * i) / n_hash_cells
!= (100 * (i + 1)) / n_hash_cells) {
printf("%lu ", (100 * i) / n_hash_cells);
fflush(stdout);
fprintf(stderr, "%lu ",
(ulong) ((100 * i) / n_hash_cells));
fflush(stderr);
}
}
@ -1859,53 +1860,46 @@ recv_report_corrupt_log(
ulint space, /* in: space id, this may also be garbage */
ulint page_no)/* in: page number, this may also be garbage */
{
char* err_buf;
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 %lu %lu\n",
(ulong) type, (ulong) space, (ulong) page_no,
(ulong) ut_dulint_get_high(recv_sys->recovered_lsn),
(ulong) ut_dulint_get_low(recv_sys->recovered_lsn));
err_buf = ut_malloc(1000000);
fprintf(stderr,
"InnoDB: Log parsing proceeded successfully up to %lu %lu\n"
"InnoDB: Previous log record type %lu, is multi %lu\n"
"InnoDB: Recv offset %lu, prev %lu\n",
(ulong) recv_previous_parsed_rec_type,
(ulong) recv_previous_parsed_rec_is_multi,
(ulong) (ptr - recv_sys->buf),
(ulong) recv_previous_parsed_rec_offset);
(ulong) type, (ulong) space, (ulong) page_no,
(ulong) ut_dulint_get_high(recv_sys->recovered_lsn),
(ulong) ut_dulint_get_low(recv_sys->recovered_lsn),
(ulong) recv_previous_parsed_rec_type,
(ulong) recv_previous_parsed_rec_is_multi,
(ulong) (ptr - recv_sys->buf),
(ulong) recv_previous_parsed_rec_offset);
if ((ulint)(ptr - recv_sys->buf + 100)
> recv_previous_parsed_rec_offset
&& (ulint)(ptr - recv_sys->buf + 100
- recv_previous_parsed_rec_offset)
< 200000) {
fputs(
"InnoDB: Hex dump of corrupt log starting 100 bytes before the start\n"
"InnoDB: of the previous log rec,\n"
"InnoDB: and ending 100 bytes after the start of the corrupt rec:\n",
stderr);
ut_sprintf_buf(err_buf,
ut_print_buf(stderr,
recv_sys->buf + recv_previous_parsed_rec_offset - 100,
ptr - recv_sys->buf + 200 -
recv_previous_parsed_rec_offset);
fprintf(stderr,
"InnoDB: Hex dump of corrupt log starting 100 bytes before the start\n"
"InnoDB: of the previous log rec,\n"
"InnoDB: and ending 100 bytes after the start of the corrupt rec:\n%s\n",
err_buf);
putc('\n', stderr);
}
ut_free(err_buf);
fprintf(stderr,
fputs(
"InnoDB: WARNING: the log file may have been corrupt and it\n"
"InnoDB: is possible that the log scan did not proceed\n"
"InnoDB: far enough in recovery! Please run CHECK TABLE\n"
"InnoDB: on your InnoDB tables to check that they are ok!\n"
"InnoDB: If mysqld crashes after this recovery, look at\n"
"InnoDB: section 6.1 of http://www.innodb.com/ibman.html\n"
"InnoDB: about forcing recovery.\n");
"InnoDB: section 6.1 of http://www.innodb.com/ibman.php\n"
"InnoDB: about forcing recovery.\n", stderr);
fflush(stderr);
}
@ -2583,7 +2577,7 @@ recv_recovery_from_checkpoint_start(
log_hdr_buf, max_cp_group);
if (0 == ut_memcmp(log_hdr_buf + LOG_FILE_WAS_CREATED_BY_HOT_BACKUP,
(byte*)"ibbackup", ut_strlen((char*)"ibbackup"))) {
(byte*)"ibbackup", (sizeof "ibbackup") - 1)) {
/* This log file was created by ibbackup --restore: print
a note to the user about it */
@ -2991,38 +2985,47 @@ recv_reset_log_files_for_backup(
ibool success;
byte* buf;
ulint i;
char name[5000];
ulint log_dir_len;
char* name;
static
char logfilename[] = "ib_logfile";
log_dir_len = strlen(log_dir);
/* reserve space for log_dir, "ib_logfile" and a number */
name = memcpy(mem_alloc(log_dir_len + ((sizeof logfilename) + 11)),
log_dir, log_dir_len);
memcpy(name + log_dir_len, logfilename, sizeof logfilename);
buf = ut_malloc(LOG_FILE_HDR_SIZE + OS_FILE_LOG_BLOCK_SIZE);
memset(buf, LOG_FILE_HDR_SIZE + OS_FILE_LOG_BLOCK_SIZE, '\0');
memset(buf, LOG_FILE_HDR_SIZE + OS_FILE_LOG_BLOCK_SIZE, '\0');
for (i = 0; i < n_log_files; i++) {
sprintf(name, "%sib_logfile%lu", log_dir, (ulong) i);
sprintf(name + log_dir_len + sizeof logfilename, "%lu", (ulong) i);
log_file = os_file_create_simple(name, OS_FILE_CREATE,
OS_FILE_READ_WRITE, &success);
if (!success) {
printf(
fprintf(stderr,
"InnoDB: Cannot create %s. Check that the file does not exist yet.\n", name);
exit(1);
}
printf(
"Setting log file size to %lu %lu\n", (ulong) ut_get_high32(log_file_size),
(ulong) (log_file_size & 0xFFFFFFFFUL));
fprintf(stderr,
"Setting log file size to %lu %lu\n",
(ulong) ut_get_high32(log_file_size),
(ulong) log_file_size & 0xFFFFFFFFUL);
success = os_file_set_size(name, log_file,
log_file_size & 0xFFFFFFFFUL,
ut_get_high32(log_file_size));
if (!success) {
printf(
"InnoDB: Cannot set %s size to %lu %lu\n", name,
(ulong) ut_get_high32(log_file_size),
(ulong) (log_file_size & 0xFFFFFFFFUL));
fprintf(stderr,
"InnoDB: Cannot set %s size to %lu %lu\n", name, (ulong) ut_get_high32(log_file_size),
(ulong) (log_file_size & 0xFFFFFFFFUL));
exit(1);
}
@ -3037,12 +3040,12 @@ recv_reset_log_files_for_backup(
log_block_init_in_old_format(buf + LOG_FILE_HDR_SIZE, lsn);
log_block_set_first_rec_group(buf + LOG_FILE_HDR_SIZE,
LOG_BLOCK_HDR_SIZE);
sprintf(name, "%sib_logfile%lu", log_dir, (ulong) 0);
strcpy(name + log_dir_len + sizeof logfilename, "0");
log_file = os_file_create_simple(name, OS_FILE_OPEN,
OS_FILE_READ_WRITE, &success);
if (!success) {
printf("InnoDB: Cannot open %s.\n", name);
fprintf(stderr, "InnoDB: Cannot open %s.\n", name);
exit(1);
}
@ -3052,6 +3055,7 @@ recv_reset_log_files_for_backup(
os_file_flush(log_file);
os_file_close(log_file);
mem_free(name);
ut_free(buf);
}

50
innobase/mem/mem0dbg.c
View File

@ -336,7 +336,7 @@ mem_hash_remove(
}
if (node == NULL) {
printf(
fprintf(stderr,
"Memory heap or buffer freed in %s line %lu did not exist.\n",
file_name, (ulong) line);
ut_error;
@ -351,20 +351,14 @@ mem_hash_remove(
mem_heap_validate_or_print(node->heap, NULL, FALSE, &error, &size,
NULL, NULL);
if (error) {
printf(
"Inconsistency in memory heap or buffer n:o %lu created\n",
(ulong) node->nth_heap);
printf("in %s line %lu and tried to free in %s line %lu.\n",
node->file_name, (ulong) node->line,
file_name, (ulong) line);
printf(
"Hex dump of 400 bytes around memory heap first block start:\n");
ut_print_buf((byte*)(node->heap) - 200, 400);
printf("\nDump of the mem heap:\n");
fprintf(stderr,
"Inconsistency in memory heap or buffer n:o %lu created\n"
"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);
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,
&size, NULL, NULL);
ut_error;
@ -379,6 +373,7 @@ mem_hash_remove(
}
#endif /* UNIV_MEM_DEBUG */
#ifdef UNIV_DEBUG
/*******************************************************************
Checks a memory heap for consistency and prints the contents if requested.
Outputs the sum of sizes of buffers given to the user (only in
@ -440,7 +435,7 @@ mem_heap_validate_or_print(
}
if (print) {
printf("Memory heap:");
fputs("Memory heap:", stderr);
}
while (block != NULL) {
@ -461,7 +456,7 @@ mem_heap_validate_or_print(
/* We can trace the fields of the block only in the debug
version */
if (print) {
printf(" Block %ld:", block_count);
fprintf(stderr, " Block %ld:", block_count);
}
field = (byte*)block + mem_block_get_start(block);
@ -481,7 +476,7 @@ mem_heap_validate_or_print(
len = mem_field_header_get_len(user_field);
if (print) {
ut_print_buf(user_field, len);
ut_print_buf(stderr, user_field, len);
}
total_len += len;
@ -561,7 +556,7 @@ mem_heap_print(
mem_heap_validate_or_print(heap, NULL, TRUE, &error,
&us_size, &phys_size, &n_blocks);
printf(
fprintf(stderr,
"\nheap type: %lu; size: user size %lu; physical size %lu; blocks %lu.\n",
(ulong) heap->type, (ulong) us_size,
(ulong) phys_size, (ulong) n_blocks);
@ -608,6 +603,7 @@ mem_heap_validate(
return(TRUE);
}
#endif /* UNIV_DEBUG */
#ifdef UNIV_MEM_DEBUG
/*********************************************************************
@ -680,9 +676,11 @@ mem_validate_no_assert(void)
&ph_size, &n_blocks);
if (error) {
printf("\nERROR!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n");
printf("Inconsistency in memory heap or buffer created\n");
printf("in %s line %lu.\n", node->file_name, node->line);
fprintf(stderr,
"\nERROR!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n"
"Inconsistency in memory heap or buffer created\n"
"in %s line %lu.\n",
node->file_name, node->line);
mutex_exit(&mem_hash_mutex);
@ -742,12 +740,10 @@ mem_analyze_corruption(
ulint i;
ulint dist;
ut_sprintf_buf(srv_fatal_errbuf, ptr - 250, 500);
fprintf(stderr,
"InnoDB: Apparent memory corruption: mem dump %s\n", srv_fatal_errbuf);
fputs("InnoDB: Apparent memory corruption: mem dump ", stderr);
ut_print_buf(stderr, ptr - 250, 500);
fprintf(stderr,
"InnoDB: Scanning backward trying to find previous allocated mem blocks\n");
fputs("\nInnoDB: Scanning backward trying to find previous allocated mem blocks\n", stderr);
p = ptr;
dist = 0;

7
innobase/mem/mem0mem.c
View File

@ -196,12 +196,7 @@ mem_heap_create_block(
mem_block_set_start(block, MEM_BLOCK_HEADER_SIZE);
block->free_block = NULL;
if (init_block != NULL) {
block->init_block = TRUE;
} else {
block->init_block = FALSE;
}
block->init_block = (init_block != NULL);
ut_ad((ulint)MEM_BLOCK_HEADER_SIZE < len);

2
innobase/mem/mem0pool.c
View File

@ -567,6 +567,7 @@ mem_area_free(
ut_ad(mem_pool_validate(pool));
}
#ifdef UNIV_DEBUG
/************************************************************************
Validates a memory pool. */
@ -644,6 +645,7 @@ mem_pool_print_info(
(ulong) pool->reserved);
mutex_exit(&(pool->mutex));
}
#endif /* UNIV_DEBUG */
/************************************************************************
Returns the amount of reserved memory. */

20
innobase/mtr/mtr0log.c
View File

@ -54,15 +54,15 @@ mlog_write_initial_log_record(
byte* log_ptr;
ut_ad(type <= MLOG_BIGGEST_TYPE);
ut_ad(type > MLOG_8BYTES);
if (ptr < buf_pool->frame_zero || ptr >= buf_pool->high_end) {
fprintf(stderr,
"InnoDB: Error: trying to write to a stray memory location %lx\n",
(ulong) ptr);
"InnoDB: Error: trying to write to a stray memory location %p\n", ptr);
ut_error;
}
log_ptr = mlog_open(mtr, 20);
log_ptr = mlog_open(mtr, 11);
/* If no logging is requested, we may return now */
if (log_ptr == NULL) {
@ -95,6 +95,7 @@ mlog_parse_initial_log_record(
}
*type = (byte)((ulint)*ptr & ~MLOG_SINGLE_REC_FLAG);
ut_ad(*type <= MLOG_BIGGEST_TYPE);
ptr++;
@ -220,8 +221,7 @@ mlog_write_ulint(
if (ptr < buf_pool->frame_zero || ptr >= buf_pool->high_end) {
fprintf(stderr,
"InnoDB: Error: trying to write to a stray memory location %lx\n",
(ulong) ptr);
"InnoDB: Error: trying to write to a stray memory location %p\n", ptr);
ut_error;
}
@ -234,7 +234,7 @@ mlog_write_ulint(
mach_write_to_4(ptr, val);
}
log_ptr = mlog_open(mtr, 30);
log_ptr = mlog_open(mtr, 11 + 2 + 5);
/* If no logging is requested, we may return now */
if (log_ptr == NULL) {
@ -267,8 +267,7 @@ mlog_write_dulint(
if (ptr < buf_pool->frame_zero || ptr >= buf_pool->high_end) {
fprintf(stderr,
"InnoDB: Error: trying to write to a stray memory location %lx\n",
(ulong) ptr);
"InnoDB: Error: trying to write to a stray memory location %p\n", ptr);
ut_error;
}
@ -276,7 +275,7 @@ mlog_write_dulint(
mach_write_to_8(ptr, val);
log_ptr = mlog_open(mtr, 30);
log_ptr = mlog_open(mtr, 11 + 2 + 9);
/* If no logging is requested, we may return now */
if (log_ptr == NULL) {
@ -311,8 +310,7 @@ mlog_write_string(
if (ptr < buf_pool->frame_zero || ptr >= buf_pool->high_end) {
fprintf(stderr,
"InnoDB: Error: trying to write to a stray memory location %lx\n",
(ulong) ptr);
"InnoDB: Error: trying to write to a stray memory location %p\n", ptr);
ut_error;
}
ut_ad(ptr && mtr);

7
innobase/mtr/mtr0mtr.c
View File

@ -262,7 +262,8 @@ mtr_first_to_modify_page_after_backup(
block->frame),
backup_lsn) <= 0) {
printf("Page %lu newest %lu backup %lu\n",
fprintf(stderr,
"Page %lu newest %lu backup %lu\n",
(ulong) block->offset,
(ulong) ut_dulint_get_low(
buf_frame_get_newest_modification(
@ -507,6 +508,7 @@ mtr_read_dulint(
return(mach_read_from_8(ptr));
}
#ifdef UNIV_DEBUG
/*************************************************************
Prints info of an mtr handle. */
@ -515,8 +517,9 @@ mtr_print(
/*======*/
mtr_t* mtr) /* in: mtr */
{
printf(
fprintf(stderr,
"Mini-transaction handle: memo size %lu bytes log size %lu bytes\n",
(ulong) dyn_array_get_data_size(&(mtr->memo)),
(ulong) dyn_array_get_data_size(&(mtr->log)));
}
#endif /* UNIV_DEBUG */

115
innobase/os/os0file.c
View File

@ -234,7 +234,7 @@ os_file_get_last_error(
"InnoDB: of the same name as a data file.\n");
} else {
fprintf(stderr,
"InnoDB: See section 13.2 at http://www.innodb.com/ibman.html\n"
"InnoDB: See section 13.2 at http://www.innodb.com/ibman.php\n"
"InnoDB: about operating system error numbers.\n");
}
}
@ -258,7 +258,7 @@ os_file_get_last_error(
ut_print_timestamp(stderr);
fprintf(stderr,
" InnoDB: Operating system error number %lu in a file operation.\n", err);
" InnoDB: Operating system error number %lu in a file operation.\n", (ulong) err);
if (err == ENOENT) {
fprintf(stderr,
@ -280,7 +280,7 @@ os_file_get_last_error(
}
fprintf(stderr,
"InnoDB: See also section 13.2 at http://www.innodb.com/ibman.html\n"
"InnoDB: See also section 13.2 at http://www.innodb.com/ibman.php\n"
"InnoDB: about operating system error numbers.\n");
}
}
@ -1097,7 +1097,7 @@ try_again:
ut_error;
}
/* printf("Opening file %s, mode %s, type %s, purpose %s\n",
/* fprintf(stderr, "Opening file %s, mode %s, type %s, purpose %s\n",
name, mode_str, type_str, purpose_str); */
#ifdef O_SYNC
/* We let O_SYNC only affect log files; note that we map O_DSYNC to
@ -1106,7 +1106,7 @@ try_again:
if (type == OS_LOG_FILE
&& srv_unix_file_flush_method == SRV_UNIX_O_DSYNC) {
/* printf("Using O_SYNC for file %s\n", name); */
/* fprintf(stderr, "Using O_SYNC for file %s\n", name); */
create_flag = create_flag | O_SYNC;
}
@ -1116,7 +1116,7 @@ try_again:
if (type != OS_LOG_FILE
&& srv_unix_file_flush_method == SRV_UNIX_O_DIRECT) {
/* printf("Using O_DIRECT for file %s\n", name); */
/* fprintf(stderr, "Using O_DIRECT for file %s\n", name); */
create_flag = create_flag | O_DIRECT;
}
@ -1585,7 +1585,7 @@ os_file_flush(
#ifdef HAVE_FDATASYNC
ret = fdatasync(file);
#else
/* printf("Flushing to file %lu\n", (ulint)file); */
/* fprintf(stderr, "Flushing to file %p\n", file); */
ret = fsync(file);
#endif
os_n_fsyncs++;
@ -2029,7 +2029,7 @@ retry:
fprintf(stderr,
" InnoDB: Error: File pointer positioning to file %s failed at\n"
"InnoDB: offset %lu %lu. Operating system error number %lu.\n"
"InnoDB: Look from section 13.2 at http://www.innodb.com/ibman.html\n"
"InnoDB: Look from section 13.2 at http://www.innodb.com/ibman.php\n"
"InnoDB: what the error number means.\n",
name, (ulong) offset_high, (ulong) offset,
(ulong) GetLastError());
@ -2087,7 +2087,7 @@ retry:
}
fprintf(stderr,
"InnoDB: See also section 13.2 at http://www.innodb.com/ibman.html\n"
"InnoDB: See also section 13.2 at http://www.innodb.com/ibman.php\n"
"InnoDB: about operating system error numbers.\n");
os_has_said_disk_full = TRUE;
@ -2122,7 +2122,7 @@ retry:
}
fprintf(stderr,
"InnoDB: See also section 13.2 at http://www.innodb.com/ibman.html\n"
"InnoDB: See also section 13.2 at http://www.innodb.com/ibman.php\n"
"InnoDB: about operating system error numbers.\n");
os_has_said_disk_full = TRUE;
@ -2412,33 +2412,35 @@ os_aio_init(
os_io_init_simple();
for (i = 0; i < n_segments; i++) {
srv_io_thread_op_info[i] = (char*)"not started yet";
srv_set_io_thread_op_info(i, "not started yet");
}
n_per_seg = n / n_segments;
n_write_segs = (n_segments - 2) / 2;
n_read_segs = n_segments - 2 - n_write_segs;
/* printf("Array n per seg %lu\n", n_per_seg); */
/* fprintf(stderr, "Array n per seg %lu\n", n_per_seg); */
os_aio_ibuf_array = os_aio_array_create(n_per_seg, 1);
srv_io_thread_function[0] = (char*)"insert buffer thread";
srv_io_thread_function[0] = "insert buffer thread";
os_aio_log_array = os_aio_array_create(n_per_seg, 1);
srv_io_thread_function[1] = (char*)"log thread";
srv_io_thread_function[1] = "log thread";
os_aio_read_array = os_aio_array_create(n_read_segs * n_per_seg,
n_read_segs);
for (i = 2; i < 2 + n_read_segs; i++) {
srv_io_thread_function[i] = (char*)"read thread";
ut_a(i < SRV_MAX_N_IO_THREADS);
srv_io_thread_function[i] = "read thread";
}
os_aio_write_array = os_aio_array_create(n_write_segs * n_per_seg,
n_write_segs);
for (i = 2 + n_read_segs; i < n_segments; i++) {
srv_io_thread_function[i] = (char*)"write thread";
ut_a(i < SRV_MAX_N_IO_THREADS);
srv_io_thread_function[i] = "write thread";
}
os_aio_sync_array = os_aio_array_create(n_slots_sync, 1);
@ -2768,7 +2770,8 @@ loop:
SIGRTMIN + 1 + os_aio_get_array_no(array);
/* TODO: How to choose the signal numbers? */
/*
printf("AIO signal number %lu\n", (ulint) control->aio_sigevent.sigev_signo);
fprintf(stderr, "AIO signal number %lu\n",
(ulint) control->aio_sigevent.sigev_signo);
*/
control->aio_sigevent.sigev_value.sival_ptr = slot;
#endif
@ -3022,7 +3025,7 @@ try_again:
#elif defined(POSIX_ASYNC_IO)
slot->control.aio_lio_opcode = LIO_READ;
err = (ulint) aio_read(&(slot->control));
printf("Starting Posix aio read %lu\n", err);
fprintf(stderr, "Starting POSIX aio read %lu\n", err);
#endif
} else {
if (!wake_later) {
@ -3039,7 +3042,7 @@ try_again:
#elif defined(POSIX_ASYNC_IO)
slot->control.aio_lio_opcode = LIO_WRITE;
err = (ulint) aio_write(&(slot->control));
printf("Starting Posix aio write %lu\n", err);
fprintf(stderr, "Starting POSIX aio write %lu\n", err);
#endif
} else {
if (!wake_later) {
@ -3150,13 +3153,10 @@ os_aio_windows_handle(
n = array->n_slots / array->n_segments;
if (array == os_aio_sync_array) {
srv_io_thread_op_info[orig_seg] =
"wait Windows aio for 1 page";
os_event_wait(os_aio_array_get_nth_slot(array, pos)->event);
i = pos;
} else {
srv_io_thread_op_info[orig_seg] =
"wait Windows aio";
srv_set_io_thread_op_info(orig_seg, "wait Windows aio");
i = os_event_wait_multiple(n,
(array->native_events) + segment * n);
}
@ -3167,7 +3167,11 @@ os_aio_windows_handle(
ut_a(slot->reserved);
srv_io_thread_op_info[orig_seg] = "get windows aio return value";
if (orig_seg != ULINT_UNDEFINED) {
srv_set_io_thread_op_info(orig_seg,
"get windows aio return value");
}
ret = GetOverlappedResult(slot->file, &(slot->control), &len, TRUE);
*message1 = slot->message1;
@ -3234,7 +3238,7 @@ os_aio_posix_handle(
pthread_sigmask(0, NULL, &thr_sigset);
for (i = 32 ; i < 40; i++) {
printf("%lu : %lu %lu\n", (ulint)i,
fprintf(stderr, "%lu : %lu %lu\n", (ulint)i,
(ulint)sigismember(&proc_sigset, i),
(ulint)sigismember(&thr_sigset, i));
}
@ -3249,7 +3253,7 @@ os_aio_posix_handle(
return(FALSE);
}
printf("Handling Posix aio\n");
fputs("Handling POSIX aio\n", stderr);
array = os_aio_get_array_from_no(array_no);
@ -3490,7 +3494,7 @@ consecutive_loop:
}
}
srv_io_thread_op_info[global_segment] = (char*) "doing file i/o";
srv_set_io_thread_op_info(global_segment, "doing file i/o");
if (os_aio_print_debug) {
fprintf(stderr,
@ -3541,11 +3545,11 @@ consecutive_loop:
}
ut_a(ret);
srv_io_thread_op_info[global_segment] = (char*) "file i/o done";
srv_set_io_thread_op_info(global_segment, "file i/o done");
/* printf("aio: %lu consecutive %lu:th segment, first offs %lu blocks\n",
n_consecutive, global_segment, slot->offset
/ UNIV_PAGE_SIZE); */
/* fprintf(stderr,
"aio: %lu consecutive %lu:th segment, first offs %lu blocks\n",
n_consecutive, global_segment, slot->offset / UNIV_PAGE_SIZE); */
if (slot->type == OS_FILE_READ && n_consecutive > 1) {
/* Copy the combined buffer to individual buffers */
@ -3599,8 +3603,7 @@ wait_for_io:
os_mutex_exit(array->mutex);
recommended_sleep:
srv_io_thread_op_info[global_segment] =
(char*)"waiting for i/o request";
srv_set_io_thread_op_info(global_segment, "waiting for i/o request");
os_event_wait(os_aio_segment_wait_events[global_segment]);
@ -3672,8 +3675,7 @@ Prints info of the aio arrays. */
void
os_aio_print(
/*=========*/
char* buf, /* in/out: buffer where to print */
char* buf_end)/* in: buffer end */
FILE* file) /* in: file where to print */
{
os_aio_array_t* array;
os_aio_slot_t* slot;
@ -3683,19 +3685,13 @@ os_aio_print(
double avg_bytes_read;
ulint i;
if (buf_end - buf < 1200) {
return;
}
for (i = 0; i < srv_n_file_io_threads; i++) {
buf += sprintf(buf, "I/O thread %lu state: %s (%s)\n",
(ulong) i,
fprintf(file, "I/O thread %lu state: %s (%s)\n", (ulong) i,
srv_io_thread_op_info[i],
srv_io_thread_function[i]);
}
buf += sprintf(buf, "Pending normal aio reads:");
fputs("Pending normal aio reads:", file);
array = os_aio_read_array;
loop:
@ -3713,21 +3709,20 @@ loop:
if (slot->reserved) {
n_reserved++;
/* printf("Reserved slot, messages %lx %lx\n",
(ulint)slot->message1,
(ulint)slot->message2);
*/ ut_a(slot->len > 0);
/* fprintf(stderr, "Reserved slot, messages %p %p\n",
slot->message1, slot->message2); */
ut_a(slot->len > 0);
}
}
ut_a(array->n_reserved == n_reserved);
buf += sprintf(buf, " %lu", (ulong) n_reserved);
fprintf(file, " %lu", (ulong) n_reserved);
os_mutex_exit(array->mutex);
if (array == os_aio_read_array) {
buf += sprintf(buf, ", aio writes:");
fputs(", aio writes:", file);
array = os_aio_write_array;
@ -3735,42 +3730,40 @@ loop:
}
if (array == os_aio_write_array) {
buf += sprintf(buf, ",\n ibuf aio reads:");
fputs(",\n ibuf aio reads:", file);
array = os_aio_ibuf_array;
goto loop;
}
if (array == os_aio_ibuf_array) {
buf += sprintf(buf, ", log i/o's:");
fputs(", log i/o's:", file);
array = os_aio_log_array;
goto loop;
}
if (array == os_aio_log_array) {
buf += sprintf(buf, ", sync i/o's:");
fputs(", sync i/o's:", file);
array = os_aio_sync_array;
goto loop;
}
buf += sprintf(buf, "\n");
putc('\n', file);
current_time = time(NULL);
time_elapsed = 0.001 + difftime(current_time, os_last_printout);
buf += sprintf(buf,
"Pending flushes (fsync) log: %lu; buffer pool: %lu\n",
(ulong) fil_n_pending_log_flushes,
(ulong) fil_n_pending_tablespace_flushes);
buf += sprintf(buf,
fprintf(file,
"Pending flushes (fsync) log: %lu; buffer pool: %lu\n"
"%lu OS file reads, %lu OS file writes, %lu OS fsyncs\n",
(ulong) fil_n_pending_log_flushes,
(ulong) fil_n_pending_tablespace_flushes,
(ulong) os_n_file_reads, (ulong) os_n_file_writes,
(ulong) os_n_fsyncs);
if (os_file_n_pending_preads != 0 || os_file_n_pending_pwrites != 0) {
buf += sprintf(buf,
fprintf(file,
"%lu pending preads, %lu pending pwrites\n",
(ulong) os_file_n_pending_preads,
(ulong) os_file_n_pending_pwrites);
@ -3783,7 +3776,7 @@ loop:
(os_n_file_reads - os_n_file_reads_old);
}
buf += sprintf(buf,
fprintf(file,
"%.2f reads/s, %lu avg bytes/read, %.2f writes/s, %.2f fsyncs/s\n",
(os_n_file_reads - os_n_file_reads_old)
/ time_elapsed,

5
innobase/os/os0proc.c
View File

@ -539,9 +539,8 @@ os_process_set_priority_boost(
/* Does not do anything currently!
SetProcessPriorityBoost(GetCurrentProcess(), no_boost);
*/
printf(
"Warning: process priority boost setting currently not functional!\n"
);
fputs("Warning: process priority boost setting currently not functional!\n",
stderr);
#else
UT_NOT_USED(do_boost);
#endif

2
innobase/os/os0thread.c
View File

@ -187,7 +187,7 @@ os_thread_exit(
is cast as a DWORD */
{
#ifdef UNIV_DEBUG_THREAD_CREATION
printf("Thread exits, id %lu\n",
fprintf(stderr, "Thread exits, id %lu\n",
os_thread_pf(os_thread_get_curr_id()));
#endif
os_mutex_enter(os_sync_mutex);

16
innobase/page/page0cur.c
View File

@ -479,6 +479,7 @@ page_cur_insert_rec_write_log(
ulint i;
ut_a(rec_size < UNIV_PAGE_SIZE);
ut_ad(rec_size == rec_get_size(insert_rec));
log_ptr = mlog_open(mtr, 30 + MLOG_BUF_MARGIN);
@ -631,7 +632,7 @@ page_cur_parse_insert_rec(
}
extra_info_yes = end_seg_len & 0x1UL;
end_seg_len = end_seg_len / 2;
end_seg_len >>= 1;
if (end_seg_len >= UNIV_PAGE_SIZE) {
recv_sys->found_corrupt_log = TRUE;
@ -694,7 +695,7 @@ page_cur_parse_insert_rec(
mismatch_index = rec_get_size(cursor_rec) - end_seg_len;
}
if (mismatch_index + end_seg_len < 1024) {
if (mismatch_index + end_seg_len < sizeof buf1) {
buf = buf1;
} else {
buf = mem_alloc(mismatch_index + end_seg_len);
@ -703,8 +704,9 @@ page_cur_parse_insert_rec(
/* Build the inserted record to buf */
if (mismatch_index >= UNIV_PAGE_SIZE) {
printf(
"Is short %lu, info_bits %lu, offset %lu, o_offset %lu\n"
fprintf(stderr,
"Is short %lu, info_bits %lu, offset %lu, "
"o_offset %lu\n"
"mismatch index %lu, end_seg_len %lu\n"
"parsed len %lu\n",
(ulong) is_short, (ulong) info_bits, (ulong) offset,
@ -712,8 +714,8 @@ page_cur_parse_insert_rec(
(ulong) mismatch_index, (ulong) end_seg_len,
(ulong) (ptr - ptr2));
printf("Dump of 300 bytes of log:\n");
ut_print_buf(ptr2, 300);
fputs("Dump of 300 bytes of log:\n", stderr);
ut_print_buf(stderr, ptr2, 300);
buf_page_print(page);
@ -729,7 +731,7 @@ page_cur_parse_insert_rec(
page_cur_rec_insert(&cursor, buf + origin_offset, mtr);
if (mismatch_index + end_seg_len >= 1024) {
if (buf != buf1) {
mem_free(buf);
}

206
innobase/page/page0page.c
View File

@ -75,7 +75,6 @@ page_dir_find_owner_slot(
page_t* page;
page_dir_slot_t* slot;
rec_t* original_rec = rec;
char err_buf[1000];
ut_ad(page_rec_check(rec));
@ -93,20 +92,20 @@ page_dir_find_owner_slot(
if (i == 0) {
fprintf(stderr,
"InnoDB: Probable data corruption on page %lu\n",
"InnoDB: Probable data corruption on page %lu\n"
"InnoDB: Original record ",
(ulong) buf_frame_get_page_no(page));
rec_sprintf(err_buf, 900, original_rec);
rec_print(stderr, original_rec);
fprintf(stderr,
"InnoDB: Original record %s\n"
"InnoDB: on that page. Steps %lu.\n", err_buf, (ulong) steps);
rec_sprintf(err_buf, 900, rec);
fprintf(stderr,
"InnoDB: Cannot find the dir slot for record %s\n"
"InnoDB: on that page!\n", err_buf);
fprintf(stderr, "\n"
"InnoDB: on that page. Steps %lu.\n", (ulong) steps);
fputs(
"InnoDB: Cannot find the dir slot for record ",
stderr);
rec_print(stderr, rec);
fputs("\n"
"InnoDB: on that page!\n", stderr);
buf_page_print(page);
@ -1121,8 +1120,8 @@ page_rec_print(
/*===========*/
rec_t* rec)
{
rec_print(rec);
printf(
rec_print(stderr, rec);
fprintf(stderr,
" n_owned: %lu; heap_no: %lu; next rec: %lu\n",
(ulong) rec_get_n_owned(rec),
(ulong) rec_get_heap_no(rec),
@ -1148,25 +1147,26 @@ page_dir_print(
n = page_dir_get_n_slots(page);
printf("--------------------------------\n");
printf("PAGE DIRECTORY\n");
printf("Page address %lx\n", (ulong)page);
printf("Directory stack top at offs: %lu; number of slots: %lu\n",
(ulong)(page_dir_get_nth_slot(page, n - 1) - page), (ulong) n);
fprintf(stderr, "--------------------------------\n"
"PAGE DIRECTORY\n"
"Page address %p\n"
"Directory stack top at offs: %lu; number of slots: %lu\n",
page, (ulong)(page_dir_get_nth_slot(page, n - 1) - page), (ulong) n);
for (i = 0; i < n; i++) {
slot = page_dir_get_nth_slot(page, i);
if ((i == pr_n) && (i < n - pr_n)) {
printf(" ... \n");
fputs(" ... \n", stderr);
}
if ((i < pr_n) || (i >= n - pr_n)) {
printf(
fprintf(stderr,
"Contents of slot: %lu: n_owned: %lu, rec offs: %lu\n",
(ulong) i, (ulong) page_dir_slot_get_n_owned(slot),
(ulong)(page_dir_slot_get_rec(slot) - page));
}
}
printf("Total of %lu records\n", (ulong) (2 + page_get_n_recs(page)));
printf("--------------------------------\n");
fprintf(stderr, "Total of %lu records\n"
"--------------------------------\n",
(ulong) (2 + page_get_n_recs(page)));
}
/*******************************************************************
@ -1180,21 +1180,20 @@ page_print_list(
ulint pr_n) /* in: print n first and n last entries */
{
page_cur_t cur;
rec_t* rec;
ulint count;
ulint n_recs;
printf("--------------------------------\n");
printf("PAGE RECORD LIST\n");
printf("Page address %lu\n", (ulong) page);
fprintf(stderr,
"--------------------------------\n"
"PAGE RECORD LIST\n"
"Page address %p\n", page);
n_recs = page_get_n_recs(page);
page_cur_set_before_first(page, &cur);
count = 0;
for (;;) {
rec = (&cur)->rec;
page_rec_print(rec);
page_rec_print(cur.rec);
if (count == pr_n) {
break;
@ -1207,24 +1206,22 @@ page_print_list(
}
if (n_recs > 2 * pr_n) {
printf(" ... \n");
fputs(" ... \n", stderr);
}
for (;;) {
if (page_cur_is_after_last(&cur)) {
break;
}
while (!page_cur_is_after_last(&cur)) {
page_cur_move_to_next(&cur);
if (count + pr_n >= n_recs) {
rec = (&cur)->rec;
page_rec_print(rec);
page_rec_print(cur.rec);
}
count++;
}
printf("Total of %lu records \n", (ulong) (count + 1));
printf("--------------------------------\n");
fprintf(stderr,
"Total of %lu records \n"
"--------------------------------\n",
(ulong) (count + 1));
}
/*******************************************************************
@ -1235,21 +1232,19 @@ page_header_print(
/*==============*/
page_t* page)
{
printf("--------------------------------\n");
printf("PAGE HEADER INFO\n");
printf("Page address %lx, n records %lu\n", (ulong) page,
(ulong) page_header_get_field(page, PAGE_N_RECS));
printf("n dir slots %lu, heap top %lu\n",
fprintf(stderr,
"--------------------------------\n"
"PAGE HEADER INFO\n"
"Page address %p, n records %lu\n"
"n dir slots %lu, heap top %lu\n"
"Page n heap %lu, free %lu, garbage %lu\n"
"Page last insert %lu, direction %lu, n direction %lu\n",
page, (ulong) page_header_get_field(page, PAGE_N_RECS),
(ulong) page_header_get_field(page, PAGE_N_DIR_SLOTS),
(ulong) page_header_get_field(page, PAGE_HEAP_TOP));
printf("Page n heap %lu, free %lu, garbage %lu\n",
(ulong) page_header_get_field(page, PAGE_HEAP_TOP),
(ulong) page_header_get_field(page, PAGE_N_HEAP),
(ulong) page_header_get_field(page, PAGE_FREE),
(ulong) page_header_get_field(page, PAGE_GARBAGE));
printf("Page last insert %lu, direction %lu, n direction %lu\n",
(ulong) page_header_get_field(page, PAGE_GARBAGE),
(ulong) page_header_get_field(page, PAGE_LAST_INSERT),
(ulong) page_header_get_field(page, PAGE_DIRECTION),
(ulong) page_header_get_field(page, PAGE_N_DIRECTION));
@ -1559,17 +1554,9 @@ page_validate(
ulint n_slots;
ibool ret = FALSE;
ulint i;
char err_buf[1000];
if (!page_simple_validate(page)) {
fprintf(stderr,
"InnoDB: Apparent corruption in page %lu in index %s in table %s\n",
(ulong) buf_frame_get_page_no(page), index->name,
index->table_name);
buf_page_print(page);
return(FALSE);
goto func_exit2;
}
heap = mem_heap_create(UNIV_PAGE_SIZE);
@ -1589,10 +1576,13 @@ page_validate(
if (!(page_header_get_ptr(page, PAGE_HEAP_TOP) <=
page_dir_get_nth_slot(page, n_slots - 1))) {
fprintf(stderr,
"InnoDB: Record heap and dir overlap on a page in index %s, %lu, %lu\n",
index->name, (ulong)page_header_get_ptr(page, PAGE_HEAP_TOP),
(ulong)page_dir_get_nth_slot(page, n_slots - 1));
fputs("InnoDB: Record heap and dir overlap on a page ",
stderr);
dict_index_name_print(stderr, index);
fprintf(stderr, ", %p, %p\n",
page_header_get_ptr(page, PAGE_HEAP_TOP),
page_dir_get_nth_slot(page, n_slots - 1));
goto func_exit;
}
@ -1608,7 +1598,7 @@ page_validate(
page_cur_set_before_first(page, &cur);
for (;;) {
rec = (&cur)->rec;
rec = cur.rec;
if (!page_rec_validate(rec)) {
goto func_exit;
@ -1618,18 +1608,14 @@ page_validate(
if ((count >= 2) && (!page_cur_is_after_last(&cur))) {
if (!(1 == cmp_rec_rec(rec, old_rec, index))) {
fprintf(stderr,
"InnoDB: Records in wrong order on page %lu index %s table %s\n",
(ulong) buf_frame_get_page_no(page),
index->name,
index->table_name);
rec_sprintf(err_buf, 900, old_rec);
fprintf(stderr,
"InnoDB: previous record %s\n", err_buf);
rec_sprintf(err_buf, 900, rec);
fprintf(stderr,
"InnoDB: record %s\n", err_buf);
"InnoDB: Records in wrong order on page %lu",
(ulong) buf_frame_get_page_no(page));
dict_index_name_print(stderr, index);
fputs("\nInnoDB: previous record ", stderr);
rec_print(stderr, old_rec);
fputs("\nInnoDB: record ", stderr);
rec_print(stderr, rec);
putc('\n', stderr);
goto func_exit;
}
@ -1647,10 +1633,8 @@ page_validate(
if (!buf[offs + i] == 0) {
/* No other record may overlap this */
fprintf(stderr,
"InnoDB: Record overlaps another in index %s \n",
index->name);
fputs("InnoDB: Record overlaps another\n",
stderr);
goto func_exit;
}
@ -1661,19 +1645,16 @@ page_validate(
/* This is a record pointed to by a dir slot */
if (rec_get_n_owned(rec) != own_count) {
fprintf(stderr,
"InnoDB: Wrong owned count %lu, %lu, in index %s\n",
"InnoDB: Wrong owned count %lu, %lu\n",
(ulong) rec_get_n_owned(rec),
(ulong) own_count,
index->name);
(ulong) own_count);
goto func_exit;
}
if (page_dir_slot_get_rec(slot) != rec) {
fprintf(stderr,
"InnoDB: Dir slot does not point to right rec in %s\n",
index->name);
fputs(
"InnoDB: Dir slot does not point to right rec\n",
stderr);
goto func_exit;
}
@ -1693,9 +1674,8 @@ page_validate(
if (rec_get_next_offs(rec) < FIL_PAGE_DATA
|| rec_get_next_offs(rec) >= UNIV_PAGE_SIZE) {
fprintf(stderr,
"InnoDB: Next record offset wrong %lu in index %s\n",
(ulong) rec_get_next_offs(rec), index->name);
"InnoDB: Next record offset wrong %lu\n",
(ulong) rec_get_next_offs(rec));
goto func_exit;
}
@ -1706,24 +1686,20 @@ page_validate(
}
if (rec_get_n_owned(rec) == 0) {
fprintf(stderr,
"InnoDB: n owned is zero in index %s\n", index->name);
fputs("InnoDB: n owned is zero\n", stderr);
goto func_exit;
}
if (slot_no != n_slots - 1) {
fprintf(stderr, "InnoDB: n slots wrong %lu %lu in index %s\n",
(ulong) slot_no, (ulong) (n_slots - 1), index->name);
fprintf(stderr, "InnoDB: n slots wrong %lu %lu\n",
(ulong) slot_no, (ulong) (n_slots - 1));
goto func_exit;
}
if (page_header_get_field(page, PAGE_N_RECS) + 2 != count + 1) {
fprintf(stderr, "InnoDB: n recs wrong %lu %lu in index %s\n",
fprintf(stderr, "InnoDB: n recs wrong %lu %lu\n",
(ulong) page_header_get_field(page, PAGE_N_RECS) + 2,
(ulong) (count + 1),
index->name);
(ulong) (count + 1));
goto func_exit;
}
@ -1749,10 +1725,8 @@ page_validate(
for (i = 0; i < rec_get_size(rec); i++) {
if (buf[offs + i] != 0) {
fprintf(stderr,
"InnoDB: Record overlaps another in free list, index %s \n",
index->name);
fputs(
"InnoDB: Record overlaps another in free list\n", stderr);
goto func_exit;
}
@ -1763,12 +1737,9 @@ page_validate(
}
if (page_header_get_field(page, PAGE_N_HEAP) != count + 1) {
fprintf(stderr,
"InnoDB: N heap is wrong %lu %lu in index %s\n",
fprintf(stderr, "InnoDB: N heap is wrong %lu %lu\n",
(ulong) page_header_get_field(page, PAGE_N_HEAP),
(ulong) count + 1,
index->name);
(ulong) count + 1);
goto func_exit;
}
@ -1778,11 +1749,11 @@ func_exit:
mem_heap_free(heap);
if (ret == FALSE) {
fprintf(stderr,
"InnoDB: Apparent corruption in page %lu in index %s in table %s\n",
(ulong) buf_frame_get_page_no(page), index->name,
index->table_name);
func_exit2:
fprintf(stderr, "InnoDB: Apparent corruption in page %lu in ",
(ulong) buf_frame_get_page_no(page));
dict_index_name_print(stderr, index);
putc('\n', stderr);
buf_page_print(page);
}
@ -1800,16 +1771,13 @@ page_find_rec_with_heap_no(
ulint heap_no)/* in: heap number */
{
page_cur_t cur;
rec_t* rec;
page_cur_set_before_first(page, &cur);
for (;;) {
rec = (&cur)->rec;
if (rec_get_heap_no(cur.rec) == heap_no) {
if (rec_get_heap_no(rec) == heap_no) {
return(rec);
return(cur.rec);
}
if (page_cur_is_after_last(&cur)) {

928
innobase/pars/lexyy.c
View File

File diff suppressed because it is too large Load Diff

77
innobase/pars/pars0lex.l
View File

@ -35,6 +35,19 @@ These instructions seem to work at least with bison-1.28 and flex-2.5.4 on
Linux.
*******************************************************/
%option nostdinit
%option 8bit
%option warn
%option pointer
%option never-interactive
%option nodefault
%option noinput
%option nounput
%option noyywrap
%option noyy_scan_buffer
%option noyy_scan_bytes
%option noyy_scan_string
%{
#define YYSTYPE que_node_t*
@ -45,18 +58,47 @@ Linux.
#include "mem0mem.h"
#include "os0proc.h"
#define isatty(A) 0
#define malloc(A) mem_alloc(A)
#define free(A) mem_free(A)
#define realloc(P, A) mem_realloc(P, A, __FILE__, __LINE__)
#define exit(A) ut_a(0)
#define exit(A) ut_error
#define YY_INPUT(buf, result, max_size) pars_get_lex_chars(buf, &result, max_size)
/* String buffer for removing quotes */
static ulint stringbuf_len_alloc = 0; /* Allocated length */
static ulint stringbuf_len = 0; /* Current length */
static char* stringbuf; /* Start of buffer */
/* Appends a string to the buffer. */
static
void
string_append(
/*==========*/
const char* str, /* in: string to be appended */
ulint len) /* in: length of the string */
{
if (stringbuf_len + len > stringbuf_len_alloc) {
if (stringbuf_len_alloc == 0) {
stringbuf_len_alloc++;
}
while (stringbuf_len + len > stringbuf_len_alloc) {
stringbuf_len_alloc <<= 1;
}
stringbuf = stringbuf
? realloc(stringbuf, stringbuf_len_alloc)
: malloc(stringbuf_len_alloc);
}
memcpy(stringbuf + stringbuf_len, str, len);
stringbuf_len += len;
}
%}
DIGIT [0-9]
ID [a-z_A-Z][a-z_A-Z0-9]*
%x comment
%x quoted
%%
{DIGIT}+ {
@ -71,13 +113,19 @@ ID [a-z_A-Z][a-z_A-Z0-9]*
return(PARS_FLOAT_LIT);
}
"\'"[^\']*"\'" {
/* Remove the single quotes around the string */
yylval = sym_tab_add_str_lit(pars_sym_tab_global,
(byte*)yytext,
ut_strlen(yytext));
return(PARS_STR_LIT);
"'" {
BEGIN(quoted);
stringbuf_len = 0;
}
<quoted>[^\']+ string_append(yytext, yyleng);
<quoted>"'"+ { string_append(yytext, yyleng / 2);
if (yyleng % 2) {
BEGIN(INITIAL);
yylval = sym_tab_add_str_lit(
pars_sym_tab_global,
stringbuf, stringbuf_len);
return(PARS_STR_LIT);
}
}
"NULL" {
@ -89,7 +137,7 @@ ID [a-z_A-Z][a-z_A-Z0-9]*
"SQL" {
/* Implicit cursor name */
yylval = sym_tab_add_str_lit(pars_sym_tab_global,
(byte*)"\'SQL\'", 5);
yytext, yyleng);
return(PARS_SQL_TOKEN);
}
@ -485,17 +533,16 @@ ID [a-z_A-Z][a-z_A-Z0-9]*
"/*" BEGIN(comment); /* eat up comment */
<comment>[^*\n]*
<comment>[^*\n]*\n
<comment>"*"+[^*/\n]*
<comment>"*"+[^*/\n]*\n
<comment>[^*]*
<comment>"*"+[^*/]*
<comment>"*"+"/" BEGIN(INITIAL);
[ \t\n]+ /* eat up whitespace */
. {
printf("Unrecognized character: %s\n", yytext);
fprintf(stderr,"Unrecognized character: %02x\n",
*yytext);
ut_error;

28
innobase/pars/pars0opt.c
View File

@ -532,8 +532,8 @@ opt_search_plan_for_table(
ulint best_goodness;
ulint best_last_op = 0; /* remove warning */
ulint mix_id_pos;
que_node_t* index_plan[128];
que_node_t* best_index_plan[128];
que_node_t* index_plan[256];
que_node_t* best_index_plan[256];
plan = sel_node_get_nth_plan(sel_node, i);
@ -1190,6 +1190,7 @@ opt_search_plan(
#endif
}
#ifdef UNIV_SQL_DEBUG
/************************************************************************
Prints info of a query plan. */
@ -1202,26 +1203,22 @@ opt_print_query_plan(
ulint n_fields;
ulint i;
printf("QUERY PLAN FOR A SELECT NODE\n");
fputs("QUERY PLAN FOR A SELECT NODE\n", stderr);
if (sel_node->asc) {
printf("Asc. search; ");
} else {
printf("Desc. search; ");
}
fputs(sel_node->asc ? "Asc. search; " : "Desc. search; ", stderr);
if (sel_node->set_x_locks) {
printf("sets row x-locks; ");
fputs("sets row x-locks; ", stderr);
ut_a(sel_node->row_lock_mode == LOCK_X);
ut_a(!sel_node->consistent_read);
} else if (sel_node->consistent_read) {
printf("consistent read; ");
fputs("consistent read; ", stderr);
} else {
ut_a(sel_node->row_lock_mode == LOCK_S);
printf("sets row s-locks; ");
fputs("sets row s-locks; ", stderr);
}
printf("\n");
putc('\n', stderr);
for (i = 0; i < sel_node->n_tables; i++) {
plan = sel_node_get_nth_plan(sel_node, i);
@ -1232,11 +1229,12 @@ opt_print_query_plan(
n_fields = 0;
}
printf(
"Table %s index %s; exact m. %lu, match %lu, end conds %lu\n",
plan->table->name, plan->index->name,
fputs("Table ", stderr);
dict_index_name_print(stderr, plan->index);
fprintf(stderr,"; exact m. %lu, match %lu, end conds %lu\n",
(unsigned long) plan->n_exact_match,
(unsigned long) n_fields,
(unsigned long) UT_LIST_GET_LEN(plan->end_conds));
}
}
#endif /* UNIV_SQL_DEBUG */

21
innobase/pars/pars0pars.c
View File

@ -1707,17 +1707,6 @@ pars_get_lex_chars(
pars_sym_tab_global->next_char_pos += len;
}
/*****************************************************************
Instructs the lexical analyzer to stop when it receives the EOF integer. */
int
yywrap(void)
/*========*/
/* out: returns TRUE */
{
return(1);
}
/*****************************************************************
Called by yyparse on error. */
@ -1745,8 +1734,6 @@ pars_sql(
sym_node_t* sym_node;
mem_heap_t* heap;
que_t* graph;
ulint len;
char* buf;
ut_ad(str);
@ -1758,12 +1745,8 @@ pars_sql(
#endif /* UNIV_SYNC_DEBUG */
pars_sym_tab_global = sym_tab_create(heap);
len = ut_strlen(str);
buf = mem_heap_alloc(heap, len + 1);
ut_memcpy(buf, str, len + 1);
pars_sym_tab_global->sql_string = buf;
pars_sym_tab_global->string_len = len;
pars_sym_tab_global->sql_string = mem_heap_strdup(heap, str);
pars_sym_tab_global->string_len = strlen(str);
pars_sym_tab_global->next_char_pos = 0;
yyparse();

27
innobase/pars/pars0sym.c
View File

@ -127,18 +127,12 @@ sym_tab_add_str_lit(
/*================*/
/* out: symbol table node */
sym_tab_t* sym_tab, /* in: symbol table */
byte* str, /* in: string starting with a single
quote; the string literal will
extend to the next single quote, but
the quotes are not included in it */
byte* str, /* in: string with no quotes around
it */
ulint len) /* in: string length */
{
sym_node_t* node;
byte* data;
ulint i;
ut_a(len > 1);
ut_a(str[0] == '\'');
node = mem_heap_alloc(sym_tab->heap, sizeof(sym_node_t));
@ -151,23 +145,14 @@ sym_tab_add_str_lit(
dtype_set(&(node->common.val.type), DATA_VARCHAR, DATA_ENGLISH, 0, 0);
for (i = 1;; i++) {
ut_a(i < len);
if (str[i] == '\'') {
break;
}
}
if (i > 1) {
data = mem_heap_alloc(sym_tab->heap, i - 1);
ut_memcpy(data, str + 1, i - 1);
if (len) {
data = mem_heap_alloc(sym_tab->heap, len);
ut_memcpy(data, str, len);
} else {
data = NULL;
}
dfield_set_data(&(node->common.val), data, i - 1);
dfield_set_data(&(node->common.val), data, len);
node->common.val_buf_size = 0;
node->prefetch_buf = NULL;

89
innobase/rem/rem0rec.c
View File

@ -112,7 +112,7 @@ rec_get_nth_field(
}
if (rec == NULL) {
fprintf(stderr, "Error: rec is NULL pointer\n");
fputs("Error: rec is NULL pointer\n", stderr);
ut_error;
}
@ -518,110 +518,47 @@ Prints a physical record. */
void
rec_print(
/*======*/
FILE* file, /* in: file where to print */
rec_t* rec) /* in: physical record */
{
byte* data;
ulint len;
char* offs;
ulint n;
ulint i;
ut_ad(rec);
if (rec_get_1byte_offs_flag(rec)) {
offs = (char *) "TRUE";
} else {
offs = (char *) "FALSE";
}
n = rec_get_n_fields(rec);
printf(
"PHYSICAL RECORD: n_fields %lu; 1-byte offs %s; info bits %lu\n",
(ulong) n, offs, (ulong) rec_get_info_bits(rec));
fprintf(file, "PHYSICAL RECORD: n_fields %lu;"
" 1-byte offs %s; info bits %lu\n",
(ulong) n, rec_get_1byte_offs_flag(rec) ? "TRUE" : "FALSE",
(ulong) rec_get_info_bits(rec));
for (i = 0; i < n; i++) {
data = rec_get_nth_field(rec, i, &len);
printf(" %lu:", (ulong) i);
fprintf(file, " %lu:", (ulong) i);
if (len != UNIV_SQL_NULL) {
if (len <= 30) {
ut_print_buf(data, len);
ut_print_buf(file, data, len);
} else {
ut_print_buf(data, 30);
ut_print_buf(file, data, 30);
printf("...(truncated)");
fputs("...(truncated)", file);
}
} else {
printf(" SQL NULL, size %lu ",
fprintf(file, " SQL NULL, size %lu ",
(ulong) rec_get_nth_field_size(rec, i));
}
printf(";");
putc(';', file);
}
printf("\n");
putc('\n', file);
rec_validate(rec);
}
/*******************************************************************
Prints a physical record to a buffer. */
ulint
rec_sprintf(
/*========*/
/* out: printed length in bytes */
char* buf, /* in: buffer to print to */
ulint buf_len,/* in: buffer length */
rec_t* rec) /* in: physical record */
{
byte* data;
ulint len;
ulint k;
ulint n;
ulint i;
ut_ad(rec);
n = rec_get_n_fields(rec);
k = 0;
if (k + 30 > buf_len) {
return(k);
}
k += sprintf(buf + k, "RECORD: info bits %lu",
(ulong) rec_get_info_bits(rec));
for (i = 0; i < n; i++) {
if (k + 30 > buf_len) {
return(k);
}
data = rec_get_nth_field(rec, i, &len);
k += sprintf(buf + k, " %lu:", (ulong) i);
if (len != UNIV_SQL_NULL) {
if (k + 30 + 5 * len > buf_len) {
return(k);
}
k += ut_sprintf_buf(buf + k, data, len);
} else {
k += sprintf(buf + k, " SQL NULL");
}
k += sprintf(buf + k, ";");
}
return(k);
}

Some files were not shown because too many files have changed in this diff Show More