#include "mariadb.h"

#include "debug_sync.h"

#include <cstring>

#if defined(ENABLED_DEBUG_SYNC)

#include "sql_priv.h"

#include "sql_parse.h"

struct st_debug_sync_action

};

struct st_debug_sync_control

};

struct st_debug_sync_globals

};

static st_debug_sync_globals *debug_sync_global; /* All globals in one object */

static void debug_sync(THD *thd, const char *sync_point_name, size_t name_len);

static int debug_sync_qsort_cmp(const void *, const void *);

#ifdef HAVE_PSI_INTERFACE

static PSI_mutex_key key_debug_sync_globals_ds_mutex;

static PSI_mutex_info all_debug_sync_mutexes[]=

{

{ &key_debug_sync_globals_ds_mutex, "DEBUG_SYNC::mutex", PSI_FLAG_GLOBAL}

};

static PSI_cond_key key_debug_sync_globals_ds_cond;

static PSI_cond_info all_debug_sync_conds[]=

{

{ &key_debug_sync_globals_ds_cond, "DEBUG_SYNC::cond", PSI_FLAG_GLOBAL}

};

static void init_debug_sync_psi_keys(void)

}

#endif /* HAVE_PSI_INTERFACE */

static const char*

debug_sync_thd_proc_info(THD *thd, const char* info)

{

const char* old_proc_info= thd->proc_info;

thd->proc_info= info;

return old_proc_info;

}

int debug_sync_init(void)

}

void debug_sync_end(void)

}

static void debug_sync_emergency_disable(void)

}

void debug_sync_init_thread(THD *thd)

}

static const char *get_signal_set_as_string()

{

mysql_mutex_assert_owner(&debug_sync_global->ds_mutex);

size_t req_size= 1; // In case of empty set for the end '\0' char.

for (size_t i= 0; i < debug_sync_global->ds_signal_set.size(); i++)

req_size+= debug_sync_global->ds_signal_set.at(i)->length + 1;

char *buf= (char *) my_malloc(PSI_NOT_INSTRUMENTED, req_size, MYF(0));

if (!buf)

return nullptr;

memset(buf, '\0', req_size);

char *cur_pos= buf;

for (size_t i= 0; i < debug_sync_global->ds_signal_set.size(); i++)

{

const LEX_CSTRING *signal= debug_sync_global->ds_signal_set.at(i);

memcpy(cur_pos, signal->str, signal->length);

if (i != debug_sync_global->ds_signal_set.size() - 1)

cur_pos[signal->length]= ',';

else

cur_pos[signal->length] = '\0';

cur_pos+= signal->length + 1;

}

return buf;

}

void debug_sync_end_thread(THD *thd)

}

void debug_sync_reset_thread(THD *thd)

}

static char *debug_sync_bmove_len(char *to, char *to_end,

const char *from, size_t length)

{

DBUG_ASSERT(to);

DBUG_ASSERT(to_end);

DBUG_ASSERT(!length || from);

set_if_smaller(length, (size_t) (to_end - to));

if (length)

memcpy(to, from, length);

return (to + length);

}

#ifdef DBUG_TRACE

static void debug_sync_action_string(char *result, uint size,

}

static void debug_sync_print_actions(THD *thd)

}

#endif /* defined(DBUG_TRACE) */

static int debug_sync_qsort_cmp(const void* arg1, const void* arg2)

}

static st_debug_sync_action *debug_sync_find(st_debug_sync_action *actionarr,

int quantity,

const char *dsp_name,

size_t name_len)

{

st_debug_sync_action *action;

int low ;

int high ;

int mid ;

ssize_t diff ;

DBUG_ASSERT(actionarr);

DBUG_ASSERT(dsp_name);

DBUG_ASSERT(name_len);

low= 0;

high= quantity;

while (low < high)

{

mid= (low + high) / 2;

action= actionarr + mid;

if (!(diff= name_len - action->sync_point.length()) &&

!(diff= memcmp(dsp_name, action->sync_point.ptr(), name_len)))

return action;

if (diff > 0)

low= mid + 1;

else

high= mid - 1;

}

if (low < quantity)

{

action= actionarr + low;

if ((name_len == action->sync_point.length()) &&

!memcmp(dsp_name, action->sync_point.ptr(), name_len))

return action;

}

return NULL;

}

static void debug_sync_reset(THD *thd)

}

static void debug_sync_remove_action(st_debug_sync_control *ds_control,

}

static st_debug_sync_action *debug_sync_get_action(THD *thd,

const char *dsp_name,

uint name_len)

{

st_debug_sync_control *ds_control= thd->debug_sync_control;

st_debug_sync_action *action;

DBUG_ENTER("debug_sync_get_action");

DBUG_ASSERT(thd);

DBUG_ASSERT(dsp_name);

DBUG_ASSERT(name_len);

DBUG_ASSERT(ds_control);

DBUG_PRINT("debug_sync", ("sync_point: '%.*s'", (int) name_len, dsp_name));

DBUG_PRINT("debug_sync", ("active: %u allocated: %u",

ds_control->ds_active, ds_control->ds_allocated));

/* There cannot be more active actions than allocated. */

DBUG_ASSERT(ds_control->ds_active <= ds_control->ds_allocated);

/* If there are active actions, the action array must be present. */

DBUG_ASSERT(!ds_control->ds_active || ds_control->ds_action);

/* Try to reuse existing action if there is one for this sync point. */

if (ds_control->ds_active &&

(action= debug_sync_find(ds_control->ds_action, ds_control->ds_active,

dsp_name, name_len)))

{

/* Reuse an already active sync point action. */

DBUG_ASSERT((uint)(action - ds_control->ds_action) < ds_control->ds_active);

DBUG_PRINT("debug_sync", ("reuse action idx: %ld",

(long) (action - ds_control->ds_action)));

}

else

{

/* Create a new action. */

int dsp_idx= ds_control->ds_active++;

set_if_bigger(ds_control->dsp_max_active, ds_control->ds_active);

if (ds_control->ds_active > ds_control->ds_allocated)

{

uint new_alloc= ds_control->ds_active + 3;

void *new_action= my_realloc(PSI_NOT_INSTRUMENTED, ds_control->ds_action,

new_alloc * sizeof(st_debug_sync_action),

MYF(MY_WME | MY_ALLOW_ZERO_PTR));

if (!new_action)

{

/* Error is reported by my_malloc(). */

goto err; /* purecov: tested */

}

ds_control->ds_action= (st_debug_sync_action*) new_action;

ds_control->ds_allocated= new_alloc;

/* Clear memory as we do not run string constructors here. */

bzero((uchar*) (ds_control->ds_action + dsp_idx),

(new_alloc - dsp_idx) * sizeof(st_debug_sync_action));

}

DBUG_PRINT("debug_sync", ("added action idx: %u", dsp_idx));

action= ds_control->ds_action + dsp_idx;

if (action->sync_point.copy(dsp_name, name_len, system_charset_info))

{

/* Error is reported by my_malloc(). */

goto err; /* purecov: tested */

}

action->need_sort= TRUE;

}

DBUG_ASSERT(action >= ds_control->ds_action);

DBUG_ASSERT(action < ds_control->ds_action + ds_control->ds_active);

DBUG_PRINT("debug_sync", ("action: %p array: %p count: %u",

action, ds_control->ds_action,

ds_control->ds_active));

DBUG_RETURN(action);

/* purecov: begin tested */

err:

DBUG_RETURN(NULL);

/* purecov: end */

}

class Debug_token: public Lex_ident_ci

};

static bool debug_sync_set_action(THD *thd, st_debug_sync_action *action)

}