dsm_registry.h File Reference

#include "lib/dshash.h"

Include dependency graph for dsm_registry.h:

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

Go to the source code of this file.

Functions
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)
Size	DSMRegistryShmemSize (void)
void	DSMRegistryShmemInit (void)

Function Documentation

DSMRegistryShmemInit()

void DSMRegistryShmemInit

(

void

)

Definition at line 123 of file dsm_registry.c.

{
    bool        found;
 
    DSMRegistryCtx = (DSMRegistryCtxStruct *)
        ShmemInitStruct("DSM Registry Data",
                        DSMRegistryShmemSize(),
                        &found);
 
    if (!found)
    {
        DSMRegistryCtx->dsah = DSA_HANDLE_INVALID;
        DSMRegistryCtx->dshh = DSHASH_HANDLE_INVALID;
    }
}

References DSA_HANDLE_INVALID, DSMRegistryCtxStruct::dsah, DSHASH_HANDLE_INVALID, DSMRegistryCtxStruct::dshh, DSMRegistryCtx, DSMRegistryShmemSize(), and ShmemInitStruct().

Referenced by CreateOrAttachShmemStructs().

DSMRegistryShmemSize()

Size DSMRegistryShmemSize

(

void

)

Definition at line 117 of file dsm_registry.c.

{
    return MAXALIGN(sizeof(DSMRegistryCtxStruct));
}

References MAXALIGN.

Referenced by CalculateShmemSize(), and DSMRegistryShmemInit().

GetNamedDSA()

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

Definition at line 276 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, 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 357 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(), NamedDSHState::dsa_handle, DSA_HANDLE_INVALID, dsa_is_attached(), dsa_pin(), dsa_pin_mapping(), DSMRegistryEntry::dsh, NamedDSHState::dsh_handle, 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, init_dsm_registry(), LWLockNewTrancheId(), MemoryContextSwitchTo(), name, TopMemoryContext, NamedDSHState::tranche, dshash_parameters::tranche_id, 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 187 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, init_dsm_registry(), MemoryContextSwitchTo(), name, TopMemoryContext, DSMRegistryEntry::type, and type.

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