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(name)   ((void) name)

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

Functions
Size	InjectionPointShmemSize (void)
void	InjectionPointShmemInit (void)
void	InjectionPointAttach (const char *name, const char *library, const char *function)
void	InjectionPointRun (const char *name)
void	InjectionPointDetach (const char *name)

Macro Definition Documentation

INJECTION_POINT

#define INJECTION_POINT

(

name

)

((void) name)

Definition at line 20 of file injection_point.h.

Typedef Documentation

InjectionPointCallback

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

Definition at line 26 of file injection_point.h.

Function Documentation

InjectionPointAttach()

void InjectionPointAttach	(	const char *	name,
		const char *	library,
		const char *	function
	)

Definition at line 187 of file injection_point.c.

{
#ifdef USE_INJECTION_POINTS
    InjectionPointEntry *entry_by_name;
    bool        found;
 
    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);
 
    /*
     * Allocate and register a new injection point.  A new point should not
     * exist.  For testing purposes this should be fine.
     */
    LWLockAcquire(InjectionPointLock, LW_EXCLUSIVE);
    entry_by_name = (InjectionPointEntry *)
        hash_search(InjectionPointHash, name,
                    HASH_ENTER, &found);
    if (found)
    {
        LWLockRelease(InjectionPointLock);
        elog(ERROR, "injection point \"%s\" already defined", name);
    }
 
    /* Save the entry */
    strlcpy(entry_by_name->name, name, sizeof(entry_by_name->name));
    entry_by_name->name[INJ_NAME_MAXLEN - 1] = '\0';
    strlcpy(entry_by_name->library, library, sizeof(entry_by_name->library));
    entry_by_name->library[INJ_LIB_MAXLEN - 1] = '\0';
    strlcpy(entry_by_name->function, function, sizeof(entry_by_name->function));
    entry_by_name->function[INJ_FUNC_MAXLEN - 1] = '\0';
 
    LWLockRelease(InjectionPointLock);
 
#else
    elog(ERROR, "injection points are not supported by this build");
#endif
}

References elog, ERROR, HASH_ENTER, hash_search(), INJ_NAME_MAXLEN, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), name, and strlcpy().

Referenced by injection_points_attach().

InjectionPointDetach()

void InjectionPointDetach

(

const char *

name

)

Definition at line 238 of file injection_point.c.

{
#ifdef USE_INJECTION_POINTS
    bool        found;
 
    LWLockAcquire(InjectionPointLock, LW_EXCLUSIVE);
    hash_search(InjectionPointHash, name, HASH_REMOVE, &found);
    LWLockRelease(InjectionPointLock);
 
    if (!found)
        elog(ERROR, "injection point \"%s\" not found", name);
 
#else
    elog(ERROR, "Injection points are not supported by this build");
#endif
}

References elog, ERROR, HASH_REMOVE, hash_search(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), and name.

Referenced by injection_points_cleanup(), and injection_points_detach().

InjectionPointRun()

void InjectionPointRun

(

const char *

name

)

Definition at line 262 of file injection_point.c.

{
#ifdef USE_INJECTION_POINTS
    InjectionPointEntry *entry_by_name;
    bool        found;
    InjectionPointCallback injection_callback;
 
    LWLockAcquire(InjectionPointLock, LW_SHARED);
    entry_by_name = (InjectionPointEntry *)
        hash_search(InjectionPointHash, name,
                    HASH_FIND, &found);
    LWLockRelease(InjectionPointLock);
 
    /*
     * If not found, do nothing and remove it from the local cache if it
     * existed there.
     */
    if (!found)
    {
        injection_point_cache_remove(name);
        return;
    }
 
    /*
     * Check if the callback exists in the local cache, to avoid unnecessary
     * external loads.
     */
    injection_callback = injection_point_cache_get(name);
    if (injection_callback == NULL)
    {
        char        path[MAXPGPATH];
 
        /* not found in local cache, so load and register */
        snprintf(path, MAXPGPATH, "%s/%s%s", pkglib_path,
                 entry_by_name->library, DLSUFFIX);
 
        if (!pg_file_exists(path))
            elog(ERROR, "could not find library \"%s\" for injection point \"%s\"",
                 path, name);
 
        injection_callback = (InjectionPointCallback)
            load_external_function(path, entry_by_name->function, false, NULL);
 
        if (injection_callback == NULL)
            elog(ERROR, "could not find function \"%s\" in library \"%s\" for injection point \"%s\"",
                 entry_by_name->function, path, name);
 
        /* add it to the local cache when found */
        injection_point_cache_add(name, injection_callback);
    }
 
    injection_callback(name);
#else
    elog(ERROR, "Injection points are not supported by this build");
#endif
}

References elog, ERROR, HASH_FIND, hash_search(), load_external_function(), LW_SHARED, LWLockAcquire(), LWLockRelease(), MAXPGPATH, name, pg_file_exists(), pkglib_path, and snprintf.

InjectionPointShmemInit()

void InjectionPointShmemInit

(

void

)

Definition at line 167 of file injection_point.c.

{
#ifdef USE_INJECTION_POINTS
    HASHCTL     info;
 
    /* key is a NULL-terminated string */
    info.keysize = sizeof(char[INJ_NAME_MAXLEN]);
    info.entrysize = sizeof(InjectionPointEntry);
    InjectionPointHash = ShmemInitHash("InjectionPoint hash",
                                       INJECTION_POINT_HASH_INIT_SIZE,
                                       INJECTION_POINT_HASH_MAX_SIZE,
                                       &info,
                                       HASH_ELEM | HASH_FIXED_SIZE | HASH_STRINGS);
#endif
}

References HASHCTL::entrysize, HASH_ELEM, HASH_FIXED_SIZE, HASH_STRINGS, INJ_NAME_MAXLEN, HASHCTL::keysize, and ShmemInitHash().

Referenced by CreateOrAttachShmemStructs().

InjectionPointShmemSize()

Size InjectionPointShmemSize

(

void

)

Definition at line 150 of file injection_point.c.

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

References add_size(), and hash_estimate_size().

Referenced by CalculateShmemSize().