injection_points.c File Reference

#include "postgres.h"
#include "fmgr.h"
#include "funcapi.h"
#include "injection_points.h"
#include "miscadmin.h"
#include "nodes/pg_list.h"
#include "nodes/value.h"
#include "storage/condition_variable.h"
#include "storage/dsm_registry.h"
#include "storage/ipc.h"
#include "storage/lwlock.h"
#include "storage/shmem.h"
#include "utils/builtins.h"
#include "utils/guc.h"
#include "utils/injection_point.h"
#include "utils/memutils.h"
#include "utils/tuplestore.h"
#include "utils/wait_event.h"

Include dependency graph for injection_points.c:

Go to the source code of this file.

Data Structures
struct	InjectionPointSharedState

Macros
#define	INJ_MAX_WAIT   8
#define	INJ_NAME_MAXLEN   64
#define	NUM_INJECTION_POINTS_LIST   3

Typedefs
typedef struct InjectionPointSharedState	InjectionPointSharedState

Functions
PGDLLEXPORT void	injection_error (const char *name, const void *private_data, void *arg)
PGDLLEXPORT void	injection_notice (const char *name, const void *private_data, void *arg)
PGDLLEXPORT void	injection_wait (const char *name, const void *private_data, void *arg)
static void	injection_shmem_request (void *arg)
static void	injection_shmem_init (void *arg)
static void	injection_point_init_state (void *ptr, void *arg)
static void	injection_init_shmem (void)
static bool	injection_point_allowed (const InjectionPointCondition *condition)
static void	injection_points_cleanup (int code, Datum arg)
	PG_FUNCTION_INFO_V1 (injection_points_attach)
Datum	injection_points_attach (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (injection_points_attach_func)
Datum	injection_points_attach_func (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (injection_points_load)
Datum	injection_points_load (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (injection_points_run)
Datum	injection_points_run (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (injection_points_cached)
Datum	injection_points_cached (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (injection_points_wakeup)
Datum	injection_points_wakeup (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (injection_points_set_local)
Datum	injection_points_set_local (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (injection_points_detach)
Datum	injection_points_detach (PG_FUNCTION_ARGS)
	PG_FUNCTION_INFO_V1 (injection_points_list)
Datum	injection_points_list (PG_FUNCTION_ARGS)
void	_PG_init (void)

Variables
	PG_MODULE_MAGIC
static List *	inj_list_local = NIL
static InjectionPointSharedState *	inj_state = NULL
static bool	injection_point_local = false
static const ShmemCallbacks	injection_shmem_callbacks

Macro Definition Documentation

INJ_MAX_WAIT

#define INJ_MAX_WAIT   8

Definition at line 41 of file injection_points.c.

INJ_NAME_MAXLEN

#define INJ_NAME_MAXLEN   64

Definition at line 42 of file injection_points.c.

NUM_INJECTION_POINTS_LIST

#define NUM_INJECTION_POINTS_LIST   3

Typedef Documentation

InjectionPointSharedState

typedef struct InjectionPointSharedState InjectionPointSharedState

Function Documentation

_PG_init()

void _PG_init

(

void

)

Definition at line 559 of file injection_points.c.

{
    if (!process_shared_preload_libraries_in_progress)
        return;
 
    RegisterShmemCallbacks(&injection_shmem_callbacks);
}

References injection_shmem_callbacks, process_shared_preload_libraries_in_progress, and RegisterShmemCallbacks().

injection_error()

void injection_error ( const char *  name, const void *  private_data, void *  arg  )

extern

Definition at line 194 of file injection_points.c.

{
    const InjectionPointCondition *condition = private_data;
    char       *argstr = arg;
 
    if (!injection_point_allowed(condition))
        return;
 
    if (argstr)
        elog(ERROR, "error triggered for injection point %s (%s)",
             name, argstr);
    else
        elog(ERROR, "error triggered for injection point %s", name);
}

References arg, elog, ERROR, fb(), injection_point_allowed(), and name.

injection_init_shmem()

static void injection_init_shmem ( void  )

static

Definition at line 133 of file injection_points.c.

{
    bool        found;
 
    if (inj_state != NULL)
        return;
 
    inj_state = GetNamedDSMSegment("injection_points",
                                   sizeof(InjectionPointSharedState),
                                   injection_point_init_state,
                                   &found, NULL);
}

References fb(), GetNamedDSMSegment(), inj_state, and injection_point_init_state().

Referenced by injection_points_load(), injection_points_set_local(), injection_points_wakeup(), and injection_wait().

injection_notice()

void injection_notice ( const char *  name, const void *  private_data, void *  arg  )

extern

Definition at line 210 of file injection_points.c.

{
    const InjectionPointCondition *condition = private_data;
    char       *argstr = arg;
 
    if (!injection_point_allowed(condition))
        return;
 
    if (argstr)
        elog(NOTICE, "notice triggered for injection point %s (%s)",
             name, argstr);
    else
        elog(NOTICE, "notice triggered for injection point %s", name);
}

References arg, elog, fb(), injection_point_allowed(), name, and NOTICE.

injection_point_allowed()

static bool injection_point_allowed ( const InjectionPointCondition *  condition )

static

Definition at line 153 of file injection_points.c.

{
    bool        result = true;
 
    switch (condition->type)
    {
        case INJ_CONDITION_PID:
            if (MyProcPid != condition->pid)
                result = false;
            break;
        case INJ_CONDITION_ALWAYS:
            break;
    }
 
    return result;
}

References INJ_CONDITION_ALWAYS, INJ_CONDITION_PID, MyProcPid, InjectionPointCondition::pid, result, and InjectionPointCondition::type.

Referenced by injection_error(), injection_notice(), and injection_wait().

injection_point_init_state()

static void injection_point_init_state ( void *  ptr, void *  arg  )

static

Definition at line 100 of file injection_points.c.

{
    InjectionPointSharedState *state = (InjectionPointSharedState *) ptr;
 
    SpinLockInit(&state->lock);
    memset(state->wait_counts, 0, sizeof(state->wait_counts));
    memset(state->name, 0, sizeof(state->name));
    ConditionVariableInit(&state->wait_point);
}

References ConditionVariableInit(), fb(), and SpinLockInit().

Referenced by injection_init_shmem(), and injection_shmem_init().

injection_points_attach()

Datum injection_points_attach

(

PG_FUNCTION_ARGS

)

Definition at line 294 of file injection_points.c.

{
    char       *name = text_to_cstring(PG_GETARG_TEXT_PP(0));
    char       *action = text_to_cstring(PG_GETARG_TEXT_PP(1));
    char       *function;
    InjectionPointCondition condition = {0};
 
    if (strcmp(action, "error") == 0)
        function = "injection_error";
    else if (strcmp(action, "notice") == 0)
        function = "injection_notice";
    else if (strcmp(action, "wait") == 0)
        function = "injection_wait";
    else
        elog(ERROR, "incorrect action \"%s\" for injection point creation", action);
 
    if (injection_point_local)
    {
        condition.type = INJ_CONDITION_PID;
        condition.pid = MyProcPid;
    }
 
    InjectionPointAttach(name, "injection_points", function, &condition,
                         sizeof(InjectionPointCondition));
 
    if (injection_point_local)
    {
        MemoryContext oldctx;
 
        /* Local injection point, so track it for automated cleanup */
        oldctx = MemoryContextSwitchTo(TopMemoryContext);
        inj_list_local = lappend(inj_list_local, makeString(pstrdup(name)));
        MemoryContextSwitchTo(oldctx);
    }
 
    PG_RETURN_VOID();
}

References elog, ERROR, fb(), function, INJ_CONDITION_PID, inj_list_local, injection_point_local, InjectionPointAttach(), lappend(), makeString(), MemoryContextSwitchTo(), MyProcPid, name, PG_GETARG_TEXT_PP, PG_RETURN_VOID, InjectionPointCondition::pid, pstrdup(), text_to_cstring(), TopMemoryContext, and InjectionPointCondition::type.

injection_points_attach_func()

Datum injection_points_attach_func

(

PG_FUNCTION_ARGS

)

Definition at line 338 of file injection_points.c.

{
    char       *name;
    char       *lib_name;
    char       *function;
    bytea      *private_data = NULL;
    int         private_data_size = 0;
 
    if (PG_ARGISNULL(0))
        elog(ERROR, "injection point name cannot be NULL");
    if (PG_ARGISNULL(1))
        elog(ERROR, "injection point library cannot be NULL");
    if (PG_ARGISNULL(2))
        elog(ERROR, "injection point function cannot be NULL");
 
    name = text_to_cstring(PG_GETARG_TEXT_PP(0));
    lib_name = text_to_cstring(PG_GETARG_TEXT_PP(1));
    function = text_to_cstring(PG_GETARG_TEXT_PP(2));
 
    if (!PG_ARGISNULL(3))
    {
        private_data = PG_GETARG_BYTEA_PP(3);
        private_data_size = VARSIZE_ANY_EXHDR(private_data);
    }
 
    if (private_data != NULL)
        InjectionPointAttach(name, lib_name, function, VARDATA_ANY(private_data),
                             private_data_size);
    else
        InjectionPointAttach(name, lib_name, function, NULL,
                             0);
    PG_RETURN_VOID();
}

References elog, ERROR, fb(), function, InjectionPointAttach(), name, PG_ARGISNULL, PG_GETARG_BYTEA_PP, PG_GETARG_TEXT_PP, PG_RETURN_VOID, text_to_cstring(), VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

injection_points_cached()

Datum injection_points_cached

(

PG_FUNCTION_ARGS

)

Definition at line 416 of file injection_points.c.

{
    char       *name;
    char       *arg = NULL;
 
    if (PG_ARGISNULL(0))
        PG_RETURN_VOID();
    name = text_to_cstring(PG_GETARG_TEXT_PP(0));
 
    if (!PG_ARGISNULL(1))
        arg = text_to_cstring(PG_GETARG_TEXT_PP(1));
 
    INJECTION_POINT_CACHED(name, arg);
 
    PG_RETURN_VOID();
}

References arg, fb(), INJECTION_POINT_CACHED, name, PG_ARGISNULL, PG_GETARG_TEXT_PP, PG_RETURN_VOID, and text_to_cstring().

injection_points_cleanup()

static void injection_points_cleanup ( int  code, Datum  arg  )

static

Definition at line 175 of file injection_points.c.

{
    ListCell   *lc;
 
    /* Leave if nothing is tracked locally */
    if (!injection_point_local)
        return;
 
    /* Detach all the local points */
    foreach(lc, inj_list_local)
    {
        char       *name = strVal(lfirst(lc));
 
        (void) InjectionPointDetach(name);
    }
}

References fb(), inj_list_local, injection_point_local, InjectionPointDetach(), lfirst, name, and strVal.

Referenced by injection_points_set_local().

injection_points_detach()

Datum injection_points_detach

(

PG_FUNCTION_ARGS

)

Definition at line 500 of file injection_points.c.

{
    char       *name = text_to_cstring(PG_GETARG_TEXT_PP(0));
 
    if (!InjectionPointDetach(name))
        elog(ERROR, "could not detach injection point \"%s\"", name);
 
    /* Remove point from local list, if required */
    if (inj_list_local != NIL)
    {
        MemoryContext oldctx;
 
        oldctx = MemoryContextSwitchTo(TopMemoryContext);
        inj_list_local = list_delete(inj_list_local, makeString(name));
        MemoryContextSwitchTo(oldctx);
    }
 
    PG_RETURN_VOID();
}

References elog, ERROR, fb(), inj_list_local, InjectionPointDetach(), list_delete(), makeString(), MemoryContextSwitchTo(), name, NIL, PG_GETARG_TEXT_PP, PG_RETURN_VOID, text_to_cstring(), and TopMemoryContext.

injection_points_list()

Datum injection_points_list

(

PG_FUNCTION_ARGS

)

Definition at line 525 of file injection_points.c.

{
#define NUM_INJECTION_POINTS_LIST 3
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    List       *inj_points;
    ListCell   *lc;
 
    /* Build a tuplestore to return our results in */
    InitMaterializedSRF(fcinfo, 0);
 
    inj_points = InjectionPointList();
 
    foreach(lc, inj_points)
    {
        Datum       values[NUM_INJECTION_POINTS_LIST];
        bool        nulls[NUM_INJECTION_POINTS_LIST];
        InjectionPointData *inj_point = lfirst(lc);
 
        memset(values, 0, sizeof(values));
        memset(nulls, 0, sizeof(nulls));
 
        values[0] = PointerGetDatum(cstring_to_text(inj_point->name));
        values[1] = PointerGetDatum(cstring_to_text(inj_point->library));
        values[2] = PointerGetDatum(cstring_to_text(inj_point->function));
 
        /* shove row into tuplestore */
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls);
    }
 
    return (Datum) 0;
#undef NUM_INJECTION_POINTS_LIST
}

References cstring_to_text(), fb(), InitMaterializedSRF(), InjectionPointList(), lfirst, NUM_INJECTION_POINTS_LIST, PointerGetDatum, tuplestore_putvalues(), and values.

injection_points_load()

Datum injection_points_load

(

PG_FUNCTION_ARGS

)

Definition at line 377 of file injection_points.c.

{
    char       *name = text_to_cstring(PG_GETARG_TEXT_PP(0));
 
    if (inj_state == NULL)
        injection_init_shmem();
 
    INJECTION_POINT_LOAD(name);
 
    PG_RETURN_VOID();
}

References fb(), inj_state, injection_init_shmem(), INJECTION_POINT_LOAD, name, PG_GETARG_TEXT_PP, PG_RETURN_VOID, and text_to_cstring().

injection_points_run()

Datum injection_points_run

(

PG_FUNCTION_ARGS

)

Definition at line 394 of file injection_points.c.

{
    char       *name;
    char       *arg = NULL;
 
    if (PG_ARGISNULL(0))
        PG_RETURN_VOID();
    name = text_to_cstring(PG_GETARG_TEXT_PP(0));
 
    if (!PG_ARGISNULL(1))
        arg = text_to_cstring(PG_GETARG_TEXT_PP(1));
 
    INJECTION_POINT(name, arg);
 
    PG_RETURN_VOID();
}

References arg, fb(), INJECTION_POINT, name, PG_ARGISNULL, PG_GETARG_TEXT_PP, PG_RETURN_VOID, and text_to_cstring().

injection_points_set_local()

Datum injection_points_set_local

(

PG_FUNCTION_ARGS

)

Definition at line 478 of file injection_points.c.

{
    /* Enable flag to add a runtime condition based on this process ID */
    injection_point_local = true;
 
    if (inj_state == NULL)
        injection_init_shmem();
 
    /*
     * Register a before_shmem_exit callback to remove any injection points
     * linked to this process.
     */
    before_shmem_exit(injection_points_cleanup, (Datum) 0);
 
    PG_RETURN_VOID();
}

References before_shmem_exit(), fb(), inj_state, injection_init_shmem(), injection_point_local, injection_points_cleanup(), and PG_RETURN_VOID.

injection_points_wakeup()

Datum injection_points_wakeup

(

PG_FUNCTION_ARGS

)

Definition at line 438 of file injection_points.c.

{
    char       *name = text_to_cstring(PG_GETARG_TEXT_PP(0));
    int         index = -1;
 
    if (inj_state == NULL)
        injection_init_shmem();
 
    /* First bump the wait counter for the injection point to wake up */
    SpinLockAcquire(&inj_state->lock);
    for (int i = 0; i < INJ_MAX_WAIT; i++)
    {
        if (strcmp(name, inj_state->name[i]) == 0)
        {
            index = i;
            break;
        }
    }
    if (index < 0)
    {
        SpinLockRelease(&inj_state->lock);
        elog(ERROR, "could not find injection point %s to wake up", name);
    }
    inj_state->wait_counts[index]++;
    SpinLockRelease(&inj_state->lock);
 
    /* And broadcast the change to the waiters */
    ConditionVariableBroadcast(&inj_state->wait_point);
    PG_RETURN_VOID();
}

References ConditionVariableBroadcast(), elog, ERROR, fb(), i, INJ_MAX_WAIT, inj_state, injection_init_shmem(), InjectionPointSharedState::lock, name, InjectionPointSharedState::name, PG_GETARG_TEXT_PP, PG_RETURN_VOID, SpinLockAcquire(), SpinLockRelease(), text_to_cstring(), InjectionPointSharedState::wait_counts, and InjectionPointSharedState::wait_point.

injection_shmem_init()

static void injection_shmem_init ( void *  arg )

static

Definition at line 120 of file injection_points.c.

{
    /*
     * First time through, so initialize.  This is shared with the dynamic
     * initialization using a DSM.
     */
    injection_point_init_state(inj_state, NULL);
}

References fb(), inj_state, and injection_point_init_state().

injection_shmem_request()

static void injection_shmem_request ( void *  arg )

static

Definition at line 111 of file injection_points.c.

{
    ShmemRequestStruct(.name = "injection_points",
                       .size = sizeof(InjectionPointSharedState),
                       .ptr = (void **) &inj_state,
        );
}

References inj_state, name, and ShmemRequestStruct.

injection_wait()

void injection_wait ( const char *  name, const void *  private_data, void *  arg  )

extern

Definition at line 227 of file injection_points.c.

{
    uint32      old_wait_counts = 0;
    int         index = -1;
    uint32      injection_wait_event = 0;
    const InjectionPointCondition *condition = private_data;
 
    if (inj_state == NULL)
        injection_init_shmem();
 
    if (!injection_point_allowed(condition))
        return;
 
    /*
     * Use the injection point name for this custom wait event.  Note that
     * this custom wait event name is not released, but we don't care much for
     * testing as this should be short-lived.
     */
    injection_wait_event = WaitEventInjectionPointNew(name);
 
    /*
     * Find a free slot to wait for, and register this injection point's name.
     */
    SpinLockAcquire(&inj_state->lock);
    for (int i = 0; i < INJ_MAX_WAIT; i++)
    {
        if (inj_state->name[i][0] == '\0')
        {
            index = i;
            strlcpy(inj_state->name[i], name, INJ_NAME_MAXLEN);
            old_wait_counts = inj_state->wait_counts[i];
            break;
        }
    }
    SpinLockRelease(&inj_state->lock);
 
    if (index < 0)
        elog(ERROR, "could not find free slot for wait of injection point %s ",
             name);
 
    /* And sleep.. */
    ConditionVariablePrepareToSleep(&inj_state->wait_point);
    for (;;)
    {
        uint32      new_wait_counts;
 
        SpinLockAcquire(&inj_state->lock);
        new_wait_counts = inj_state->wait_counts[index];
        SpinLockRelease(&inj_state->lock);
 
        if (old_wait_counts != new_wait_counts)
            break;
        ConditionVariableSleep(&inj_state->wait_point, injection_wait_event);
    }
    ConditionVariableCancelSleep();
 
    /* Remove this injection point from the waiters. */
    SpinLockAcquire(&inj_state->lock);
    inj_state->name[index][0] = '\0';
    SpinLockRelease(&inj_state->lock);
}

References ConditionVariableCancelSleep(), ConditionVariablePrepareToSleep(), ConditionVariableSleep(), elog, ERROR, fb(), i, INJ_MAX_WAIT, INJ_NAME_MAXLEN, inj_state, injection_init_shmem(), injection_point_allowed(), InjectionPointSharedState::lock, name, InjectionPointSharedState::name, SpinLockAcquire(), SpinLockRelease(), strlcpy(), InjectionPointSharedState::wait_counts, InjectionPointSharedState::wait_point, and WaitEventInjectionPointNew().

PG_FUNCTION_INFO_V1() [1/9]

PG_FUNCTION_INFO_V1

(

injection_points_attach

)

PG_FUNCTION_INFO_V1() [2/9]

PG_FUNCTION_INFO_V1

(

injection_points_attach_func

)

PG_FUNCTION_INFO_V1() [3/9]

PG_FUNCTION_INFO_V1

(

injection_points_cached

)

PG_FUNCTION_INFO_V1() [4/9]

PG_FUNCTION_INFO_V1

(

injection_points_detach

)

PG_FUNCTION_INFO_V1() [5/9]

PG_FUNCTION_INFO_V1

(

injection_points_list

)

PG_FUNCTION_INFO_V1() [6/9]

PG_FUNCTION_INFO_V1

(

injection_points_load

)

PG_FUNCTION_INFO_V1() [7/9]

PG_FUNCTION_INFO_V1

(

injection_points_run

)

PG_FUNCTION_INFO_V1() [8/9]

PG_FUNCTION_INFO_V1

(

injection_points_set_local

)

PG_FUNCTION_INFO_V1() [9/9]

PG_FUNCTION_INFO_V1

(

injection_points_wakeup

)

Variable Documentation

inj_list_local

List* inj_list_local = NIL

static

Definition at line 48 of file injection_points.c.

Referenced by injection_points_attach(), injection_points_cleanup(), and injection_points_detach().

inj_state

InjectionPointSharedState* inj_state = NULL

static

Definition at line 72 of file injection_points.c.

Referenced by injection_init_shmem(), injection_points_load(), injection_points_set_local(), injection_points_wakeup(), injection_shmem_init(), injection_shmem_request(), and injection_wait().

injection_point_local

bool injection_point_local = false

static

Definition at line 85 of file injection_points.c.

Referenced by injection_points_attach(), injection_points_cleanup(), and injection_points_set_local().

injection_shmem_callbacks

const ShmemCallbacks injection_shmem_callbacks

static

Initial value:

= {
    .request_fn = injection_shmem_request,
    .init_fn = injection_shmem_init,
}

Definition at line 90 of file injection_points.c.

                                                        {
    .request_fn = injection_shmem_request,
    .init_fn = injection_shmem_init,
};

Referenced by _PG_init().

PG_MODULE_MAGIC

PG_MODULE_MAGIC

Definition at line 38 of file injection_points.c.