dsm_registry.c File Reference

#include "postgres.h"
#include "funcapi.h"
#include "lib/dshash.h"
#include "storage/dsm_registry.h"
#include "storage/lwlock.h"
#include "storage/shmem.h"
#include "storage/subsystems.h"
#include "utils/builtins.h"
#include "utils/memutils.h"
#include "utils/tuplestore.h"

Include dependency graph for dsm_registry.c:

Go to the source code of this file.

Data Structures
struct	DSMRegistryCtxStruct
struct	NamedDSMState
struct	NamedDSAState
struct	NamedDSHState
struct	DSMRegistryEntry

Typedefs
typedef struct DSMRegistryCtxStruct	DSMRegistryCtxStruct
typedef struct NamedDSMState	NamedDSMState
typedef struct NamedDSAState	NamedDSAState
typedef struct NamedDSHState	NamedDSHState
typedef enum DSMREntryType	DSMREntryType
typedef struct DSMRegistryEntry	DSMRegistryEntry

Enumerations
enum	DSMREntryType { DSMR_ENTRY_TYPE_DSM , DSMR_ENTRY_TYPE_DSA , DSMR_ENTRY_TYPE_DSH }

Functions
static void	DSMRegistryShmemRequest (void *arg)
static void	DSMRegistryShmemInit (void *arg)
static void	init_dsm_registry (void)
void *	GetNamedDSMSegment (const char *name, size_t size, void(*init_callback)(void *ptr, void *arg), bool *found, void *arg)
dsa_area *	GetNamedDSA (const char *name, bool *found)
dshash_table *	GetNamedDSHash (const char *name, const dshash_parameters *params, bool *found)
Datum	pg_get_dsm_registry_allocations (PG_FUNCTION_ARGS)

Variables
static DSMRegistryCtxStruct *	DSMRegistryCtx
const ShmemCallbacks	DSMRegistryShmemCallbacks
static const char *const	DSMREntryTypeNames []
static const dshash_parameters	dsh_params
static dsa_area *	dsm_registry_dsa
static dshash_table *	dsm_registry_table

Typedef Documentation

DSMRegistryCtxStruct

typedef struct DSMRegistryCtxStruct DSMRegistryCtxStruct

DSMRegistryEntry

typedef struct DSMRegistryEntry DSMRegistryEntry

DSMREntryType

typedef enum DSMREntryType DSMREntryType

NamedDSAState

typedef struct NamedDSAState NamedDSAState

NamedDSHState

typedef struct NamedDSHState NamedDSHState

NamedDSMState

typedef struct NamedDSMState NamedDSMState

Enumeration Type Documentation

DSMREntryType

enum DSMREntryType

Enumerator
DSMR_ENTRY_TYPE_DSM
DSMR_ENTRY_TYPE_DSA
DSMR_ENTRY_TYPE_DSH

Definition at line 88 of file dsm_registry.c.

{
    DSMR_ENTRY_TYPE_DSM,
    DSMR_ENTRY_TYPE_DSA,
    DSMR_ENTRY_TYPE_DSH,
} DSMREntryType;

Function Documentation

DSMRegistryShmemInit()

static void DSMRegistryShmemInit ( void *  arg )

static

Definition at line 136 of file dsm_registry.c.

{
    DSMRegistryCtx->dsah = DSA_HANDLE_INVALID;
    DSMRegistryCtx->dshh = DSHASH_HANDLE_INVALID;
}

References DSA_HANDLE_INVALID, DSMRegistryCtxStruct::dsah, DSHASH_HANDLE_INVALID, DSMRegistryCtxStruct::dshh, and DSMRegistryCtx.

DSMRegistryShmemRequest()

static void DSMRegistryShmemRequest ( void *  arg )

static

Definition at line 127 of file dsm_registry.c.

{
    ShmemRequestStruct(.name = "DSM Registry Data",
                       .size = sizeof(DSMRegistryCtxStruct),
                       .ptr = (void **) &DSMRegistryCtx,
        );
}

References DSMRegistryCtx, name, and ShmemRequestStruct.

GetNamedDSA()

dsa_area * GetNamedDSA	(	const char *	name,
		bool *	found
	)

Definition at line 279 of file dsm_registry.c.

{
    DSMRegistryEntry *entry;
    MemoryContext oldcontext;
    dsa_area   *ret;
    NamedDSAState *state;
 
    Assert(found);
 
    if (!name || *name == '\0')
        ereport(ERROR,
                (errmsg("DSA name cannot be empty")));
 
    if (strlen(name) >= offsetof(DSMRegistryEntry, type))
        ereport(ERROR,
                (errmsg("DSA name too long")));
 
    /* Be sure any local memory allocated by DSM/DSA routines is persistent. */
    oldcontext = MemoryContextSwitchTo(TopMemoryContext);
 
    /* Connect to the registry. */
    init_dsm_registry();
 
    entry = dshash_find_or_insert(dsm_registry_table, name, found);
    state = &entry->dsa;
    if (!(*found))
    {
        entry->type = DSMR_ENTRY_TYPE_DSA;
        state->handle = DSA_HANDLE_INVALID;
        state->tranche = -1;
    }
    else if (entry->type != DSMR_ENTRY_TYPE_DSA)
        ereport(ERROR,
                (errmsg("requested DSA does not match type of existing entry")));
 
    if (state->tranche == -1)
    {
        *found = false;
 
        /* Initialize the LWLock tranche for the DSA. */
        state->tranche = LWLockNewTrancheId(name);
    }
 
    if (state->handle == DSA_HANDLE_INVALID)
    {
        *found = false;
 
        /* Initialize the DSA. */
        ret = dsa_create(state->tranche);
        dsa_pin(ret);
        dsa_pin_mapping(ret);
 
        /* Store handle for other backends to use. */
        state->handle = dsa_get_handle(ret);
    }
    else if (dsa_is_attached(state->handle))
        ereport(ERROR,
                (errmsg("requested DSA already attached to current process")));
    else
    {
        /* Attach to existing DSA. */
        ret = dsa_attach(state->handle);
        dsa_pin_mapping(ret);
    }
 
    dshash_release_lock(dsm_registry_table, entry);
    MemoryContextSwitchTo(oldcontext);
 
    return ret;
}

References Assert, DSMRegistryEntry::dsa, dsa_attach(), dsa_create, dsa_get_handle(), DSA_HANDLE_INVALID, dsa_is_attached(), dsa_pin(), dsa_pin_mapping(), dshash_find_or_insert, dshash_release_lock(), dsm_registry_table, DSMR_ENTRY_TYPE_DSA, ereport, errmsg, ERROR, fb(), init_dsm_registry(), LWLockNewTrancheId(), MemoryContextSwitchTo(), name, TopMemoryContext, DSMRegistryEntry::type, and type.

Referenced by tdr_attach_shmem(), test_custom_stats_var_create(), test_custom_stats_var_from_serialized_data(), test_custom_stats_var_report(), and test_custom_stats_var_to_serialized_data().

GetNamedDSHash()

dshash_table * GetNamedDSHash	(	const char *	name,
		const dshash_parameters *	params,
		bool *	found
	)

Definition at line 360 of file dsm_registry.c.

{
    DSMRegistryEntry *entry;
    MemoryContext oldcontext;
    dshash_table *ret;
    NamedDSHState *dsh_state;
 
    Assert(params);
    Assert(found);
 
    if (!name || *name == '\0')
        ereport(ERROR,
                (errmsg("DSHash name cannot be empty")));
 
    if (strlen(name) >= offsetof(DSMRegistryEntry, type))
        ereport(ERROR,
                (errmsg("DSHash name too long")));
 
    /* Be sure any local memory allocated by DSM/DSA routines is persistent. */
    oldcontext = MemoryContextSwitchTo(TopMemoryContext);
 
    /* Connect to the registry. */
    init_dsm_registry();
 
    entry = dshash_find_or_insert(dsm_registry_table, name, found);
    dsh_state = &entry->dsh;
    if (!(*found))
    {
        entry->type = DSMR_ENTRY_TYPE_DSH;
        dsh_state->dsa_handle = DSA_HANDLE_INVALID;
        dsh_state->dsh_handle = DSHASH_HANDLE_INVALID;
        dsh_state->tranche = -1;
    }
    else if (entry->type != DSMR_ENTRY_TYPE_DSH)
        ereport(ERROR,
                (errmsg("requested DSHash does not match type of existing entry")));
 
    if (dsh_state->tranche == -1)
    {
        *found = false;
 
        /* Initialize the LWLock tranche for the hash table. */
        dsh_state->tranche = LWLockNewTrancheId(name);
    }
 
    if (dsh_state->dsa_handle == DSA_HANDLE_INVALID)
    {
        dshash_parameters params_copy;
        dsa_area   *dsa;
 
        *found = false;
 
        /* Initialize the DSA for the hash table. */
        dsa = dsa_create(dsh_state->tranche);
 
        /* Initialize the dshash table. */
        memcpy(&params_copy, params, sizeof(dshash_parameters));
        params_copy.tranche_id = dsh_state->tranche;
        ret = dshash_create(dsa, &params_copy, NULL);
 
        dsa_pin(dsa);
        dsa_pin_mapping(dsa);
 
        /* Store handles for other backends to use. */
        dsh_state->dsa_handle = dsa_get_handle(dsa);
        dsh_state->dsh_handle = dshash_get_hash_table_handle(ret);
    }
    else if (dsa_is_attached(dsh_state->dsa_handle))
        ereport(ERROR,
                (errmsg("requested DSHash already attached to current process")));
    else
    {
        dsa_area   *dsa;
 
        /* XXX: Should we verify params matches what table was created with? */
 
        /* Attach to existing DSA for the hash table. */
        dsa = dsa_attach(dsh_state->dsa_handle);
        dsa_pin_mapping(dsa);
 
        /* Attach to existing dshash table. */
        ret = dshash_attach(dsa, params, dsh_state->dsh_handle, NULL);
    }
 
    dshash_release_lock(dsm_registry_table, entry);
    MemoryContextSwitchTo(oldcontext);
 
    return ret;
}

References Assert, dsa_attach(), dsa_create, dsa_get_handle(), DSA_HANDLE_INVALID, dsa_is_attached(), dsa_pin(), dsa_pin_mapping(), DSMRegistryEntry::dsh, dshash_attach(), dshash_create(), dshash_find_or_insert, dshash_get_hash_table_handle(), DSHASH_HANDLE_INVALID, dshash_release_lock(), dsm_registry_table, DSMR_ENTRY_TYPE_DSH, ereport, errmsg, ERROR, fb(), init_dsm_registry(), LWLockNewTrancheId(), memcpy(), MemoryContextSwitchTo(), name, TopMemoryContext, DSMRegistryEntry::type, and type.

Referenced by tdr_attach_shmem().

GetNamedDSMSegment()

void * GetNamedDSMSegment	(	const char *	name,
		size_t	size,
		void(*)(void *ptr, void *arg)	init_callback,
		bool *	found,
		void *	arg
	)

Definition at line 190 of file dsm_registry.c.

{
    DSMRegistryEntry *entry;
    MemoryContext oldcontext;
    void       *ret;
    NamedDSMState *state;
    dsm_segment *seg;
 
    Assert(found);
 
    if (!name || *name == '\0')
        ereport(ERROR,
                (errmsg("DSM segment name cannot be empty")));
 
    if (strlen(name) >= offsetof(DSMRegistryEntry, type))
        ereport(ERROR,
                (errmsg("DSM segment name too long")));
 
    if (size == 0)
        ereport(ERROR,
                (errmsg("DSM segment size must be nonzero")));
 
    /* Be sure any local memory allocated by DSM/DSA routines is persistent. */
    oldcontext = MemoryContextSwitchTo(TopMemoryContext);
 
    /* Connect to the registry. */
    init_dsm_registry();
 
    entry = dshash_find_or_insert(dsm_registry_table, name, found);
    state = &entry->dsm;
    if (!(*found))
    {
        entry->type = DSMR_ENTRY_TYPE_DSM;
        state->handle = DSM_HANDLE_INVALID;
        state->size = size;
    }
    else if (entry->type != DSMR_ENTRY_TYPE_DSM)
        ereport(ERROR,
                (errmsg("requested DSM segment does not match type of existing entry")));
    else if (state->size != size)
        ereport(ERROR,
                (errmsg("requested DSM segment size does not match size of existing segment")));
 
    if (state->handle == DSM_HANDLE_INVALID)
    {
        *found = false;
 
        /* Initialize the segment. */
        seg = dsm_create(size, 0);
 
        if (init_callback)
            (*init_callback) (dsm_segment_address(seg), arg);
 
        dsm_pin_segment(seg);
        dsm_pin_mapping(seg);
        state->handle = dsm_segment_handle(seg);
    }
    else
    {
        /* If the existing segment is not already attached, attach it now. */
        seg = dsm_find_mapping(state->handle);
        if (seg == NULL)
        {
            seg = dsm_attach(state->handle);
            if (seg == NULL)
                elog(ERROR, "could not map dynamic shared memory segment");
 
            dsm_pin_mapping(seg);
        }
    }
 
    ret = dsm_segment_address(seg);
    dshash_release_lock(dsm_registry_table, entry);
    MemoryContextSwitchTo(oldcontext);
 
    return ret;
}

References arg, Assert, dshash_find_or_insert, dshash_release_lock(), DSMRegistryEntry::dsm, dsm_attach(), dsm_create(), dsm_find_mapping(), DSM_HANDLE_INVALID, dsm_pin_mapping(), dsm_pin_segment(), dsm_registry_table, dsm_segment_address(), dsm_segment_handle(), DSMR_ENTRY_TYPE_DSM, elog, ereport, errmsg, ERROR, fb(), init_dsm_registry(), MemoryContextSwitchTo(), name, TopMemoryContext, DSMRegistryEntry::type, and type.

Referenced by apw_init_shmem(), injection_init_shmem(), pgsa_attach(), tdr_attach_shmem(), test_dsa_allocate(), test_dsa_basic(), and test_dsa_resowners().

init_dsm_registry()

static void init_dsm_registry ( void  )

static

Definition at line 148 of file dsm_registry.c.

{
    /* Quick exit if we already did this. */
    if (dsm_registry_table)
        return;
 
    /* Otherwise, use a lock to ensure only one process creates the table. */
    LWLockAcquire(DSMRegistryLock, LW_EXCLUSIVE);
 
    if (DSMRegistryCtx->dshh == DSHASH_HANDLE_INVALID)
    {
        /* Initialize dynamic shared hash table for registry. */
        dsm_registry_dsa = dsa_create(LWTRANCHE_DSM_REGISTRY_DSA);
        dsm_registry_table = dshash_create(dsm_registry_dsa, &dsh_params, NULL);
 
        dsa_pin(dsm_registry_dsa);
        dsa_pin_mapping(dsm_registry_dsa);
 
        /* Store handles in shared memory for other backends to use. */
        DSMRegistryCtx->dsah = dsa_get_handle(dsm_registry_dsa);
        DSMRegistryCtx->dshh = dshash_get_hash_table_handle(dsm_registry_table);
    }
    else
    {
        /* Attach to existing dynamic shared hash table. */
        dsm_registry_dsa = dsa_attach(DSMRegistryCtx->dsah);
        dsa_pin_mapping(dsm_registry_dsa);
        dsm_registry_table = dshash_attach(dsm_registry_dsa, &dsh_params,
                                           DSMRegistryCtx->dshh, NULL);
    }
 
    LWLockRelease(DSMRegistryLock);
}

References dsa_attach(), dsa_create, dsa_get_handle(), dsa_pin(), dsa_pin_mapping(), DSMRegistryCtxStruct::dsah, dsh_params, dshash_attach(), dshash_create(), dshash_get_hash_table_handle(), DSHASH_HANDLE_INVALID, DSMRegistryCtxStruct::dshh, dsm_registry_dsa, dsm_registry_table, DSMRegistryCtx, fb(), LW_EXCLUSIVE, LWLockAcquire(), and LWLockRelease().

Referenced by GetNamedDSA(), GetNamedDSHash(), GetNamedDSMSegment(), and pg_get_dsm_registry_allocations().

pg_get_dsm_registry_allocations()

Datum pg_get_dsm_registry_allocations

(

PG_FUNCTION_ARGS

)

Definition at line 451 of file dsm_registry.c.

{
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    DSMRegistryEntry *entry;
    MemoryContext oldcontext;
    dshash_seq_status status;
 
    InitMaterializedSRF(fcinfo, MAT_SRF_USE_EXPECTED_DESC);
 
    /* Be sure any local memory allocated by DSM/DSA routines is persistent. */
    oldcontext = MemoryContextSwitchTo(TopMemoryContext);
    init_dsm_registry();
    MemoryContextSwitchTo(oldcontext);
 
    dshash_seq_init(&status, dsm_registry_table, false);
    while ((entry = dshash_seq_next(&status)) != NULL)
    {
        Datum       vals[3];
        bool        nulls[3] = {0};
 
        vals[0] = CStringGetTextDatum(entry->name);
        vals[1] = CStringGetTextDatum(DSMREntryTypeNames[entry->type]);
 
        /* Be careful to only return the sizes of initialized entries. */
        if (entry->type == DSMR_ENTRY_TYPE_DSM &&
            entry->dsm.handle != DSM_HANDLE_INVALID)
            vals[2] = Int64GetDatum(entry->dsm.size);
        else if (entry->type == DSMR_ENTRY_TYPE_DSA &&
                 entry->dsa.handle != DSA_HANDLE_INVALID)
            vals[2] = Int64GetDatum(dsa_get_total_size_from_handle(entry->dsa.handle));
        else if (entry->type == DSMR_ENTRY_TYPE_DSH &&
                 entry->dsh.dsa_handle !=DSA_HANDLE_INVALID)
            vals[2] = Int64GetDatum(dsa_get_total_size_from_handle(entry->dsh.dsa_handle));
        else
            nulls[2] = true;
 
        tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, vals, nulls);
    }
    dshash_seq_term(&status);
 
    return (Datum) 0;
}

References CStringGetTextDatum, DSMRegistryEntry::dsa, dsa_get_total_size_from_handle(), NamedDSHState::dsa_handle, DSA_HANDLE_INVALID, DSMRegistryEntry::dsh, dshash_seq_init(), dshash_seq_next(), dshash_seq_term(), DSMRegistryEntry::dsm, DSM_HANDLE_INVALID, dsm_registry_table, DSMR_ENTRY_TYPE_DSA, DSMR_ENTRY_TYPE_DSH, DSMR_ENTRY_TYPE_DSM, DSMREntryTypeNames, fb(), NamedDSMState::handle, NamedDSAState::handle, init_dsm_registry(), InitMaterializedSRF(), Int64GetDatum(), MAT_SRF_USE_EXPECTED_DESC, MemoryContextSwitchTo(), DSMRegistryEntry::name, NamedDSMState::size, TopMemoryContext, tuplestore_putvalues(), and DSMRegistryEntry::type.

Variable Documentation

dsh_params

const dshash_parameters dsh_params

static

Initial value:

= {
    offsetof(DSMRegistryEntry, type),
    sizeof(DSMRegistryEntry),
    dshash_strcmp,
    dshash_strhash,
    dshash_strcpy,
    LWTRANCHE_DSM_REGISTRY_HASH
}

Definition at line 114 of file dsm_registry.c.

                                            {
    offsetof(DSMRegistryEntry, type),
    sizeof(DSMRegistryEntry),
    dshash_strcmp,
    dshash_strhash,
    dshash_strcpy,
    LWTRANCHE_DSM_REGISTRY_HASH
};

Referenced by init_dsm_registry().

dsm_registry_dsa

dsa_area* dsm_registry_dsa

static

Definition at line 123 of file dsm_registry.c.

Referenced by init_dsm_registry().

dsm_registry_table

dshash_table* dsm_registry_table

static

Definition at line 124 of file dsm_registry.c.

Referenced by GetNamedDSA(), GetNamedDSHash(), GetNamedDSMSegment(), init_dsm_registry(), and pg_get_dsm_registry_allocations().

DSMRegistryCtx

DSMRegistryCtxStruct* DSMRegistryCtx

static

Definition at line 59 of file dsm_registry.c.

Referenced by DSMRegistryShmemInit(), DSMRegistryShmemRequest(), and init_dsm_registry().

DSMRegistryShmemCallbacks

const ShmemCallbacks DSMRegistryShmemCallbacks

Initial value:

= {
    .request_fn = DSMRegistryShmemRequest,
    .init_fn = DSMRegistryShmemInit,
}

Definition at line 64 of file dsm_registry.c.

                                                 {
    .request_fn = DSMRegistryShmemRequest,
    .init_fn = DSMRegistryShmemInit,
};

DSMREntryTypeNames

const char* const DSMREntryTypeNames[]

static

Initial value:

=
{
    [DSMR_ENTRY_TYPE_DSM] = "segment",
    [DSMR_ENTRY_TYPE_DSA] = "area",
    [DSMR_ENTRY_TYPE_DSH] = "hash",
}

Definition at line 95 of file dsm_registry.c.

{
    [DSMR_ENTRY_TYPE_DSM] = "segment",
    [DSMR_ENTRY_TYPE_DSA] = "area",
    [DSMR_ENTRY_TYPE_DSH] = "hash",
};

Referenced by pg_get_dsm_registry_allocations().