summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--client/mysqlcheck.c113
-rw-r--r--mysys/array.c2
-rw-r--r--mysys/default.c5
-rw-r--r--mysys/hash.c6
-rw-r--r--mysys/my_getopt.c100
-rw-r--r--mysys/my_malloc.c12
-rw-r--r--mysys/my_open.c5
-rw-r--r--mysys/string.c5
-rw-r--r--sql-common/client.c2
-rw-r--r--sql-common/client_plugin.c45
-rw-r--r--sql/handler.h6
-rw-r--r--sql/log.cc6
-rw-r--r--sql/log.h20
-rw-r--r--sql/rpl_tblmap.cc2
-rw-r--r--sql/sql_class.cc4
-rw-r--r--sql/sql_lex.cc2
-rw-r--r--sql/sql_parse.cc3
-rw-r--r--sql/sql_plugin.cc7
-rw-r--r--storage/myisam/ha_myisam.cc10
-rw-r--r--storage/perfschema/pfs_instr.cc135
20 files changed, 326 insertions, 164 deletions
diff --git a/client/mysqlcheck.c b/client/mysqlcheck.c
index 5e0621469a3..8139c373f2c 100644
--- a/client/mysqlcheck.c
+++ b/client/mysqlcheck.c
@@ -224,6 +224,7 @@ static void print_version(void)
static void usage(void)
{
+ DBUG_ENTER("usage");
print_version();
puts(ORACLE_WELCOME_COPYRIGHT_NOTICE("2000, 2010"));
printf("Usage: %s [OPTIONS] database [tables]\n", my_progname);
@@ -247,6 +248,7 @@ static void usage(void)
print_defaults("my", load_default_groups);
my_print_help(my_long_options);
my_print_variables(my_long_options);
+ DBUG_VOID_RETURN;
} /* usage */
@@ -255,6 +257,7 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
char *argument)
{
int orig_what_to_do= what_to_do;
+ DBUG_ENTER("get_one_option");
switch(optid) {
case 'a':
@@ -335,15 +338,16 @@ get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
{
fprintf(stderr, "Error: %s doesn't support multiple contradicting commands.\n",
my_progname);
- return 1;
+ DBUG_RETURN(1);
}
- return 0;
+ DBUG_RETURN(0);
}
static int get_options(int *argc, char ***argv)
{
int ho_error;
+ DBUG_ENTER("get_options");
if (*argc == 1)
{
@@ -385,21 +389,21 @@ static int get_options(int *argc, char ***argv)
!get_charset_by_csname(default_charset, MY_CS_PRIMARY, MYF(MY_WME)))
{
printf("Unsupported character set: %s\n", default_charset);
- return 1;
+ DBUG_RETURN(1);
}
if (*argc > 0 && opt_alldbs)
{
printf("You should give only options, no arguments at all, with option\n");
printf("--all-databases. Please see %s --help for more information.\n",
my_progname);
- return 1;
+ DBUG_RETURN(1);
}
if (*argc < 1 && !opt_alldbs)
{
printf("You forgot to give the arguments! Please see %s --help\n",
my_progname);
printf("for more information.\n");
- return 1;
+ DBUG_RETURN(1);
}
if (tty_password)
opt_password = get_tty_password(NullS);
@@ -407,7 +411,7 @@ static int get_options(int *argc, char ***argv)
my_end_arg= MY_CHECK_ERROR | MY_GIVE_INFO;
if (debug_check_flag)
my_end_arg= MY_CHECK_ERROR;
- return(0);
+ DBUG_RETURN((0));
} /* get_options */
@@ -416,13 +420,14 @@ static int process_all_databases()
MYSQL_ROW row;
MYSQL_RES *tableres;
int result = 0;
+ DBUG_ENTER("process_all_databases");
if (mysql_query(sock, "SHOW DATABASES") ||
!(tableres = mysql_store_result(sock)))
{
my_printf_error(0, "Error: Couldn't execute 'SHOW DATABASES': %s",
MYF(0), mysql_error(sock));
- return 1;
+ DBUG_RETURN(1);
}
if (verbose)
printf("Processing databases\n");
@@ -432,7 +437,7 @@ static int process_all_databases()
result = 1;
}
mysql_free_result(tableres);
- return result;
+ DBUG_RETURN(result);
}
/* process_all_databases */
@@ -440,6 +445,8 @@ static int process_all_databases()
static int process_databases(char **db_names)
{
int result = 0;
+ DBUG_ENTER("process_databases");
+
if (verbose)
printf("Processing databases\n");
for ( ; *db_names ; db_names++)
@@ -447,14 +454,16 @@ static int process_databases(char **db_names)
if (process_one_db(*db_names))
result = 1;
}
- return result;
+ DBUG_RETURN(result);
} /* process_databases */
static int process_selected_tables(char *db, char **table_names, int tables)
{
+ DBUG_ENTER("process_selected_tables");
+
if (use_db(db))
- return 1;
+ DBUG_RETURN(1);
if (opt_all_in_1 && what_to_do != DO_UPGRADE)
{
/*
@@ -471,7 +480,7 @@ static int process_selected_tables(char *db, char **table_names, int tables)
if (!(table_names_comma_sep = (char *)
my_malloc((sizeof(char) * tot_length) + 4, MYF(MY_WME))))
- return 1;
+ DBUG_RETURN(1);
for (end = table_names_comma_sep + 1; tables > 0;
tables--, table_names++)
@@ -486,7 +495,7 @@ static int process_selected_tables(char *db, char **table_names, int tables)
else
for (; tables > 0; tables--, table_names++)
handle_request_for_tables(*table_names, fixed_name_length(*table_names));
- return 0;
+ DBUG_RETURN(0);
} /* process_selected_tables */
@@ -494,20 +503,24 @@ static uint fixed_name_length(const char *name)
{
const char *p;
uint extra_length= 2; /* count the first/last backticks */
-
+ DBUG_ENTER("fixed_name_length");
+
for (p= name; *p; p++)
{
if (*p == '`')
extra_length++;
else if (*p == '.')
extra_length+= 2;
+
}
- return (uint) ((p - name) + extra_length);
+ DBUG_RETURN((uint) ((p - name) + extra_length));
}
static char *fix_table_name(char *dest, char *src)
{
+ DBUG_ENTER("fix_table_name");
+
*dest++= '`';
for (; *src; src++)
{
@@ -525,27 +538,28 @@ static char *fix_table_name(char *dest, char *src)
}
}
*dest++= '`';
- return dest;
+
+ DBUG_RETURN(dest);
}
static int process_all_tables_in_db(char *database)
{
- MYSQL_RES *res;
+ MYSQL_RES *UNINIT_VAR(res);
MYSQL_ROW row;
uint num_columns;
my_bool system_database= 0;
+ DBUG_ENTER("process_all_tables_in_db");
- LINT_INIT(res);
if (use_db(database))
- return 1;
+ DBUG_RETURN(1);
if ((mysql_query(sock, "SHOW /*!50002 FULL*/ TABLES") &&
mysql_query(sock, "SHOW TABLES")) ||
!(res= mysql_store_result(sock)))
{
my_printf_error(0, "Error: Couldn't get table list for database %s: %s",
MYF(0), database, mysql_error(sock));
- return 1;
+ DBUG_RETURN(1);
}
if (!strcmp(database, "mysql") || !strcmp(database, "MYSQL"))
@@ -571,7 +585,7 @@ static int process_all_tables_in_db(char *database)
if (!(tables=(char *) my_malloc(sizeof(char)*tot_length+4, MYF(MY_WME))))
{
mysql_free_result(res);
- return 1;
+ DBUG_RETURN(1);
}
for (end = tables + 1; (row = mysql_fetch_row(res)) ;)
{
@@ -602,7 +616,7 @@ static int process_all_tables_in_db(char *database)
}
}
mysql_free_result(res);
- return 0;
+ DBUG_RETURN(0);
} /* process_all_tables_in_db */
@@ -611,8 +625,10 @@ static int fix_table_storage_name(const char *name)
{
char qbuf[100 + NAME_LEN*4];
int rc= 0;
+ DBUG_ENTER("fix_table_storage_name");
+
if (strncmp(name, "#mysql50#", 9))
- return 1;
+ DBUG_RETURN(1);
sprintf(qbuf, "RENAME TABLE `%s` TO `%s`", name, name + 9);
if (mysql_query(sock, qbuf))
{
@@ -622,15 +638,17 @@ static int fix_table_storage_name(const char *name)
}
if (verbose)
printf("%-50s %s\n", name, rc ? "FAILED" : "OK");
- return rc;
+ DBUG_RETURN(rc);
}
static int fix_database_storage_name(const char *name)
{
char qbuf[100 + NAME_LEN*4];
int rc= 0;
+ DBUG_ENTER("fix_database_storage_name");
+
if (strncmp(name, "#mysql50#", 9))
- return 1;
+ DBUG_RETURN(1);
sprintf(qbuf, "ALTER DATABASE `%s` UPGRADE DATA DIRECTORY NAME", name);
if (mysql_query(sock, qbuf))
{
@@ -640,17 +658,19 @@ static int fix_database_storage_name(const char *name)
}
if (verbose)
printf("%-50s %s\n", name, rc ? "FAILED" : "OK");
- return rc;
+ DBUG_RETURN(rc);
}
static int rebuild_table(char *name)
{
char *query, *ptr;
int rc= 0;
+ DBUG_ENTER("rebuild_table");
+
query= (char*)my_malloc(sizeof(char) * (12 + fixed_name_length(name) + 6 + 1),
MYF(MY_WME));
if (!query)
- return 1;
+ DBUG_RETURN(1);
ptr= strmov(query, "ALTER TABLE ");
ptr= fix_table_name(ptr, name);
ptr= strxmov(ptr, " FORCE", NullS);
@@ -661,11 +681,13 @@ static int rebuild_table(char *name)
rc= 1;
}
my_free(query);
- return rc;
+ DBUG_RETURN(rc);
}
static int process_one_db(char *database)
{
+ DBUG_ENTER("process_one_db");
+
if (verbose)
puts(database);
if (what_to_do == DO_UPGRADE)
@@ -677,38 +699,42 @@ static int process_one_db(char *database)
database+= 9;
}
if (rc || !opt_fix_table_names)
- return rc;
+ DBUG_RETURN(rc);
}
- return process_all_tables_in_db(database);
+ DBUG_RETURN(process_all_tables_in_db(database));
}
static int use_db(char *database)
{
+ DBUG_ENTER("use_db");
+
if (mysql_get_server_version(sock) >= FIRST_INFORMATION_SCHEMA_VERSION &&
!my_strcasecmp(&my_charset_latin1, database, INFORMATION_SCHEMA_DB_NAME))
- return 1;
+ DBUG_RETURN(1);
if (mysql_get_server_version(sock) >= FIRST_PERFORMANCE_SCHEMA_VERSION &&
!my_strcasecmp(&my_charset_latin1, database, PERFORMANCE_SCHEMA_DB_NAME))
- return 1;
+ DBUG_RETURN(1);
if (mysql_select_db(sock, database))
{
DBerror(sock, "when selecting the database");
- return 1;
+ DBUG_RETURN(1);
}
- return 0;
+ DBUG_RETURN(0);
} /* use_db */
static int disable_binlog()
{
const char *stmt= "SET SQL_LOG_BIN=0";
+ DBUG_ENTER("disable_binlog");
+
if (mysql_query(sock, stmt))
{
fprintf(stderr, "Failed to %s\n", stmt);
fprintf(stderr, "Error: %s\n", mysql_error(sock));
- return 1;
+ DBUG_RETURN(1);
}
- return 0;
+ DBUG_RETURN(0);
}
static int handle_request_for_tables(char *tables, uint length)
@@ -716,6 +742,7 @@ static int handle_request_for_tables(char *tables, uint length)
char *query, *end, options[100], message[100];
uint query_length= 0;
const char *op = 0;
+ DBUG_ENTER("handle_request_for_tables");
options[0] = 0;
end = options;
@@ -742,11 +769,11 @@ static int handle_request_for_tables(char *tables, uint length)
op= (opt_write_binlog) ? "OPTIMIZE" : "OPTIMIZE NO_WRITE_TO_BINLOG";
break;
case DO_UPGRADE:
- return fix_table_storage_name(tables);
+ DBUG_RETURN(fix_table_storage_name(tables));
}
if (!(query =(char *) my_malloc((sizeof(char)*(length+110)), MYF(MY_WME))))
- return 1;
+ DBUG_RETURN(1);
if (opt_all_in_1)
{
/* No backticks here as we added them before */
@@ -765,11 +792,11 @@ static int handle_request_for_tables(char *tables, uint length)
{
sprintf(message, "when executing '%s TABLE ... %s'", op, options);
DBerror(sock, message);
- return 1;
+ DBUG_RETURN(1);
}
print_result();
my_free(query);
- return 0;
+ DBUG_RETURN(0);
}
@@ -780,6 +807,7 @@ static void print_result()
char prev[(NAME_LEN+9)*2+2];
uint i;
my_bool found_error=0, table_rebuild=0;
+ DBUG_ENTER("print_result");
res = mysql_use_result(sock);
@@ -843,6 +871,7 @@ static void print_result()
insert_dynamic(&tables4repair, (uchar*) prev);
}
mysql_free_result(res);
+ DBUG_VOID_RETURN;
}
@@ -888,9 +917,11 @@ static int dbConnect(char *host, char *user, char *passwd)
static void dbDisconnect(char *host)
{
+ DBUG_ENTER("dbDisconnect");
if (verbose > 1)
fprintf(stderr, "# Disconnecting from %s...\n", host ? host : "localhost");
mysql_close(sock);
+ DBUG_VOID_RETURN;
} /* dbDisconnect */
@@ -906,13 +937,15 @@ static void DBerror(MYSQL *mysql, const char *when)
static void safe_exit(int error)
{
+ DBUG_ENTER("safe_exit");
if (!first_error)
first_error= error;
if (ignore_errors)
- return;
+ DBUG_VOID_RETURN;
if (sock)
mysql_close(sock);
exit(error);
+ DBUG_VOID_RETURN;
}
diff --git a/mysys/array.c b/mysys/array.c
index 83a879768c4..d5a4a6fa284 100644
--- a/mysys/array.c
+++ b/mysys/array.c
@@ -44,7 +44,7 @@ my_bool init_dynamic_array2(DYNAMIC_ARRAY *array, uint element_size,
void *init_buffer, uint init_alloc,
uint alloc_increment)
{
- DBUG_ENTER("init_dynamic_array");
+ DBUG_ENTER("init_dynamic_array2");
if (!alloc_increment)
{
alloc_increment=max((8192-MALLOC_OVERHEAD)/element_size,16);
diff --git a/mysys/default.c b/mysys/default.c
index fe070f42748..c7ac0d89462 100644
--- a/mysys/default.c
+++ b/mysys/default.c
@@ -1198,10 +1198,11 @@ static const char **init_default_directories(MEM_ROOT *alloc)
const char **dirs;
char *env;
int errors= 0;
+ DBUG_ENTER("init_default_directories");
dirs= (const char **)alloc_root(alloc, DEFAULT_DIRS_SIZE * sizeof(char *));
if (dirs == NULL)
- return NULL;
+ DBUG_RETURN(NULL);
bzero((char *) dirs, DEFAULT_DIRS_SIZE * sizeof(char *));
#ifdef __WIN__
@@ -1242,5 +1243,5 @@ static const char **init_default_directories(MEM_ROOT *alloc)
errors += add_directory(alloc, "~/", dirs);
#endif
- return (errors > 0 ? NULL : dirs);
+ DBUG_RETURN(errors > 0 ? NULL : dirs);
}
diff --git a/mysys/hash.c b/mysys/hash.c
index 392d4f4fe15..55b96afe615 100644
--- a/mysys/hash.c
+++ b/mysys/hash.c
@@ -77,6 +77,7 @@ _my_hash_init(HASH *hash, uint growth_size, CHARSET_INFO *charset,
my_hash_get_key get_key,
void (*free_element)(void*), uint flags)
{
+ my_bool res;
DBUG_ENTER("my_hash_init");
DBUG_PRINT("enter",("hash: 0x%lx size: %u", (long) hash, (uint) size));
@@ -88,8 +89,9 @@ _my_hash_init(HASH *hash, uint growth_size, CHARSET_INFO *charset,
hash->free=free_element;
hash->flags=flags;
hash->charset=charset;
- DBUG_RETURN(my_init_dynamic_array_ci(&hash->array,
- sizeof(HASH_LINK), size, growth_size));
+ res= my_init_dynamic_array_ci(&hash->array,
+ sizeof(HASH_LINK), size, growth_size);
+ DBUG_RETURN(res);
}
diff --git a/mysys/my_getopt.c b/mysys/my_getopt.c
index fff8fda581c..d9e34cbece6 100644
--- a/mysys/my_getopt.c
+++ b/mysys/my_getopt.c
@@ -72,6 +72,8 @@ static void default_reporter(enum loglevel level,
const char *format, ...)
{
va_list args;
+ DBUG_ENTER("default_reporter");
+
va_start(args, format);
if (level == WARNING_LEVEL)
fprintf(stderr, "%s", "Warning: ");
@@ -81,6 +83,7 @@ static void default_reporter(enum loglevel level,
va_end(args);
fputc('\n', stderr);
fflush(stderr);
+ DBUG_VOID_RETURN;
}
static my_getopt_value getopt_get_addr;
@@ -162,6 +165,7 @@ int handle_options(int *argc, char ***argv,
void *value;
int error, i;
my_bool is_cmdline_arg= 1;
+ DBUG_ENTER("handle_options");
/* handle_options() assumes arg0 (program name) always exists */
DBUG_ASSERT(argc && *argc >= 1);
@@ -263,7 +267,7 @@ int handle_options(int *argc, char ***argv,
my_progname, special_opt_prefix[i],
opt_str, special_opt_prefix[i],
prev_found);
- return EXIT_AMBIGUOUS_OPTION;
+ DBUG_RETURN(EXIT_AMBIGUOUS_OPTION);
}
switch (i) {
case OPT_SKIP:
@@ -308,7 +312,7 @@ int handle_options(int *argc, char ***argv,
"%s: unknown variable '%s'",
my_progname, cur_arg);
if (!option_is_loose)
- return EXIT_UNKNOWN_VARIABLE;
+ DBUG_RETURN(EXIT_UNKNOWN_VARIABLE);
}
else
{
@@ -318,7 +322,7 @@ int handle_options(int *argc, char ***argv,
"%s: unknown option '--%s'",
my_progname, cur_arg);
if (!option_is_loose)
- return EXIT_UNKNOWN_OPTION;
+ DBUG_RETURN(EXIT_UNKNOWN_OPTION);
}
if (option_is_loose)
{
@@ -335,7 +339,7 @@ int handle_options(int *argc, char ***argv,
my_getopt_error_reporter(ERROR_LEVEL,
"%s: variable prefix '%s' is not unique",
my_progname, opt_str);
- return EXIT_VAR_PREFIX_NOT_UNIQUE;
+ DBUG_RETURN(EXIT_VAR_PREFIX_NOT_UNIQUE);
}
else
{
@@ -344,7 +348,7 @@ int handle_options(int *argc, char ***argv,
"%s: ambiguous option '--%s' (%s, %s)",
my_progname, opt_str, prev_found,
optp->name);
- return EXIT_AMBIGUOUS_OPTION;
+ DBUG_RETURN(EXIT_AMBIGUOUS_OPTION);
}
}
if ((optp->var_type & GET_TYPE_MASK) == GET_DISABLED)
@@ -358,14 +362,14 @@ int handle_options(int *argc, char ***argv,
(*argc)--;
continue;
}
- return EXIT_OPTION_DISABLED;
+ DBUG_RETURN(EXIT_OPTION_DISABLED);
}
error= 0;
value= optp->var_type & GET_ASK_ADDR ?
(*getopt_get_addr)(key_name, (uint) strlen(key_name), optp, &error) :
optp->value;
if (error)
- return error;
+ DBUG_RETURN(error);
if (optp->arg_type == NO_ARG)
{
@@ -380,7 +384,7 @@ int handle_options(int *argc, char ***argv,
my_getopt_error_reporter(ERROR_LEVEL,
"%s: option '--%s' cannot take an argument",
my_progname, optp->name);
- return EXIT_NO_ARGUMENT_ALLOWED;
+ DBUG_RETURN(EXIT_NO_ARGUMENT_ALLOWED);
}
if ((optp->var_type & GET_TYPE_MASK) == GET_BOOL)
{
@@ -407,7 +411,7 @@ int handle_options(int *argc, char ***argv,
if (get_one_option && get_one_option(optp->id, optp,
*((my_bool*) value) ?
enabled_my_option : disabled_my_option))
- return EXIT_ARGUMENT_INVALID;
+ DBUG_RETURN(EXIT_ARGUMENT_INVALID);
continue;
}
argument= optend;
@@ -424,7 +428,7 @@ int handle_options(int *argc, char ***argv,
my_getopt_error_reporter(ERROR_LEVEL,
"%s: option '--%s' requires an argument",
my_progname, optp->name);
- return EXIT_ARGUMENT_REQUIRED;
+ DBUG_RETURN(EXIT_ARGUMENT_REQUIRED);
}
argument= *pos;
(*argc)--;
@@ -449,14 +453,14 @@ int handle_options(int *argc, char ***argv,
fprintf(stderr,
"%s: ERROR: Option '-%c' used, but is disabled\n",
my_progname, optp->id);
- return EXIT_OPTION_DISABLED;
+ DBUG_RETURN(EXIT_OPTION_DISABLED);
}
if ((optp->var_type & GET_TYPE_MASK) == GET_BOOL &&
optp->arg_type == NO_ARG)
{
*((my_bool*) optp->value)= (my_bool) 1;
if (get_one_option && get_one_option(optp->id, optp, argument))
- return EXIT_UNSPECIFIED_ERROR;
+ DBUG_RETURN(EXIT_UNSPECIFIED_ERROR);
continue;
}
else if (optp->arg_type == REQUIRED_ARG ||
@@ -476,7 +480,7 @@ int handle_options(int *argc, char ***argv,
if (optp->var_type == GET_BOOL)
*((my_bool*) optp->value)= (my_bool) 1;
if (get_one_option && get_one_option(optp->id, optp, argument))
- return EXIT_UNSPECIFIED_ERROR;
+ DBUG_RETURN(EXIT_UNSPECIFIED_ERROR);
continue;
}
/* Check if there are more arguments after this one */
@@ -486,7 +490,7 @@ int handle_options(int *argc, char ***argv,
my_getopt_error_reporter(ERROR_LEVEL,
"%s: option '-%c' requires an argument",
my_progname, optp->id);
- return EXIT_ARGUMENT_REQUIRED;
+ DBUG_RETURN(EXIT_ARGUMENT_REQUIRED);
}
argument= *++pos;
(*argc)--;
@@ -495,9 +499,9 @@ int handle_options(int *argc, char ***argv,
}
if ((error= setval(optp, optp->value, argument,
set_maximum_value)))
- return error;
+ DBUG_RETURN(error);
if (get_one_option && get_one_option(optp->id, optp, argument))
- return EXIT_UNSPECIFIED_ERROR;
+ DBUG_RETURN(EXIT_UNSPECIFIED_ERROR);
break;
}
}
@@ -531,7 +535,7 @@ int handle_options(int *argc, char ***argv,
my_getopt_error_reporter(ERROR_LEVEL,
"%s: unknown option '-%c'",
my_progname, *optend);
- return EXIT_UNKNOWN_OPTION;
+ DBUG_RETURN(EXIT_UNKNOWN_OPTION);
}
}
}
@@ -541,9 +545,9 @@ int handle_options(int *argc, char ***argv,
}
if (((error= setval(optp, value, argument, set_maximum_value))) &&
!option_is_loose)
- return error;
+ DBUG_RETURN(error);
if (get_one_option && get_one_option(optp->id, optp, argument))
- return EXIT_UNSPECIFIED_ERROR;
+ DBUG_RETURN(EXIT_UNSPECIFIED_ERROR);
(*argc)--; /* option handled (long), decrease argument count */
}
@@ -557,7 +561,7 @@ int handle_options(int *argc, char ***argv,
to the program, yet to be (possibly) handled.
*/
(*argv)[argvpos]= 0;
- return 0;
+ DBUG_RETURN(0);
}
@@ -578,6 +582,7 @@ int handle_options(int *argc, char ***argv,
static char *check_struct_option(char *cur_arg, char *key_name)
{
char *ptr, *end;
+ DBUG_ENTER("check_struct_option");
ptr= strcend(cur_arg + 1, '.'); /* Skip the first character */
end= strcend(cur_arg, '=');
@@ -594,12 +599,12 @@ static char *check_struct_option(char *cur_arg, char *key_name)
uint len= (uint) (ptr - cur_arg);
set_if_smaller(len, FN_REFLEN-1);
strmake(key_name, cur_arg, len);
- return ++ptr;
+ DBUG_RETURN(++ptr);
}
else
{
key_name[0]= 0;
- return cur_arg;
+ DBUG_RETURN(cur_arg);
}
}
@@ -615,18 +620,20 @@ static char *check_struct_option(char *cur_arg, char *key_name)
static my_bool get_bool_argument(const struct my_option *opts,
const char *argument)
{
+ DBUG_ENTER("get_bool_argument");
+
if (!my_strcasecmp(&my_charset_latin1, argument, "true") ||
!my_strcasecmp(&my_charset_latin1, argument, "on") ||
!my_strcasecmp(&my_charset_latin1, argument, "1"))
- return 1;
+ DBUG_RETURN(1);
else if (!my_strcasecmp(&my_charset_latin1, argument, "false") ||
!my_strcasecmp(&my_charset_latin1, argument, "off") ||
!my_strcasecmp(&my_charset_latin1, argument, "0"))
- return 0;
+ DBUG_RETURN(0);
my_getopt_error_reporter(WARNING_LEVEL,
"option '%s': boolean value '%s' wasn't recognized. Set to OFF.",
opts->name, argument);
- return 0;
+ DBUG_RETURN(0);
}
/*
@@ -640,6 +647,7 @@ static int setval(const struct my_option *opts, void *value, char *argument,
my_bool set_maximum_value)
{
int err= 0, res= 0;
+ DBUG_ENTER("setval");
if (!argument)
argument= enabled_my_option;
@@ -651,7 +659,7 @@ static int setval(const struct my_option *opts, void *value, char *argument,
my_getopt_error_reporter(ERROR_LEVEL,
"%s: Maximum value of '%s' cannot be set",
my_progname, opts->name);
- return EXIT_NO_PTR_TO_VARIABLE;
+ DBUG_RETURN(EXIT_NO_PTR_TO_VARIABLE);
}
switch ((opts->var_type & GET_TYPE_MASK)) {
@@ -758,13 +766,13 @@ static int setval(const struct my_option *opts, void *value, char *argument,
goto ret;
};
}
- return 0;
+ DBUG_RETURN(0);
ret:
my_getopt_error_reporter(ERROR_LEVEL,
"%s: Error while setting value '%s' to '%s'",
my_progname, argument, opts->name);
- return res;
+ DBUG_RETURN(res);
}
@@ -796,6 +804,7 @@ static int findopt(char *optpat, uint length,
{
uint count;
const struct my_option *opt= *opt_res;
+ DBUG_ENTER("findopt");
for (count= 0; opt->name; opt++)
{
@@ -803,7 +812,7 @@ static int findopt(char *optpat, uint length,
{
(*opt_res)= opt;
if (!opt->name[length]) /* Exact match */
- return 1;
+ DBUG_RETURN(1);
if (!count)
{
/* We only need to know one prev */
@@ -820,7 +829,7 @@ static int findopt(char *optpat, uint length,
}
}
}
- return count;
+ DBUG_RETURN(count);
}
@@ -835,12 +844,14 @@ my_bool getopt_compare_strings(register const char *s, register const char *t,
uint length)
{
char const *end= s + length;
+ DBUG_ENTER("getopt_compare_strings");
+
for (;s != end ; s++, t++)
{
if ((*s != '-' ? *s : '_') != (*t != '-' ? *t : '_'))
- return 1;
+ DBUG_RETURN(1);
}
- return 0;
+ DBUG_RETURN(0);
}
/*
@@ -854,6 +865,8 @@ static longlong eval_num_suffix(char *argument, int *error, char *option_name)
{
char *endchar;
longlong num;
+ DBUG_ENTER("eval_num_suffix");
+
*error= 0;
errno= 0;
@@ -863,7 +876,7 @@ static longlong eval_num_suffix(char *argument, int *error, char *option_name)
my_getopt_error_reporter(ERROR_LEVEL,
"Incorrect integer value: '%s'", argument);
*error= 1;
- return 0;
+ DBUG_RETURN(0);
}
if (*endchar == 'k' || *endchar == 'K')
num*= 1024L;
@@ -877,9 +890,9 @@ static longlong eval_num_suffix(char *argument, int *error, char *option_name)
"Unknown suffix '%c' used for variable '%s' (value '%s')\n",
*endchar, option_name, argument);
*error= 1;
- return 0;
+ DBUG_RETURN(0);
}
- return num;
+ DBUG_RETURN(num);
}
/*
@@ -913,6 +926,7 @@ longlong getopt_ll_limit_value(longlong num, const struct my_option *optp,
my_bool adjusted= FALSE;
char buf1[255], buf2[255];
ulonglong block_size= (optp->block_size ? (ulonglong) optp->block_size : 1L);
+ DBUG_ENTER("getopt_ll_limit_value");
if (num > 0 && ((ulonglong) num > (ulonglong) optp->max_value) &&
optp->max_value) /* if max value is not set -> no upper limit */
@@ -959,7 +973,7 @@ longlong getopt_ll_limit_value(longlong num, const struct my_option *optp,
my_getopt_error_reporter(WARNING_LEVEL,
"option '%s': signed value %s adjusted to %s",
optp->name, llstr(old, buf1), llstr(num, buf2));
- return num;
+ DBUG_RETURN(num);
}
/*
@@ -982,6 +996,7 @@ ulonglong getopt_ull_limit_value(ulonglong num, const struct my_option *optp,
my_bool adjusted= FALSE;
ulonglong old= num;
char buf1[255], buf2[255];
+ DBUG_ENTER("getopt_ull_limit_value");
if ((ulonglong) num > (ulonglong) optp->max_value &&
optp->max_value) /* if max value is not set -> no upper limit */
@@ -1032,7 +1047,7 @@ ulonglong getopt_ull_limit_value(ulonglong num, const struct my_option *optp,
"option '%s': unsigned value %s adjusted to %s",
optp->name, ullstr(old, buf1), ullstr(num, buf2));
- return num;
+ DBUG_RETURN(num);
}
double getopt_double_limit_value(double num, const struct my_option *optp,
@@ -1040,6 +1055,8 @@ double getopt_double_limit_value(double num, const struct my_option *optp,
{
my_bool adjusted= FALSE;
double old= num;
+ DBUG_ENTER("getopt_double_limit_value");
+
if (optp->max_value && num > (double) optp->max_value)
{
num= (double) optp->max_value;
@@ -1056,7 +1073,7 @@ double getopt_double_limit_value(double num, const struct my_option *optp,
my_getopt_error_reporter(WARNING_LEVEL,
"option '%s': value %g adjusted to %g",
optp->name, old, num);
- return num;
+ DBUG_RETURN(num);
}
/*
@@ -1190,7 +1207,9 @@ static void fini_one_value(const struct my_option *option, void *variable,
void my_cleanup_options(const struct my_option *options)
{
+ DBUG_ENTER("my_cleanup_options");
init_variables(options, fini_one_value);
+ DBUG_VOID_RETURN;
}
@@ -1234,6 +1253,7 @@ static void init_variables(const struct my_option *options,
static uint print_name(const struct my_option *optp)
{
const char *s= optp->name;
+
for (;*s;s++)
putchar(*s == '_' ? '-' : *s);
return s - optp->name;
@@ -1250,6 +1270,7 @@ void my_print_help(const struct my_option *options)
uint col, name_space= 22, comment_space= 57;
const char *line_end;
const struct my_option *optp;
+ DBUG_ENTER("my_print_help");
for (optp= options; optp->name; optp++)
{
@@ -1324,6 +1345,7 @@ void my_print_help(const struct my_option *options)
}
}
}
+ DBUG_VOID_RETURN;
}
@@ -1339,6 +1361,7 @@ void my_print_variables(const struct my_option *options)
ulonglong llvalue;
char buff[255];
const struct my_option *optp;
+ DBUG_ENTER("my_print_variables");
for (optp= options; optp->name; optp++)
{
@@ -1425,4 +1448,5 @@ void my_print_variables(const struct my_option *options)
}
}
}
+ DBUG_VOID_RETURN;
}
diff --git a/mysys/my_malloc.c b/mysys/my_malloc.c
index c1bfb89c1fd..2555c052fc3 100644
--- a/mysys/my_malloc.c
+++ b/mysys/my_malloc.c
@@ -115,9 +115,11 @@ void my_free(void *ptr)
void *my_memdup(const void *from, size_t length, myf my_flags)
{
void *ptr;
+ DBUG_ENTER("my_memdup");
+
if ((ptr= my_malloc(length,my_flags)) != 0)
memcpy(ptr, from, length);
- return ptr;
+ DBUG_RETURN(ptr);
}
@@ -125,20 +127,24 @@ char *my_strdup(const char *from, myf my_flags)
{
char *ptr;
size_t length= strlen(from)+1;
+ DBUG_ENTER("my_strdup");
+
if ((ptr= (char*) my_malloc(length, my_flags)))
memcpy(ptr, from, length);
- return ptr;
+ DBUG_RETURN(ptr);
}
char *my_strndup(const char *from, size_t length, myf my_flags)
{
char *ptr;
+ DBUG_ENTER("my_strndup");
+
if ((ptr= (char*) my_malloc(length+1, my_flags)))
{
memcpy(ptr, from, length);
ptr[length]= 0;
}
- return ptr;
+ DBUG_RETURN(ptr);
}
diff --git a/mysys/my_open.c b/mysys/my_open.c
index 2aef97b3e34..db627c72f91 100644
--- a/mysys/my_open.c
+++ b/mysys/my_open.c
@@ -49,8 +49,9 @@ File my_open(const char *FileName, int Flags, myf MyFlags)
fd = open((char *) FileName, Flags);
#endif
- DBUG_RETURN(my_register_filename(fd, FileName, FILE_BY_OPEN,
- EE_FILENOTFOUND, MyFlags));
+ fd= my_register_filename(fd, FileName, FILE_BY_OPEN,
+ EE_FILENOTFOUND, MyFlags);
+ DBUG_RETURN(fd);
} /* my_open */
diff --git a/mysys/string.c b/mysys/string.c
index b1eded0664c..0aa175e8991 100644
--- a/mysys/string.c
+++ b/mysys/string.c
@@ -98,20 +98,21 @@ my_bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
size_t length)
{
char *new_ptr;
+ DBUG_ENTER("dynstr_append_mem");
if (str->length+length >= str->max_length)
{
size_t new_length=(str->length+length+str->alloc_increment)/
str->alloc_increment;
new_length*=str->alloc_increment;
if (!(new_ptr=(char*) my_realloc(str->str,new_length,MYF(MY_WME))))
- return TRUE;
+ DBUG_RETURN(TRUE);
str->str=new_ptr;
str->max_length=new_length;
}
memcpy(str->str + str->length,append,length);
str->length+=length;
str->str[str->length]=0; /* Safety for C programs */
- return FALSE;
+ DBUG_RETURN(FALSE);
}
diff --git a/sql-common/client.c b/sql-common/client.c
index adf416b8362..bbe6b33b759 100644
--- a/sql-common/client.c
+++ b/sql-common/client.c
@@ -4050,7 +4050,7 @@ mysql_fetch_lengths(MYSQL_RES *res)
int STDCALL
mysql_options(MYSQL *mysql,enum mysql_option option, const void *arg)
{
- DBUG_ENTER("mysql_option");
+ DBUG_ENTER("mysql_options");
DBUG_PRINT("enter",("option: %d",(int) option));
switch (option) {
case MYSQL_OPT_CONNECT_TIMEOUT:
diff --git a/sql-common/client_plugin.c b/sql-common/client_plugin.c
index 53d283d98ce..9bae7169256 100644
--- a/sql-common/client_plugin.c
+++ b/sql-common/client_plugin.c
@@ -68,13 +68,15 @@ static pthread_mutex_t LOCK_load_client_plugin;
static int is_not_initialized(MYSQL *mysql, const char *name)
{
+ DBUG_ENTER("is_not_initialized");
+
if (initialized)
- return 0;
+ DBUG_RETURN(0);
set_mysql_extended_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD,
unknown_sqlstate, ER(CR_AUTH_PLUGIN_CANNOT_LOAD),
name, "not initialized");
- return 1;
+ DBUG_RETURN(1);
}
/**
@@ -91,18 +93,19 @@ static struct st_mysql_client_plugin *
find_plugin(const char *name, int type)
{
struct st_client_plugin_int *p;
+ DBUG_ENTER("find_plugin");
DBUG_ASSERT(initialized);
DBUG_ASSERT(type >= 0 && type < MYSQL_CLIENT_MAX_PLUGINS);
if (type < 0 || type >= MYSQL_CLIENT_MAX_PLUGINS)
- return 0;
+ DBUG_RETURN(0);
for (p= plugin_list[type]; p; p= p->next)
{
if (strcmp(p->plugin->name, name) == 0)
- return p->plugin;
+ DBUG_RETURN(p->plugin);
}
- return NULL;
+ DBUG_RETURN(NULL);
}
/**
@@ -124,6 +127,7 @@ add_plugin(MYSQL *mysql, struct st_mysql_client_plugin *plugin, void *dlhandle,
const char *errmsg;
struct st_client_plugin_int plugin_int, *p;
char errbuf[1024];
+ DBUG_ENTER("add_plugin");
DBUG_ASSERT(initialized);
@@ -166,7 +170,7 @@ add_plugin(MYSQL *mysql, struct st_mysql_client_plugin *plugin, void *dlhandle,
plugin_list[plugin->type]= p;
net_clear_error(&mysql->net);
- return plugin;
+ DBUG_RETURN(plugin);
err2:
if (plugin->deinit)
@@ -177,7 +181,7 @@ err1:
errmsg);
if (dlhandle)
dlclose(dlhandle);
- return NULL;
+ DBUG_RETURN(NULL);
}
/**
@@ -198,10 +202,11 @@ err1:
static void load_env_plugins(MYSQL *mysql)
{
char *plugs, *free_env, *s= getenv("LIBMYSQL_PLUGINS");
+ DBUG_ENTER("load_env_plugins");
/* no plugins to load */
if (!s)
- return;
+ DBUG_VOID_RETURN;
free_env= plugs= my_strdup(s, MYF(MY_WME));
@@ -213,6 +218,7 @@ static void load_env_plugins(MYSQL *mysql)
} while (s);
my_free(free_env);
+ DBUG_VOID_RETURN;
}
/********** extern functions to be used by libmysql *********************/
@@ -229,9 +235,10 @@ int mysql_client_plugin_init()
{
MYSQL mysql;
struct st_mysql_client_plugin **builtin;
+ DBUG_ENTER("mysql_client_plugin_init");
if (initialized)
- return 0;
+ DBUG_RETURN(0);
bzero(&mysql, sizeof(mysql)); /* dummy mysql for set_mysql_extended_error */
@@ -251,7 +258,7 @@ int mysql_client_plugin_init()
load_env_plugins(&mysql);
- return 0;
+ DBUG_RETURN(0);
}
/**
@@ -263,9 +270,10 @@ void mysql_client_plugin_deinit()
{
int i;
struct st_client_plugin_int *p;
+ DBUG_ENTER("mysql_client_plugin_deinit");
if (!initialized)
- return;
+ DBUG_VOID_RETURN;
for (i=0; i < MYSQL_CLIENT_MAX_PLUGINS; i++)
for (p= plugin_list[i]; p; p= p->next)
@@ -280,6 +288,7 @@ void mysql_client_plugin_deinit()
initialized= 0;
free_root(&mem_root, MYF(0));
pthread_mutex_destroy(&LOCK_load_client_plugin);
+ DBUG_VOID_RETURN;
}
/************* public facing functions, for client consumption *********/
@@ -289,8 +298,10 @@ struct st_mysql_client_plugin *
mysql_client_register_plugin(MYSQL *mysql,
struct st_mysql_client_plugin *plugin)
{
+ DBUG_ENTER("mysql_client_register_plugin");
+
if (is_not_initialized(mysql, plugin->name))
- return NULL;
+ DBUG_RETURN(NULL);
pthread_mutex_lock(&LOCK_load_client_plugin);
@@ -306,7 +317,7 @@ mysql_client_register_plugin(MYSQL *mysql,
plugin= add_plugin(mysql, plugin, 0, 0, 0);
pthread_mutex_unlock(&LOCK_load_client_plugin);
- return plugin;
+ DBUG_RETURN(plugin);
}
/* see <mysql/client_plugin.h> for a full description */
@@ -318,8 +329,8 @@ mysql_load_plugin_v(MYSQL *mysql, const char *name, int type,
char dlpath[FN_REFLEN+1];
void *sym, *dlhandle;
struct st_mysql_client_plugin *plugin;
+ DBUG_ENTER("mysql_load_plugin_v");
- DBUG_ENTER ("mysql_load_plugin_v");
DBUG_PRINT ("entry", ("name=%s type=%d int argc=%d", name, type, argc));
if (is_not_initialized(mysql, name))
{
@@ -399,10 +410,12 @@ mysql_load_plugin(MYSQL *mysql, const char *name, int type, int argc, ...)
{
struct st_mysql_client_plugin *p;
va_list args;
+ DBUG_ENTER("mysql_load_plugin");
+
va_start(args, argc);
p= mysql_load_plugin_v(mysql, name, type, argc, args);
va_end(args);
- return p;
+ DBUG_RETURN(p);
}
/* see <mysql/client_plugin.h> for a full description */
@@ -410,8 +423,8 @@ struct st_mysql_client_plugin *
mysql_client_find_plugin(MYSQL *mysql, const char *name, int type)
{
struct st_mysql_client_plugin *p;
+ DBUG_ENTER("mysql_client_find_plugin");
- DBUG_ENTER ("mysql_client_find_plugin");
DBUG_PRINT ("entry", ("name=%s, type=%d", name, type));
if (is_not_initialized(mysql, name))
DBUG_RETURN (NULL);
diff --git a/sql/handler.h b/sql/handler.h
index 979d66cdb1f..c64859bafc3 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -1715,13 +1715,17 @@ public:
int ha_repair(THD* thd, HA_CHECK_OPT* check_opt);
void ha_start_bulk_insert(ha_rows rows)
{
+ DBUG_ENTER("handler::ha_start_bulk_insert");
estimation_rows_to_insert= rows;
start_bulk_insert(rows);
+ DBUG_VOID_RETURN;
}
int ha_end_bulk_insert()
{
+ DBUG_ENTER("handler::ha_end_bulk_insert");
estimation_rows_to_insert= 0;
- return end_bulk_insert();
+ int ret= end_bulk_insert();
+ DBUG_RETURN(ret);
}
int ha_bulk_update_row(const uchar *old_data, uchar *new_data,
uint *dup_key_found);
diff --git a/sql/log.cc b/sql/log.cc
index 829cd7c748a..e66ca32d560 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -3827,8 +3827,7 @@ int MYSQL_BIN_LOG::close_purge_index_file()
bool MYSQL_BIN_LOG::is_inited_purge_index_file()
{
- DBUG_ENTER("MYSQL_BIN_LOG::is_inited_purge_index_file");
- DBUG_RETURN (my_b_inited(&purge_index_file));
+ return my_b_inited(&purge_index_file);
}
int MYSQL_BIN_LOG::sync_purge_index_file()
@@ -3864,13 +3863,12 @@ int MYSQL_BIN_LOG::register_create_index_entry(const char *entry)
int MYSQL_BIN_LOG::purge_index_entry(THD *thd, ulonglong *decrease_log_space,
bool need_mutex)
{
+ DBUG_ENTER("MYSQL_BIN_LOG:purge_index_entry");
MY_STAT s;
int error= 0;
LOG_INFO log_info;
LOG_INFO check_log_info;
- DBUG_ENTER("MYSQL_BIN_LOG:purge_index_entry");
-
DBUG_ASSERT(my_b_inited(&purge_index_file));
if ((error=reinit_io_cache(&purge_index_file, READ_CACHE, 0, 0, 0)))
diff --git a/sql/log.h b/sql/log.h
index 402c90034c7..6da45c5f44c 100644
--- a/sql/log.h
+++ b/sql/log.h
@@ -158,14 +158,20 @@ typedef struct st_log_info
my_off_t pos;
bool fatal; // if the purge happens to give us a negative offset
mysql_mutex_t lock;
- st_log_info()
- : index_file_offset(0), index_file_start_offset(0),
+ st_log_info() : index_file_offset(0), index_file_start_offset(0),
pos(0), fatal(0)
- {
- log_file_name[0] = '\0';
- mysql_mutex_init(key_LOG_INFO_lock, &lock, MY_MUTEX_INIT_FAST);
- }
- ~st_log_info() { mysql_mutex_destroy(&lock);}
+ {
+ DBUG_ENTER("LOG_INFO");
+ log_file_name[0] = '\0';
+ mysql_mutex_init(key_LOG_INFO_lock, &lock, MY_MUTEX_INIT_FAST);
+ DBUG_VOID_RETURN;
+ }
+ ~st_log_info()
+ {
+ DBUG_ENTER("~LOG_INFO");
+ mysql_mutex_destroy(&lock);
+ DBUG_VOID_RETURN;
+ }
} LOG_INFO;
/*
diff --git a/sql/rpl_tblmap.cc b/sql/rpl_tblmap.cc
index 5a178ffde83..79c8dbf7ec5 100644
--- a/sql/rpl_tblmap.cc
+++ b/sql/rpl_tblmap.cc
@@ -34,6 +34,7 @@
table_mapping::table_mapping()
: m_free(0)
{
+ DBUG_ENTER("table_mapping::table_mapping");
/*
No "free_element" function for entries passed here, as the entries are
allocated in a MEM_ROOT (freed as a whole in the destructor), they cannot
@@ -46,6 +47,7 @@ table_mapping::table_mapping()
0,0,0);
/* We don't preallocate any block, this is consistent with m_free=0 above */
init_alloc_root(&m_mem_root, TABLE_ID_HASH_SIZE*sizeof(entry), 0);
+ DBUG_VOID_RETURN;
}
table_mapping::~table_mapping()
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 395ab889a14..3a4c98410e1 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -1723,6 +1723,7 @@ void THD::reset_globals()
void THD::cleanup_after_query()
{
+ DBUG_ENTER("THD::cleanup_after_query");
/*
Reset rand_used so that detection of calls to rand() will save random
seeds if needed by the slave.
@@ -1756,6 +1757,7 @@ void THD::cleanup_after_query()
/* reset table map for multi-table update */
table_map_for_update= 0;
m_binlog_invoker= FALSE;
+ DBUG_VOID_RETURN;
}
@@ -3035,6 +3037,7 @@ void Statement::restore_backup_statement(Statement *stmt, Statement *backup)
void THD::end_statement()
{
+ DBUG_ENTER("THD::end_statement");
/* Cleanup SQL processing state to reuse this statement in next query. */
lex_end(lex);
delete lex->result;
@@ -3045,6 +3048,7 @@ void THD::end_statement()
Don't free mem_root, as mem_root is freed in the end of dispatch_command
(once for any command).
*/
+ DBUG_VOID_RETURN;
}
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
index d9327e6a7c0..bd08e6c4f63 100644
--- a/sql/sql_lex.cc
+++ b/sql/sql_lex.cc
@@ -2811,6 +2811,7 @@ void st_select_lex_unit::set_limit(st_select_lex *sl)
void LEX::set_trg_event_type_for_tables()
{
uint8 new_trg_event_map= 0;
+ DBUG_ENTER("LEX::set_trg_event_type_for_tables");
/*
Some auxiliary operations
@@ -2930,6 +2931,7 @@ void LEX::set_trg_event_type_for_tables()
tables->trg_event_map= new_trg_event_map;
tables= tables->next_local;
}
+ DBUG_VOID_RETURN;
}
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 400cc2683cd..73f96fc3fc5 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -7342,6 +7342,7 @@ bool parse_sql(THD *thd,
Object_creation_ctx *creation_ctx)
{
bool ret_value;
+ DBUG_ENTER("parse_sql");
DBUG_ASSERT(thd->m_parser_state == NULL);
DBUG_ASSERT(thd->lex->m_stmt == NULL);
@@ -7389,7 +7390,7 @@ bool parse_sql(THD *thd,
ret_value= mysql_parse_status || thd->is_fatal_error;
MYSQL_QUERY_PARSE_DONE(ret_value);
- return ret_value;
+ DBUG_RETURN(ret_value);
}
/**
diff --git a/sql/sql_plugin.cc b/sql/sql_plugin.cc
index 16214c5edc8..eb7fa3222e5 100644
--- a/sql/sql_plugin.cc
+++ b/sql/sql_plugin.cc
@@ -1125,7 +1125,7 @@ static void plugin_deinitialize(struct st_plugin_int *plugin, bool ref_check)
static void plugin_del(struct st_plugin_int *plugin)
{
- DBUG_ENTER("plugin_del(plugin)");
+ DBUG_ENTER("plugin_del");
mysql_mutex_assert_owner(&LOCK_plugin);
/* Free allocated strings before deleting the plugin. */
mysql_rwlock_wrlock(&LOCK_system_variables_hash);
@@ -2703,11 +2703,12 @@ static void restore_pluginvar_names(sys_var *first)
*/
static uchar *intern_sys_var_ptr(THD* thd, int offset, bool global_lock)
{
+ DBUG_ENTER("intern_sys_var_ptr");
DBUG_ASSERT(offset >= 0);
DBUG_ASSERT((uint)offset <= global_system_variables.dynamic_variables_head);
if (!thd)
- return (uchar*) global_system_variables.dynamic_variables_ptr + offset;
+ DBUG_RETURN((uchar*) global_system_variables.dynamic_variables_ptr + offset);
/*
dynamic_variables_head points to the largest valid offset
@@ -2779,7 +2780,7 @@ static uchar *intern_sys_var_ptr(THD* thd, int offset, bool global_lock)
mysql_rwlock_unlock(&LOCK_system_variables_hash);
}
- return (uchar*)thd->variables.dynamic_variables_ptr + offset;
+ DBUG_RETURN((uchar*)thd->variables.dynamic_variables_ptr + offset);
}
diff --git a/storage/myisam/ha_myisam.cc b/storage/myisam/ha_myisam.cc
index bc43d9631ab..dfb06f800c2 100644
--- a/storage/myisam/ha_myisam.cc
+++ b/storage/myisam/ha_myisam.cc
@@ -1339,6 +1339,7 @@ int ha_myisam::disable_indexes(uint mode)
int ha_myisam::enable_indexes(uint mode)
{
int error;
+ DBUG_ENTER("ha_myisam::enable_indexes");
DBUG_EXECUTE_IF("wait_in_enable_indexes",
debug_wait_for_kill("wait_in_enable_indexes"); );
@@ -1346,7 +1347,7 @@ int ha_myisam::enable_indexes(uint mode)
if (mi_is_all_keys_active(file->s->state.key_map, file->s->base.keys))
{
/* All indexes are enabled already. */
- return 0;
+ DBUG_RETURN(0);
}
if (mode == HA_KEY_SWITCH_ALL)
@@ -1365,7 +1366,7 @@ int ha_myisam::enable_indexes(uint mode)
const char *save_proc_info=thd->proc_info;
if (!&param)
- return HA_ADMIN_INTERNAL_ERROR;
+ DBUG_RETURN(HA_ADMIN_INTERNAL_ERROR);
thd_proc_info(thd, "Creating index");
myisamchk_init(&param);
@@ -1407,7 +1408,7 @@ int ha_myisam::enable_indexes(uint mode)
/* mode not implemented */
error= HA_ERR_WRONG_COMMAND;
}
- return error;
+ DBUG_RETURN(error);
}
@@ -1500,6 +1501,7 @@ void ha_myisam::start_bulk_insert(ha_rows rows)
int ha_myisam::end_bulk_insert()
{
+ DBUG_ENTER("ha_myisam::end_bulk_insert");
mi_end_bulk_insert(file);
int err=mi_extra(file, HA_EXTRA_NO_CACHE, 0);
if (!err && !file->s->deleting)
@@ -1522,7 +1524,7 @@ int ha_myisam::end_bulk_insert()
}
}
}
- return err;
+ DBUG_RETURN(err);
}
diff --git a/storage/perfschema/pfs_instr.cc b/storage/perfschema/pfs_instr.cc
index a09920737c8..ed2df685a2d 100644
--- a/storage/perfschema/pfs_instr.cc
+++ b/storage/perfschema/pfs_instr.cc
@@ -148,6 +148,7 @@ int init_instruments(const PFS_global_param *param)
{
uint thread_history_sizing;
uint index;
+ DBUG_ENTER("init_instruments");
mutex_max= param->m_mutex_sizing;
mutex_lost= 0;
@@ -194,49 +195,49 @@ int init_instruments(const PFS_global_param *param)
{
mutex_array= PFS_MALLOC_ARRAY(mutex_max, PFS_mutex, MYF(MY_ZEROFILL));
if (unlikely(mutex_array == NULL))
- return 1;
+ DBUG_RETURN(1);
}
if (rwlock_max > 0)
{
rwlock_array= PFS_MALLOC_ARRAY(rwlock_max, PFS_rwlock, MYF(MY_ZEROFILL));
if (unlikely(rwlock_array == NULL))
- return 1;
+ DBUG_RETURN(1);
}
if (cond_max > 0)
{
cond_array= PFS_MALLOC_ARRAY(cond_max, PFS_cond, MYF(MY_ZEROFILL));
if (unlikely(cond_array == NULL))
- return 1;
+ DBUG_RETURN(1);
}
if (file_max > 0)
{
file_array= PFS_MALLOC_ARRAY(file_max, PFS_file, MYF(MY_ZEROFILL));
if (unlikely(file_array == NULL))
- return 1;
+ DBUG_RETURN(1);
}
if (file_handle_max > 0)
{
file_handle_array= PFS_MALLOC_ARRAY(file_handle_max, PFS_file*, MYF(MY_ZEROFILL));
if (unlikely(file_handle_array == NULL))
- return 1;
+ DBUG_RETURN(1);
}
if (table_max > 0)
{
table_array= PFS_MALLOC_ARRAY(table_max, PFS_table, MYF(MY_ZEROFILL));
if (unlikely(table_array == NULL))
- return 1;
+ DBUG_RETURN(1);
}
if (thread_max > 0)
{
thread_array= PFS_MALLOC_ARRAY(thread_max, PFS_thread, MYF(MY_ZEROFILL));
if (unlikely(thread_array == NULL))
- return 1;
+ DBUG_RETURN(1);
}
if (thread_history_sizing > 0)
@@ -245,7 +246,7 @@ int init_instruments(const PFS_global_param *param)
PFS_MALLOC_ARRAY(thread_history_sizing, PFS_events_waits,
MYF(MY_ZEROFILL));
if (unlikely(thread_history_array == NULL))
- return 1;
+ DBUG_RETURN(1);
}
if (thread_instr_class_waits_sizing > 0)
@@ -254,7 +255,7 @@ int init_instruments(const PFS_global_param *param)
PFS_MALLOC_ARRAY(thread_instr_class_waits_sizing,
PFS_single_stat_chain, MYF(MY_ZEROFILL));
if (unlikely(thread_instr_class_waits_array == NULL))
- return 1;
+ DBUG_RETURN(1);
}
for (index= 0; index < thread_instr_class_waits_sizing; index++)
@@ -277,7 +278,7 @@ int init_instruments(const PFS_global_param *param)
&thread_instr_class_waits_array[index * instr_class_per_thread];
}
- return 0;
+ DBUG_RETURN(0);
}
/**
@@ -292,6 +293,7 @@ find_per_thread_mutex_class_wait_stat(PFS_thread *thread,
{
PFS_single_stat_chain *stat;
uint index;
+ DBUG_ENTER("find_per_thread_mutex_class_wait_stat");
DBUG_ASSERT(thread != NULL);
DBUG_ASSERT(klass != NULL);
@@ -299,7 +301,7 @@ find_per_thread_mutex_class_wait_stat(PFS_thread *thread,
DBUG_ASSERT(index < mutex_class_max);
stat= &(thread->m_instr_class_wait_stats[index]);
- return stat;
+ DBUG_RETURN(stat);
}
/**
@@ -314,6 +316,7 @@ find_per_thread_rwlock_class_wait_stat(PFS_thread *thread,
{
PFS_single_stat_chain *stat;
uint index;
+ DBUG_ENTER("find_per_thread_rwlock_class_wait_stat");
DBUG_ASSERT(thread != NULL);
DBUG_ASSERT(klass != NULL);
@@ -322,7 +325,7 @@ find_per_thread_rwlock_class_wait_stat(PFS_thread *thread,
stat= &(thread->m_instr_class_wait_stats
[per_thread_rwlock_class_start + index]);
- return stat;
+ DBUG_RETURN(stat);
}
/**
@@ -337,6 +340,7 @@ find_per_thread_cond_class_wait_stat(PFS_thread *thread,
{
PFS_single_stat_chain *stat;
uint index;
+ DBUG_ENTER("find_per_thread_cond_class_wait_stat");
DBUG_ASSERT(thread != NULL);
DBUG_ASSERT(klass != NULL);
@@ -345,7 +349,7 @@ find_per_thread_cond_class_wait_stat(PFS_thread *thread,
stat= &(thread->m_instr_class_wait_stats
[per_thread_cond_class_start + index]);
- return stat;
+ DBUG_RETURN(stat);
}
/**
@@ -360,6 +364,7 @@ find_per_thread_file_class_wait_stat(PFS_thread *thread,
{
PFS_single_stat_chain *stat;
uint index;
+ DBUG_ENTER("find_per_thread_file_class_wait_stat");
DBUG_ASSERT(thread != NULL);
DBUG_ASSERT(klass != NULL);
@@ -368,7 +373,7 @@ find_per_thread_file_class_wait_stat(PFS_thread *thread,
stat= &(thread->m_instr_class_wait_stats
[per_thread_file_class_start + index]);
- return stat;
+ DBUG_RETURN(stat);
}
/** Reset the wait statistics per thread. */
@@ -376,14 +381,18 @@ void reset_per_thread_wait_stat(void)
{
PFS_single_stat_chain *stat= thread_instr_class_waits_array;
PFS_single_stat_chain *stat_last= stat + thread_instr_class_waits_sizing;
+ DBUG_ENTER("reset_per_thread_wait_stat");
for ( ; stat < stat_last; stat++)
reset_single_stat_link(stat);
+ DBUG_VOID_RETURN;
}
/** Cleanup all the instruments buffers. */
void cleanup_instruments(void)
{
+ DBUG_ENTER("cleanup_instruments");
+
pfs_free(mutex_array);
mutex_array= NULL;
mutex_max= 0;
@@ -409,6 +418,7 @@ void cleanup_instruments(void)
thread_history_array= NULL;
pfs_free(thread_instr_class_waits_array);
thread_instr_class_waits_array= NULL;
+ DBUG_VOID_RETURN;
}
extern "C"
@@ -419,13 +429,15 @@ static uchar *filename_hash_get_key(const uchar *entry, size_t *length,
const PFS_file * const *typed_entry;
const PFS_file *file;
const void *result;
+ DBUG_ENTER("filename_hash_get_key");
+
typed_entry= reinterpret_cast<const PFS_file* const *> (entry);
DBUG_ASSERT(typed_entry != NULL);
file= *typed_entry;
DBUG_ASSERT(file != NULL);
*length= file->m_filename_length;
result= file->m_filename;
- return const_cast<uchar*> (reinterpret_cast<const uchar*> (result));
+ DBUG_RETURN(const_cast<uchar*> (reinterpret_cast<const uchar*> (result)));
}
}
@@ -435,34 +447,41 @@ static uchar *filename_hash_get_key(const uchar *entry, size_t *length,
*/
int init_file_hash(void)
{
+ DBUG_ENTER("init_file_hash");
+
if (! filename_hash_inited)
{
lf_hash_init(&filename_hash, sizeof(PFS_file*), LF_HASH_UNIQUE,
0, 0, filename_hash_get_key, &my_charset_bin);
filename_hash_inited= true;
}
- return 0;
+ DBUG_RETURN(0);
}
/** Cleanup the file name hash. */
void cleanup_file_hash(void)
{
+ DBUG_ENTER("cleanup_file_hash");
+
if (filename_hash_inited)
{
lf_hash_destroy(&filename_hash);
filename_hash_inited= false;
}
+ DBUG_VOID_RETURN;
}
void PFS_scan::init(uint random, uint max_size)
{
+ DBUG_ENTER("PFS_scan::init");
+
m_pass= 0;
if (max_size == 0)
{
/* Degenerated case, no buffer */
m_pass_max= 0;
- return;
+ DBUG_VOID_RETURN;
}
DBUG_ASSERT(random < max_size);
@@ -521,6 +540,7 @@ void PFS_scan::init(uint random, uint max_size)
/* The combined length of all passes should not exceed PFS_MAX_ALLOC_RETRY. */
DBUG_ASSERT((m_last[0] - m_first[0]) +
(m_last[1] - m_first[1]) <= PFS_MAX_ALLOC_RETRY);
+ DBUG_VOID_RETURN;
}
/**
@@ -533,6 +553,7 @@ PFS_mutex* create_mutex(PFS_mutex_class *klass, const void *identity)
{
PFS_scan scan;
uint random= randomized_index(identity, mutex_max);
+ DBUG_ENTER("create_mutex");
for (scan.init(random, mutex_max);
scan.has_pass();
@@ -559,14 +580,14 @@ PFS_mutex* create_mutex(PFS_mutex_class *klass, const void *identity)
pfs->m_owner= NULL;
pfs->m_last_locked= 0;
pfs->m_lock.dirty_to_allocated();
- return pfs;
+ DBUG_RETURN(pfs);
}
}
}
}
mutex_lost++;
- return NULL;
+ DBUG_RETURN(NULL);
}
/**
@@ -575,8 +596,11 @@ PFS_mutex* create_mutex(PFS_mutex_class *klass, const void *identity)
*/
void destroy_mutex(PFS_mutex *pfs)
{
+ DBUG_ENTER("destroy_mutex");
+
DBUG_ASSERT(pfs != NULL);
pfs->m_lock.allocated_to_free();
+ DBUG_VOID_RETURN;
}
/**
@@ -589,6 +613,7 @@ PFS_rwlock* create_rwlock(PFS_rwlock_class *klass, const void *identity)
{
PFS_scan scan;
uint random= randomized_index(identity, rwlock_max);
+ DBUG_ENTER("create_rwlock");
for (scan.init(random, rwlock_max);
scan.has_pass();
@@ -621,14 +646,14 @@ PFS_rwlock* create_rwlock(PFS_rwlock_class *klass, const void *identity)
pfs->m_readers= 0;
pfs->m_last_written= 0;
pfs->m_last_read= 0;
- return pfs;
+ DBUG_RETURN(pfs);
}
}
}
}
rwlock_lost++;
- return NULL;
+ DBUG_RETURN(NULL);
}
/**
@@ -637,8 +662,11 @@ PFS_rwlock* create_rwlock(PFS_rwlock_class *klass, const void *identity)
*/
void destroy_rwlock(PFS_rwlock *pfs)
{
+ DBUG_ENTER("destroy_rwlock");
+
DBUG_ASSERT(pfs != NULL);
pfs->m_lock.allocated_to_free();
+ DBUG_VOID_RETURN;
}
/**
@@ -651,6 +679,7 @@ PFS_cond* create_cond(PFS_cond_class *klass, const void *identity)
{
PFS_scan scan;
uint random= randomized_index(identity, cond_max);
+ DBUG_ENTER("create_cond");
for (scan.init(random, cond_max);
scan.has_pass();
@@ -673,14 +702,14 @@ PFS_cond* create_cond(PFS_cond_class *klass, const void *identity)
pfs->m_wait_stat.m_parent= &klass->m_wait_stat;
reset_single_stat_link(&pfs->m_wait_stat);
pfs->m_lock.dirty_to_allocated();
- return pfs;
+ DBUG_RETURN(pfs);
}
}
}
}
cond_lost++;
- return NULL;
+ DBUG_RETURN(NULL);
}
/**
@@ -689,8 +718,11 @@ PFS_cond* create_cond(PFS_cond_class *klass, const void *identity)
*/
void destroy_cond(PFS_cond *pfs)
{
+ DBUG_ENTER("destroy_cond");
+
DBUG_ASSERT(pfs != NULL);
pfs->m_lock.allocated_to_free();
+ DBUG_VOID_RETURN;
}
/**
@@ -707,6 +739,7 @@ PFS_thread* create_thread(PFS_thread_class *klass, const void *identity,
{
PFS_scan scan;
uint random= randomized_index(identity, thread_max);
+ DBUG_ENTER("create_thread");
for (scan.init(random, thread_max);
scan.has_pass();
@@ -737,14 +770,14 @@ PFS_thread* create_thread(PFS_thread_class *klass, const void *identity,
pfs->m_filename_hash_pins= NULL;
pfs->m_table_share_hash_pins= NULL;
pfs->m_lock.dirty_to_allocated();
- return pfs;
+ DBUG_RETURN(pfs);
}
}
}
}
thread_lost++;
- return NULL;
+ DBUG_RETURN(NULL);
}
/**
@@ -766,6 +799,7 @@ const char *sanitize_file_name(const char *unsafe)
intptr ptr= (intptr) unsafe;
intptr first= (intptr) &file_array[0];
intptr last= (intptr) &file_array[file_max];
+ DBUG_ENTER("sanitize_file_name");
/* Check if unsafe points inside file_array[] */
if (likely((first <= ptr) && (ptr < last)))
@@ -775,10 +809,10 @@ const char *sanitize_file_name(const char *unsafe)
intptr valid_offset= my_offsetof(PFS_file, m_filename[0]);
if (likely(offset == valid_offset))
{
- return unsafe;
+ DBUG_RETURN(unsafe);
}
}
- return NULL;
+ DBUG_RETURN(NULL);
}
/**
@@ -787,6 +821,8 @@ const char *sanitize_file_name(const char *unsafe)
*/
void destroy_thread(PFS_thread *pfs)
{
+ DBUG_ENTER("destroy_thread");
+
DBUG_ASSERT(pfs != NULL);
if (pfs->m_filename_hash_pins)
{
@@ -799,6 +835,7 @@ void destroy_thread(PFS_thread *pfs)
pfs->m_table_share_hash_pins= NULL;
}
pfs->m_lock.allocated_to_free();
+ DBUG_VOID_RETURN;
}
/**
@@ -815,12 +852,13 @@ find_or_create_file(PFS_thread *thread, PFS_file_class *klass,
{
PFS_file *pfs;
PFS_scan scan;
+ DBUG_ENTER("find_or_create_file");
if (! filename_hash_inited)
{
/* File instrumentation can be turned off. */
file_lost++;
- return NULL;
+ DBUG_RETURN(NULL);
}
if (unlikely(thread->m_filename_hash_pins == NULL))
@@ -829,7 +867,7 @@ find_or_create_file(PFS_thread *thread, PFS_file_class *klass,
if (unlikely(thread->m_filename_hash_pins == NULL))
{
file_lost++;
- return NULL;
+ DBUG_RETURN(NULL);
}
}
@@ -898,7 +936,7 @@ find_or_create_file(PFS_thread *thread, PFS_file_class *klass,
if (my_realpath(buffer, dirbuffer, MYF(0)) != 0)
{
file_lost++;
- return NULL;
+ DBUG_RETURN(NULL);
}
/* Append the unresolved file name to the resolved path */
@@ -925,7 +963,7 @@ search:
pfs= *entry;
pfs->m_file_stat.m_open_count++;
lf_hash_search_unpin(thread->m_filename_hash_pins);
- return pfs;
+ DBUG_RETURN(pfs);
}
/* filename is not constant, just using it for noise on create */
@@ -959,7 +997,7 @@ search:
if (likely(res == 0))
{
pfs->m_lock.dirty_to_allocated();
- return pfs;
+ DBUG_RETURN(pfs);
}
pfs->m_lock.dirty_to_free();
@@ -971,21 +1009,21 @@ search:
{
/* Avoid infinite loops */
file_lost++;
- return NULL;
+ DBUG_RETURN(NULL);
}
goto search;
}
/* OOM in lf_hash_insert */
file_lost++;
- return NULL;
+ DBUG_RETURN(NULL);
}
}
}
}
file_lost++;
- return NULL;
+ DBUG_RETURN(NULL);
}
/**
@@ -994,8 +1032,11 @@ search:
*/
void release_file(PFS_file *pfs)
{
+ DBUG_ENTER("release_file");
+
DBUG_ASSERT(pfs != NULL);
pfs->m_file_stat.m_open_count--;
+ DBUG_VOID_RETURN;
}
/**
@@ -1005,12 +1046,15 @@ void release_file(PFS_file *pfs)
*/
void destroy_file(PFS_thread *thread, PFS_file *pfs)
{
+ DBUG_ENTER("destroy_file");
+
DBUG_ASSERT(thread != NULL);
DBUG_ASSERT(thread->m_filename_hash_pins != NULL);
DBUG_ASSERT(pfs != NULL);
lf_hash_delete(&filename_hash, thread->m_filename_hash_pins,
pfs->m_filename, pfs->m_filename_length);
pfs->m_lock.allocated_to_free();
+ DBUG_VOID_RETURN;
}
/**
@@ -1023,6 +1067,7 @@ PFS_table* create_table(PFS_table_share *share, const void *identity)
{
PFS_scan scan;
uint random= randomized_index(identity, table_max);
+ DBUG_ENTER("create_table");
for (scan.init(random, table_max);
scan.has_pass();
@@ -1043,14 +1088,14 @@ PFS_table* create_table(PFS_table_share *share, const void *identity)
pfs->m_wait_stat.m_parent= &share->m_wait_stat;
reset_single_stat_link(&pfs->m_wait_stat);
pfs->m_lock.dirty_to_allocated();
- return pfs;
+ DBUG_RETURN(pfs);
}
}
}
}
table_lost++;
- return NULL;
+ DBUG_RETURN(NULL);
}
/**
@@ -1059,53 +1104,67 @@ PFS_table* create_table(PFS_table_share *share, const void *identity)
*/
void destroy_table(PFS_table *pfs)
{
+ DBUG_ENTER("destroy_table");
+
DBUG_ASSERT(pfs != NULL);
pfs->m_lock.allocated_to_free();
+ DBUG_VOID_RETURN;
}
static void reset_mutex_waits_by_instance(void)
{
PFS_mutex *pfs= mutex_array;
PFS_mutex *pfs_last= mutex_array + mutex_max;
+ DBUG_ENTER("reset_mutex_waits_by_instance");
for ( ; pfs < pfs_last; pfs++)
reset_single_stat_link(&pfs->m_wait_stat);
+ DBUG_VOID_RETURN;
}
static void reset_rwlock_waits_by_instance(void)
{
PFS_rwlock *pfs= rwlock_array;
PFS_rwlock *pfs_last= rwlock_array + rwlock_max;
+ DBUG_ENTER("reset_rwlock_waits_by_instance");
for ( ; pfs < pfs_last; pfs++)
reset_single_stat_link(&pfs->m_wait_stat);
+ DBUG_VOID_RETURN;
}
static void reset_cond_waits_by_instance(void)
{
PFS_cond *pfs= cond_array;
PFS_cond *pfs_last= cond_array + cond_max;
+ DBUG_ENTER("reset_cond_waits_by_instance");
for ( ; pfs < pfs_last; pfs++)
reset_single_stat_link(&pfs->m_wait_stat);
+ DBUG_VOID_RETURN;
}
static void reset_file_waits_by_instance(void)
{
PFS_file *pfs= file_array;
PFS_file *pfs_last= file_array + file_max;
+ DBUG_ENTER("reset_file_waits_by_instance");
for ( ; pfs < pfs_last; pfs++)
reset_single_stat_link(&pfs->m_wait_stat);
+ DBUG_VOID_RETURN;
}
/** Reset the wait statistics per object instance. */
void reset_events_waits_by_instance(void)
{
+ DBUG_ENTER("reset_events_waits_by_instance");
+
reset_mutex_waits_by_instance();
reset_rwlock_waits_by_instance();
reset_cond_waits_by_instance();
reset_file_waits_by_instance();
+ DBUG_VOID_RETURN;
}
/** Reset the io statistics per file instance. */
@@ -1113,9 +1172,11 @@ void reset_file_instance_io(void)
{
PFS_file *pfs= file_array;
PFS_file *pfs_last= file_array + file_max;
+ DBUG_ENTER("reset_file_instance_io");
for ( ; pfs < pfs_last; pfs++)
reset_file_stat(&pfs->m_file_stat);
+ DBUG_VOID_RETURN;
}
/** @} */
View Lorry Controller Status