injection_point.c File Reference

#include "postgres.h"
#include "utils/injection_point.h"

Include dependency graph for injection_point.c:

Go to the source code of this file.

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)
bool	InjectionPointDetach (const char *name)
void	InjectionPointLoad (const char *name)
void	InjectionPointRun (const char *name, void *arg)
void	InjectionPointCached (const char *name, void *arg)
bool	IsInjectionPointAttached (const char *name)
List *	InjectionPointList (void)

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 273 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));
    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, function, 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(), injection_points_attach_func(), and test_aio_shmem_startup().

InjectionPointCached()

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

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

InjectionPointDetach()

bool InjectionPointDetach

(

const char *

name

)

Definition at line 358 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().

InjectionPointList()

List * InjectionPointList

(

void

)

Definition at line 591 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, InjectionPointData::function, idx(), lappend(), InjectionPointData::library, LW_SHARED, LWLockAcquire(), LWLockRelease(), InjectionPointData::name, NIL, palloc0_object, pg_atomic_read_u32(), pg_atomic_read_u64(), and pstrdup().

Referenced by injection_points_list().

InjectionPointLoad()

void InjectionPointLoad

(

const char *

name

)

Definition at line 528 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.

Referenced by test_aio_shmem_startup().

InjectionPointRun()

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

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

InjectionPointShmemInit()

void InjectionPointShmemInit

(

void

)

Definition at line 249 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 233 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 575 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.