injection_point.h File Reference

#include "nodes/pg_list.h"

Include dependency graph for injection_point.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	InjectionPointData

Macros
#define	INJECTION_POINT_LOAD(name)   ((void) name)
#define	INJECTION_POINT(name, arg)   ((void) name)
#define	INJECTION_POINT_CACHED(name, arg)   ((void) name)
#define	IS_INJECTION_POINT_ATTACHED(name)   (false)

Typedefs
typedef struct InjectionPointData	InjectionPointData
typedef void(*	InjectionPointCallback) (const char *name, const void *private_data, void *arg)

Functions
void	InjectionPointAttach (const char *name, const char *library, const char *function, const void *private_data, int private_data_size)
void	InjectionPointLoad (const char *name)
void	InjectionPointRun (const char *name, void *arg)
void	InjectionPointCached (const char *name, void *arg)
bool	IsInjectionPointAttached (const char *name)
bool	InjectionPointDetach (const char *name)
List *	InjectionPointList (void)

Macro Definition Documentation

INJECTION_POINT

#define INJECTION_POINT	(		name,
			arg
	)		((void) name)

Definition at line 37 of file injection_point.h.

INJECTION_POINT_CACHED

#define INJECTION_POINT_CACHED	(		name,
			arg
	)		((void) name)

Definition at line 38 of file injection_point.h.

INJECTION_POINT_LOAD

#define INJECTION_POINT_LOAD

(

name

)

((void) name)

Definition at line 36 of file injection_point.h.

IS_INJECTION_POINT_ATTACHED

#define IS_INJECTION_POINT_ATTACHED

(

name

)

(false)

Definition at line 39 of file injection_point.h.

Typedef Documentation

InjectionPointCallback

typedef void(* InjectionPointCallback) (const char *name, const void *private_data, void *arg)

Definition at line 45 of file injection_point.h.

InjectionPointData

typedef struct InjectionPointData InjectionPointData

Function Documentation

InjectionPointAttach()

void InjectionPointAttach ( const char *  name, const char *  library, const char *  function, const void *  private_data, int  private_data_size  )

extern

Definition at line 262 of file injection_point.c.

{
#ifdef USE_INJECTION_POINTS
    InjectionPointEntry *entry;
    uint64      generation;
    uint32      max_inuse;
    int         free_idx;
 
    if (strlen(name) >= INJ_NAME_MAXLEN)
        elog(ERROR, "injection point name %s too long (maximum of %u characters)",
             name, INJ_NAME_MAXLEN - 1);
    if (strlen(library) >= INJ_LIB_MAXLEN)
        elog(ERROR, "injection point library %s too long (maximum of %u characters)",
             library, INJ_LIB_MAXLEN - 1);
    if (strlen(function) >= INJ_FUNC_MAXLEN)
        elog(ERROR, "injection point function %s too long (maximum of %u characters)",
             function, INJ_FUNC_MAXLEN - 1);
    if (private_data_size > INJ_PRIVATE_MAXLEN)
        elog(ERROR, "injection point data too long (maximum of %u bytes)",
             INJ_PRIVATE_MAXLEN);
 
    /*
     * Allocate and register a new injection point.  A new point should not
     * exist.  For testing purposes this should be fine.
     */
    LWLockAcquire(InjectionPointLock, LW_EXCLUSIVE);
    max_inuse = pg_atomic_read_u32(&ActiveInjectionPoints->max_inuse);
    free_idx = -1;
 
    for (int idx = 0; idx < max_inuse; idx++)
    {
        entry = &ActiveInjectionPoints->entries[idx];
        generation = pg_atomic_read_u64(&entry->generation);
        if (generation % 2 == 0)
        {
            /*
             * Found a free slot where we can add the new entry, but keep
             * going so that we will find out if the entry already exists.
             */
            if (free_idx == -1)
                free_idx = idx;
        }
        else if (strcmp(entry->name, name) == 0)
            elog(ERROR, "injection point \"%s\" already defined", name);
    }
    if (free_idx == -1)
    {
        if (max_inuse == MAX_INJECTION_POINTS)
            elog(ERROR, "too many injection points");
        free_idx = max_inuse;
    }
    entry = &ActiveInjectionPoints->entries[free_idx];
    generation = pg_atomic_read_u64(&entry->generation);
    Assert(generation % 2 == 0);
 
    /* Save the entry */
    strlcpy(entry->name, name, sizeof(entry->name));
    strlcpy(entry->library, library, sizeof(entry->library));
    strlcpy(entry->function, function, sizeof(entry->function));
    memset(entry->private_data, 0, INJ_PRIVATE_MAXLEN);
    if (private_data != NULL)
        memcpy(entry->private_data, private_data, private_data_size);
 
    pg_write_barrier();
    pg_atomic_write_u64(&entry->generation, generation + 1);
 
    if (free_idx + 1 > max_inuse)
        pg_atomic_write_u32(&ActiveInjectionPoints->max_inuse, free_idx + 1);
 
    LWLockRelease(InjectionPointLock);
 
#else
    elog(ERROR, "injection points are not supported by this build");
#endif
}

References Assert, elog, ERROR, fb(), function, idx(), INJ_NAME_MAXLEN, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), memcpy(), name, pg_atomic_read_u32(), pg_atomic_read_u64(), pg_atomic_write_u32(), pg_atomic_write_u64(), pg_write_barrier, and strlcpy().

Referenced by dcw_inject_delay_barrier(), dcw_inject_launcher_delay(), dcw_inject_startup_delay(), injection_points_attach(), injection_points_attach_func(), and test_aio_shmem_init().

InjectionPointCached()

void InjectionPointCached ( const char *  name, void *  arg  )

extern

Definition at line 548 of file injection_point.c.

{
#ifdef USE_INJECTION_POINTS
    InjectionPointCacheEntry *cache_entry;
 
    cache_entry = injection_point_cache_get(name);
    if (cache_entry)
        cache_entry->callback(name, cache_entry->private_data, arg);
#else
    elog(ERROR, "Injection points are not supported by this build");
#endif
}

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

InjectionPointDetach()

bool InjectionPointDetach ( const char *  name )

extern

Definition at line 348 of file injection_point.c.

{
#ifdef USE_INJECTION_POINTS
    bool        found = false;
    int         idx;
    int         max_inuse;
 
    LWLockAcquire(InjectionPointLock, LW_EXCLUSIVE);
 
    /* Find it in the shmem array, and mark the slot as unused */
    max_inuse = (int) pg_atomic_read_u32(&ActiveInjectionPoints->max_inuse);
    for (idx = max_inuse - 1; idx >= 0; --idx)
    {
        InjectionPointEntry *entry = &ActiveInjectionPoints->entries[idx];
        uint64      generation;
 
        generation = pg_atomic_read_u64(&entry->generation);
        if (generation % 2 == 0)
            continue;           /* empty slot */
 
        if (strcmp(entry->name, name) == 0)
        {
            Assert(!found);
            found = true;
            pg_atomic_write_u64(&entry->generation, generation + 1);
            break;
        }
    }
 
    /* If we just removed the highest-numbered entry, update 'max_inuse' */
    if (found && idx == max_inuse - 1)
    {
        for (; idx >= 0; --idx)
        {
            InjectionPointEntry *entry = &ActiveInjectionPoints->entries[idx];
            uint64      generation;
 
            generation = pg_atomic_read_u64(&entry->generation);
            if (generation % 2 != 0)
                break;
        }
        pg_atomic_write_u32(&ActiveInjectionPoints->max_inuse, idx + 1);
    }
    LWLockRelease(InjectionPointLock);
 
    return found;
#else
    elog(ERROR, "Injection points are not supported by this build");
    return true;                /* silence compiler */
#endif
}

References Assert, elog, ERROR, fb(), idx(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), name, pg_atomic_read_u32(), pg_atomic_read_u64(), pg_atomic_write_u32(), and pg_atomic_write_u64().

Referenced by dcw_inject_delay_barrier(), dcw_inject_launcher_delay(), dcw_inject_startup_delay(), injection_points_cleanup(), and injection_points_detach().

InjectionPointList()

List * InjectionPointList ( void  )

extern

Definition at line 581 of file injection_point.c.

{
#ifdef USE_INJECTION_POINTS
    List       *inj_points = NIL;
    uint32      max_inuse;
 
    LWLockAcquire(InjectionPointLock, LW_SHARED);
 
    max_inuse = pg_atomic_read_u32(&ActiveInjectionPoints->max_inuse);
 
    for (uint32 idx = 0; idx < max_inuse; idx++)
    {
        InjectionPointEntry *entry;
        InjectionPointData *inj_point;
        uint64      generation;
 
        entry = &ActiveInjectionPoints->entries[idx];
        generation = pg_atomic_read_u64(&entry->generation);
 
        /* skip free slots */
        if (generation % 2 == 0)
            continue;
 
        inj_point = palloc0_object(InjectionPointData);
        inj_point->name = pstrdup(entry->name);
        inj_point->library = pstrdup(entry->library);
        inj_point->function = pstrdup(entry->function);
        inj_points = lappend(inj_points, inj_point);
    }
 
    LWLockRelease(InjectionPointLock);
 
    return inj_points;
 
#else
    elog(ERROR, "Injection points are not supported by this build");
    return NIL;                 /* keep compiler quiet */
#endif
}

References elog, ERROR, fb(), idx(), lappend(), LW_SHARED, LWLockAcquire(), LWLockRelease(), NIL, palloc0_object, pg_atomic_read_u32(), pg_atomic_read_u64(), and pstrdup().

Referenced by injection_points_list().

InjectionPointLoad()

void InjectionPointLoad ( const char *  name )

extern

Definition at line 518 of file injection_point.c.

{
#ifdef USE_INJECTION_POINTS
    InjectionPointCacheRefresh(name);
#else
    elog(ERROR, "Injection points are not supported by this build");
#endif
}

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

Referenced by test_aio_shmem_attach(), and test_aio_shmem_init().

InjectionPointRun()

void InjectionPointRun ( const char *  name, void *  arg  )

extern

Definition at line 531 of file injection_point.c.

{
#ifdef USE_INJECTION_POINTS
    InjectionPointCacheEntry *cache_entry;
 
    cache_entry = InjectionPointCacheRefresh(name);
    if (cache_entry)
        cache_entry->callback(name, cache_entry->private_data, arg);
#else
    elog(ERROR, "Injection points are not supported by this build");
#endif
}

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

IsInjectionPointAttached()

bool IsInjectionPointAttached ( const char *  name )

extern

Definition at line 565 of file injection_point.c.

{
#ifdef USE_INJECTION_POINTS
    return InjectionPointCacheRefresh(name) != NULL;
#else
    elog(ERROR, "Injection points are not supported by this build");
    return false;               /* silence compiler */
#endif
}

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