{

ulong activation_count; /* max(hit_limit, execute) */

ulong hit_limit; /* hits before kill query */

ulong execute; /* executes before self-clear */

ulong timeout; /* wait_for timeout */

String signal; /* signal to emit */

String wait_for; /* signal to wait for */

String sync_point; /* sync point name */

bool need_sort; /* if new action, array needs sort */

{

st_debug_sync_action *ds_action; /* array of actions */

uint ds_active; /* # active actions */

uint ds_allocated; /* # allocated actions */

ulonglong dsp_hits; /* statistics */

ulonglong dsp_executed; /* statistics */

ulonglong dsp_max_active; /* statistics */

/*

char ds_proc_info[80]; /* proc_info string */

{

String ds_signal; /* signal variable */

mysql_cond_t ds_cond; /* condition variable */

mysql_mutex_t ds_mutex; /* mutex variable */

ulonglong dsp_hits; /* statistics */

ulonglong dsp_executed; /* statistics */

ulonglong dsp_max_active; /* statistics */

size_t name_len)

{

if (unlikely(opt_debug_sync_timeout))

debug_sync(current_thd, sync_point_name, name_len);

{

const char* category= "sql";

int count;

if (PSI_server == NULL)

return;

count= array_elements(all_debug_sync_mutexes);

PSI_server->register_mutex(category, all_debug_sync_mutexes, count);

count= array_elements(all_debug_sync_conds);

PSI_server->register_cond(category, all_debug_sync_conds, count);

{

DBUG_ENTER("debug_sync_init");

#ifdef HAVE_PSI_INTERFACE

init_debug_sync_psi_keys();

#endif

if (opt_debug_sync_timeout)

{

int rc;

/* Initialize the global variables. */

debug_sync_global.ds_signal.length(0);

if ((rc= mysql_cond_init(key_debug_sync_globals_ds_cond,

&debug_sync_global.ds_cond, NULL)) ||

(rc= mysql_mutex_init(key_debug_sync_globals_ds_mutex,

&debug_sync_global.ds_mutex,

MY_MUTEX_INIT_FAST)))

DBUG_RETURN(rc); /* purecov: inspected */

/* Set the call back pointer in C files. */

debug_sync_C_callback_ptr= debug_sync_C_callback;

}

DBUG_RETURN(0);

{

DBUG_ENTER("debug_sync_end");

/* End the facility only if it had been initialized. */

if (debug_sync_C_callback_ptr)

{

/* Clear the call back pointer in C files. */

debug_sync_C_callback_ptr= NULL;

/* Destroy the global variables. */

debug_sync_global.ds_signal.free();

mysql_cond_destroy(&debug_sync_global.ds_cond);

mysql_mutex_destroy(&debug_sync_global.ds_mutex);

/* Print statistics. */

{

char llbuff[22];

sql_print_information("Debug sync points hit: %22s",

llstr(debug_sync_global.dsp_hits, llbuff));

sql_print_information("Debug sync points executed: %22s",

llstr(debug_sync_global.dsp_executed, llbuff));

sql_print_information("Debug sync points max active per thread: %22s",

llstr(debug_sync_global.dsp_max_active, llbuff));

}

}

DBUG_VOID_RETURN;

{

DBUG_ENTER("debug_sync_emergency_disable");

opt_debug_sync_timeout= 0;

DBUG_PRINT("debug_sync",

("Debug Sync Facility disabled due to lack of memory."));

sql_print_error("Debug Sync Facility disabled due to lack of memory.");

DBUG_VOID_RETURN;

{

DBUG_ENTER("debug_sync_init_thread");

DBUG_ASSERT(thd);

if (opt_debug_sync_timeout)

{

thd->debug_sync_control= (st_debug_sync_control*)

my_malloc(sizeof(st_debug_sync_control), MYF(MY_WME | MY_ZEROFILL));

if (!thd->debug_sync_control)

{

/*

debug_sync_emergency_disable(); /* purecov: tested */

}

}

DBUG_VOID_RETURN;

{

DBUG_ENTER("debug_sync_end_thread");

DBUG_ASSERT(thd);

if (thd->debug_sync_control)

{

st_debug_sync_control *ds_control= thd->debug_sync_control;

/*

DEBUG_SYNC(thd, "thread_end");

if (ds_control->ds_action)

{

st_debug_sync_action *action= ds_control->ds_action;

st_debug_sync_action *action_end= action + ds_control->ds_allocated;

for (; action < action_end; action++)

{

action->signal.free();

action->wait_for.free();

action->sync_point.free();

}

my_free(ds_control->ds_action);

}

/* Statistics. */

mysql_mutex_lock(&debug_sync_global.ds_mutex);

debug_sync_global.dsp_hits+= ds_control->dsp_hits;

debug_sync_global.dsp_executed+= ds_control->dsp_executed;

if (debug_sync_global.dsp_max_active < ds_control->dsp_max_active)

debug_sync_global.dsp_max_active= ds_control->dsp_max_active;

mysql_mutex_unlock(&debug_sync_global.ds_mutex);

my_free(ds_control);

thd->debug_sync_control= NULL;

}

DBUG_VOID_RETURN;

st_debug_sync_action *action)

{

char *wtxt= result;

char *wend= wtxt + size - 1; /* Allow emergency '\0'. */

DBUG_ASSERT(result);

DBUG_ASSERT(action);

/* If an execute count is present, signal or wait_for are needed too. */

DBUG_ASSERT(!action->execute ||

action->signal.length() || action->wait_for.length());

if (action->execute)

{

if (action->signal.length())

{

wtxt= debug_sync_bmove_len(wtxt, wend, STRING_WITH_LEN("SIGNAL "));

wtxt= debug_sync_bmove_len(wtxt, wend, action->signal.ptr(),

action->signal.length());

}

if (action->wait_for.length())

{

if ((wtxt == result) && (wtxt < wend))

*(wtxt++)= ' ';

wtxt= debug_sync_bmove_len(wtxt, wend, STRING_WITH_LEN(" WAIT_FOR "));

wtxt= debug_sync_bmove_len(wtxt, wend, action->wait_for.ptr(),

action->wait_for.length());

if (action->timeout != opt_debug_sync_timeout)

{

wtxt+= my_snprintf(wtxt, wend - wtxt, " TIMEOUT %lu", action->timeout);

}

}

if (action->execute != 1)

{

wtxt+= my_snprintf(wtxt, wend - wtxt, " EXECUTE %lu", action->execute);

}

}

if (action->hit_limit)

{

wtxt+= my_snprintf(wtxt, wend - wtxt, "%sHIT_LIMIT %lu",

(wtxt == result) ? "" : " ", action->hit_limit);

}

/*

*wtxt= '\0';

{

st_debug_sync_control *ds_control= thd->debug_sync_control;

uint idx;

DBUG_ENTER("debug_sync_print_actions");

DBUG_ASSERT(thd);

if (!ds_control)

DBUG_VOID_RETURN;

for (idx= 0; idx < ds_control->ds_active; idx++)

{

const char *dsp_name= ds_control->ds_action[idx].sync_point.c_ptr();

char action_string[256];

debug_sync_action_string(action_string, sizeof(action_string),

ds_control->ds_action + idx);

DBUG_PRINT("debug_sync_list", ("%s %s", dsp_name, action_string));

}

DBUG_VOID_RETURN;

{

st_debug_sync_action *action1= (st_debug_sync_action*) arg1;

st_debug_sync_action *action2= (st_debug_sync_action*) arg2;

int diff;

DBUG_ASSERT(action1);

DBUG_ASSERT(action2);

if (!(diff= action1->sync_point.length() - action2->sync_point.length()))

diff= memcmp(action1->sync_point.ptr(), action2->sync_point.ptr(),

action1->sync_point.length());

return diff;

{

st_debug_sync_control *ds_control= thd->debug_sync_control;

DBUG_ENTER("debug_sync_reset");

DBUG_ASSERT(thd);

DBUG_ASSERT(ds_control);

/* Remove all actions of this thread. */

ds_control->ds_active= 0;

/* Clear the global signal. */

mysql_mutex_lock(&debug_sync_global.ds_mutex);

debug_sync_global.ds_signal.length(0);

mysql_mutex_unlock(&debug_sync_global.ds_mutex);

DBUG_VOID_RETURN;

st_debug_sync_action *action)

{

uint dsp_idx= action - ds_control->ds_action;

DBUG_ENTER("debug_sync_remove_action");

DBUG_ASSERT(ds_control);

DBUG_ASSERT(ds_control == current_thd->debug_sync_control);

DBUG_ASSERT(action);

DBUG_ASSERT(dsp_idx < ds_control->ds_active);

/* Decrement the number of currently active actions. */

ds_control->ds_active--;

/*

if (ds_control->ds_active > dsp_idx)

{

/*

uchar save_action[sizeof(st_debug_sync_action)];

/*

memmove(save_action, action, sizeof(st_debug_sync_action));

/* Move actions down. */

memmove(ds_control->ds_action + dsp_idx,

ds_control->ds_action + dsp_idx + 1,

(ds_control->ds_active - dsp_idx) *

sizeof(st_debug_sync_action));

/*

memmove(ds_control->ds_action + ds_control->ds_active, save_action,

sizeof(st_debug_sync_action));

}

DBUG_VOID_RETURN;