22#ifdef USE_INJECTION_POINTS
35#define INJ_NAME_MAXLEN 64
36#define INJ_LIB_MAXLEN 128
37#define INJ_FUNC_MAXLEN 128
38#define INJ_PRIVATE_MAXLEN 1024
41typedef struct InjectionPointEntry
64 char library[INJ_LIB_MAXLEN];
71 char private_data[INJ_PRIVATE_MAXLEN];
74#define MAX_INJECTION_POINTS 128
83typedef struct InjectionPointsCtl
86 InjectionPointEntry entries[MAX_INJECTION_POINTS];
95typedef struct InjectionPointCacheEntry
98 char private_data[INJ_PRIVATE_MAXLEN];
108} InjectionPointCacheEntry;
110static HTAB *InjectionPointCache = NULL;
117static InjectionPointCacheEntry *
118injection_point_cache_add(
const char *
name,
122 const void *private_data)
124 InjectionPointCacheEntry *entry;
128 if (InjectionPointCache == NULL)
133 hash_ctl.
entrysize =
sizeof(InjectionPointCacheEntry);
136 InjectionPointCache =
hash_create(
"InjectionPoint cache hash",
137 MAX_INJECTION_POINTS,
142 entry = (InjectionPointCacheEntry *)
147 entry->slot_idx = slot_idx;
148 entry->generation = generation;
150 memcpy(entry->private_data, private_data, INJ_PRIVATE_MAXLEN);
163injection_point_cache_remove(
const char *
name)
176static InjectionPointCacheEntry *
177injection_point_cache_load(InjectionPointEntry *entry,
int slot_idx,
uint64 generation)
180 void *injection_callback_local;
183 entry->library, DLSUFFIX);
186 elog(
ERROR,
"could not find library \"%s\" for injection point \"%s\"",
189 injection_callback_local = (
void *)
192 if (injection_callback_local == NULL)
193 elog(
ERROR,
"could not find function \"%s\" in library \"%s\" for injection point \"%s\"",
194 entry->function, path, entry->name);
197 return injection_point_cache_add(entry->name,
200 injection_callback_local,
201 entry->private_data);
209static InjectionPointCacheEntry *
210injection_point_cache_get(
const char *
name)
213 InjectionPointCacheEntry *entry;
216 if (InjectionPointCache == NULL)
219 entry = (InjectionPointCacheEntry *)
235#ifdef USE_INJECTION_POINTS
238 sz =
add_size(sz,
sizeof(InjectionPointsCtl));
251#ifdef USE_INJECTION_POINTS
255 sizeof(InjectionPointsCtl),
261 for (
int i = 0;
i < MAX_INJECTION_POINTS;
i++)
276 const void *private_data,
277 int private_data_size)
279#ifdef USE_INJECTION_POINTS
280 InjectionPointEntry *entry;
286 elog(
ERROR,
"injection point name %s too long (maximum of %u)",
288 if (strlen(library) >= INJ_LIB_MAXLEN)
289 elog(
ERROR,
"injection point library %s too long (maximum of %u)",
290 library, INJ_LIB_MAXLEN);
291 if (strlen(
function) >= INJ_FUNC_MAXLEN)
292 elog(
ERROR,
"injection point function %s too long (maximum of %u)",
294 if (private_data_size >= INJ_PRIVATE_MAXLEN)
295 elog(
ERROR,
"injection point data too long (maximum of %u)",
306 for (
int idx = 0;
idx < max_inuse;
idx++)
308 entry = &ActiveInjectionPoints->entries[
idx];
310 if (generation % 2 == 0)
319 else if (strcmp(entry->name,
name) == 0)
324 if (max_inuse == MAX_INJECTION_POINTS)
325 elog(
ERROR,
"too many injection points");
326 free_idx = max_inuse;
328 entry = &ActiveInjectionPoints->entries[free_idx];
330 Assert(generation % 2 == 0);
335 strlcpy(entry->library, library,
sizeof(entry->library));
336 entry->library[INJ_LIB_MAXLEN - 1] =
'\0';
338 entry->function[INJ_FUNC_MAXLEN - 1] =
'\0';
339 if (private_data != NULL)
340 memcpy(entry->private_data, private_data, private_data_size);
345 if (free_idx + 1 > max_inuse)
351 elog(
ERROR,
"injection points are not supported by this build");
363#ifdef USE_INJECTION_POINTS
372 for (
idx = max_inuse - 1;
idx >= 0; --
idx)
374 InjectionPointEntry *entry = &ActiveInjectionPoints->entries[
idx];
378 if (generation % 2 == 0)
381 if (strcmp(entry->name,
name) == 0)
391 if (found &&
idx == max_inuse - 1)
395 InjectionPointEntry *entry = &ActiveInjectionPoints->entries[
idx];
399 if (generation % 2 != 0)
408 elog(
ERROR,
"Injection points are not supported by this build");
413#ifdef USE_INJECTION_POINTS
420static InjectionPointCacheEntry *
421InjectionPointCacheRefresh(
const char *
name)
425 InjectionPointEntry local_copy;
426 InjectionPointCacheEntry *cached;
437 if (InjectionPointCache)
440 InjectionPointCache = NULL;
449 cached = injection_point_cache_get(
name);
452 int idx = cached->slot_idx;
453 InjectionPointEntry *entry = &ActiveInjectionPoints->entries[
idx];
460 injection_point_cache_remove(
name);
473 namelen = strlen(
name);
474 for (
int idx = 0;
idx < max_inuse;
idx++)
476 InjectionPointEntry *entry = &ActiveInjectionPoints->entries[
idx];
485 if (generation % 2 == 0)
490 if (memcmp(entry->name,
name, namelen + 1) != 0)
499 memcpy(&local_copy, entry,
sizeof(InjectionPointEntry));
517 return injection_point_cache_load(&local_copy,
idx, generation);
533#ifdef USE_INJECTION_POINTS
534 InjectionPointCacheRefresh(
name);
536 elog(
ERROR,
"Injection points are not supported by this build");
546#ifdef USE_INJECTION_POINTS
547 InjectionPointCacheEntry *cache_entry;
549 cache_entry = InjectionPointCacheRefresh(
name);
551 cache_entry->callback(
name, cache_entry->private_data);
553 elog(
ERROR,
"Injection points are not supported by this build");
563#ifdef USE_INJECTION_POINTS
564 InjectionPointCacheEntry *cache_entry;
566 cache_entry = injection_point_cache_get(
name);
568 cache_entry->callback(
name, cache_entry->private_data);
570 elog(
ERROR,
"Injection points are not supported by this build");
580#ifdef USE_INJECTION_POINTS
581 return InjectionPointCacheRefresh(
name) != NULL;
583 elog(
ERROR,
"Injection points are not supported by this build");
Datum idx(PG_FUNCTION_ARGS)
static void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
#define pg_read_barrier()
static void pg_atomic_init_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
#define pg_write_barrier()
static void pg_atomic_write_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
static uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
static void pg_atomic_init_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
static uint64 pg_atomic_read_u64(volatile pg_atomic_uint64 *ptr)
#define PG_USED_FOR_ASSERTS_ONLY
#define Assert(condition)
void * load_external_function(const char *filename, const char *funcname, bool signalNotFound, void **filehandle)
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
void hash_destroy(HTAB *hashp)
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
bool pg_file_exists(const char *name)
char pkglib_path[MAXPGPATH]
void InjectionPointShmemInit(void)
Size InjectionPointShmemSize(void)
void InjectionPointCached(const char *name)
void InjectionPointLoad(const char *name)
bool InjectionPointDetach(const char *name)
void InjectionPointRun(const char *name)
bool IsInjectionPointAttached(const char *name)
void InjectionPointAttach(const char *name, const char *library, const char *function, const void *private_data, int private_data_size)
void(* InjectionPointCallback)(const char *name, const void *private_data)
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
void LWLockRelease(LWLock *lock)
MemoryContext TopMemoryContext
on_exit_nicely_callback function
size_t strlcpy(char *dst, const char *src, size_t siz)
Size add_size(Size s1, Size s2)
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)