injection_point.h File Reference

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

Go to the source code of this file.

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

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

Functions
Size	InjectionPointShmemSize (void)
void	InjectionPointShmemInit (void)
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	InjectionPointCached (const char *name)
bool	IsInjectionPointAttached (const char *name)
bool	InjectionPointDetach (const char *name)

Macro Definition Documentation

INJECTION_POINT

#define INJECTION_POINT

(

name

)

((void) name)

Definition at line 24 of file injection_point.h.

INJECTION_POINT_CACHED

#define INJECTION_POINT_CACHED

(

name

)

((void) name)

Definition at line 25 of file injection_point.h.

INJECTION_POINT_LOAD

#define INJECTION_POINT_LOAD

(

name

)

((void) name)

Definition at line 23 of file injection_point.h.

IS_INJECTION_POINT_ATTACHED

#define IS_INJECTION_POINT_ATTACHED

(

name

)

(false)

Definition at line 26 of file injection_point.h.

Typedef Documentation

InjectionPointCallback

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

Definition at line 32 of file injection_point.h.

Function Documentation

InjectionPointAttach()

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

Definition at line 272 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)",
             name, INJ_NAME_MAXLEN);
    if (strlen(library) >= INJ_LIB_MAXLEN)
        elog(ERROR, "injection point library %s too long (maximum of %u)",
             library, INJ_LIB_MAXLEN);
    if (strlen(function) >= INJ_FUNC_MAXLEN)
        elog(ERROR, "injection point function %s too long (maximum of %u)",
             function, INJ_FUNC_MAXLEN);
    if (private_data_size >= INJ_PRIVATE_MAXLEN)
        elog(ERROR, "injection point data too long (maximum of %u)",
             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;
        }
 
        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));
    entry->name[INJ_NAME_MAXLEN - 1] = '\0';
    strlcpy(entry->library, library, sizeof(entry->library));
    entry->library[INJ_LIB_MAXLEN - 1] = '\0';
    strlcpy(entry->function, function, sizeof(entry->function));
    entry->function[INJ_FUNC_MAXLEN - 1] = '\0';
    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, idx(), INJ_NAME_MAXLEN, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), name, pg_atomic_read_u32(), pg_atomic_read_u64(), pg_atomic_write_u32(), pg_atomic_write_u64(), pg_write_barrier, and strlcpy().

Referenced by injection_points_attach().

InjectionPointCached()

void InjectionPointCached

(

const char *

name

)

Definition at line 561 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);
#else
    elog(ERROR, "Injection points are not supported by this build");
#endif
}

References elog, ERROR, and name.

InjectionPointDetach()

bool InjectionPointDetach

(

const char *

name

)

Definition at line 361 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, 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 injection_points_cleanup(), and injection_points_detach().

InjectionPointLoad()

void InjectionPointLoad

(

const char *

name

)

Definition at line 531 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, and name.

InjectionPointRun()

void InjectionPointRun

(

const char *

name

)

Definition at line 544 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);
#else
    elog(ERROR, "Injection points are not supported by this build");
#endif
}

References elog, ERROR, and name.

InjectionPointShmemInit()

void InjectionPointShmemInit

(

void

)

Definition at line 248 of file injection_point.c.

{
#ifdef USE_INJECTION_POINTS
    bool        found;
 
    ActiveInjectionPoints = ShmemInitStruct("InjectionPoint hash",
                                            sizeof(InjectionPointsCtl),
                                            &found);
    if (!IsUnderPostmaster)
    {
        Assert(!found);
        pg_atomic_init_u32(&ActiveInjectionPoints->max_inuse, 0);
        for (int i = 0; i < MAX_INJECTION_POINTS; i++)
            pg_atomic_init_u64(&ActiveInjectionPoints->entries[i].generation, 0);
    }
    else
        Assert(found);
#endif
}

References Assert, i, IsUnderPostmaster, pg_atomic_init_u32(), pg_atomic_init_u64(), and ShmemInitStruct().

Referenced by CreateOrAttachShmemStructs().

InjectionPointShmemSize()

Size InjectionPointShmemSize

(

void

)

Definition at line 232 of file injection_point.c.

{
#ifdef USE_INJECTION_POINTS
    Size        sz = 0;
 
    sz = add_size(sz, sizeof(InjectionPointsCtl));
    return sz;
#else
    return 0;
#endif
}

References add_size().

Referenced by CalculateShmemSize().

IsInjectionPointAttached()

bool IsInjectionPointAttached

(

const char *

name

)

Definition at line 578 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, and name.