shmem_internal.h File Reference

#include "storage/shmem.h"
#include "utils/hsearch.h"

Include dependency graph for shmem_internal.h:

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

Go to the source code of this file.

Typedefs
typedef struct PGShmemHeader	PGShmemHeader

Enumerations
enum	ShmemRequestKind { SHMEM_KIND_STRUCT = 0 , SHMEM_KIND_HASH , SHMEM_KIND_SLRU }

Functions
void	ShmemCallRequestCallbacks (void)
void	InitShmemAllocator (PGShmemHeader *seghdr)
void	ResetShmemAllocator (void)
void	ShmemRequestInternal (ShmemStructOpts *options, ShmemRequestKind kind)
size_t	ShmemGetRequestedSize (void)
void	ShmemInitRequested (void)
PGDLLIMPORT Size	pg_get_shmem_pagesize (void)
HTAB *	shmem_hash_create (void *location, size_t size, bool found, const char *name, int64 nelems, HASHCTL *infoP, int hash_flags)
void	shmem_hash_init (void *location, ShmemStructOpts *base_options)
void	shmem_hash_attach (void *location, ShmemStructOpts *base_options)

Typedef Documentation

PGShmemHeader

typedef struct PGShmemHeader PGShmemHeader

Definition at line 28 of file shmem_internal.h.

Enumeration Type Documentation

ShmemRequestKind

enum ShmemRequestKind

Enumerator
SHMEM_KIND_STRUCT
SHMEM_KIND_HASH
SHMEM_KIND_SLRU

Definition at line 20 of file shmem_internal.h.

{
    SHMEM_KIND_STRUCT = 0,      /* plain, contiguous area of memory */
    SHMEM_KIND_HASH,            /* a hash table */
    SHMEM_KIND_SLRU,            /* SLRU buffers and control structures */
} ShmemRequestKind;

Function Documentation

InitShmemAllocator()

void InitShmemAllocator ( PGShmemHeader *  seghdr )

extern

Definition at line 637 of file shmem.c.

{
    Size        offset;
    int64       hash_nelems;
    HASHCTL     info;
    int         hash_flags;
 
#ifndef EXEC_BACKEND
    Assert(!IsUnderPostmaster);
#endif
    Assert(seghdr != NULL);
 
    if (IsUnderPostmaster)
    {
        Assert(shmem_request_state == SRS_INITIAL);
    }
    else
    {
        Assert(shmem_request_state == SRS_REQUESTING);
        shmem_request_state = SRS_INITIALIZING;
    }
 
    /*
     * We assume the pointer and offset are MAXALIGN.  Not a hard requirement,
     * but it's true today and keeps the math below simpler.
     */
    Assert(seghdr == (void *) MAXALIGN(seghdr));
    Assert(seghdr->content_offset == MAXALIGN(seghdr->content_offset));
 
    /*
     * Allocations after this point should go through ShmemAlloc, which
     * expects to allocate everything on cache line boundaries.  Make sure the
     * first allocation begins on a cache line boundary.
     */
    offset = CACHELINEALIGN(seghdr->content_offset + sizeof(ShmemAllocatorData));
    if (offset > seghdr->totalsize)
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of shared memory (%zu bytes requested)",
                        offset)));
 
    /*
     * In postmaster or stand-alone backend, initialize the shared memory
     * allocator so that we can allocate shared memory for ShmemIndex using
     * ShmemAlloc().  In a regular backend just set up the pointers required
     * by ShmemAlloc().
     */
    ShmemAllocator = (ShmemAllocatorData *) ((char *) seghdr + seghdr->content_offset);
    if (!IsUnderPostmaster)
    {
        SpinLockInit(&ShmemAllocator->shmem_lock);
        ShmemAllocator->free_offset = offset;
        LWLockInitialize(&ShmemAllocator->index_lock, LWTRANCHE_SHMEM_INDEX);
    }
 
    ShmemSegHdr = seghdr;
    ShmemBase = seghdr;
    ShmemEnd = (char *) ShmemBase + seghdr->totalsize;
 
    /*
     * Create (or attach to) the shared memory index of shmem areas.
     *
     * This is the same initialization as ShmemInitHash() does, but we cannot
     * use ShmemInitHash() here because it relies on ShmemIndex being already
     * initialized.
     */
    hash_nelems = list_length(pending_shmem_requests) + SHMEM_INDEX_ADDITIONAL_SIZE;
 
    info.keysize = SHMEM_INDEX_KEYSIZE;
    info.entrysize = sizeof(ShmemIndexEnt);
    hash_flags = HASH_ELEM | HASH_STRINGS | HASH_FIXED_SIZE;
 
    if (!IsUnderPostmaster)
    {
        ShmemAllocator->index_size = hash_estimate_size(hash_nelems, info.entrysize);
        ShmemAllocator->index = (HASHHDR *) ShmemAlloc(ShmemAllocator->index_size);
    }
    ShmemIndex = shmem_hash_create(ShmemAllocator->index,
                                   ShmemAllocator->index_size,
                                   IsUnderPostmaster,
                                   "ShmemIndex", hash_nelems,
                                   &info, hash_flags);
    Assert(ShmemIndex != NULL);
 
    /*
     * Add an entry for ShmemIndex itself into ShmemIndex, so that it's
     * visible in the pg_shmem_allocations view
     */
    if (!IsUnderPostmaster)
    {
        bool        found;
        ShmemIndexEnt *result = (ShmemIndexEnt *)
            hash_search(ShmemIndex, "ShmemIndex", HASH_ENTER, &found);
 
        Assert(!found);
        result->size = ShmemAllocator->index_size;
        result->allocated_size = ShmemAllocator->index_size;
        result->location = ShmemAllocator->index;
    }
}

References Assert, CACHELINEALIGN, HASHCTL::entrysize, ereport, errcode(), errmsg, ERROR, fb(), ShmemAllocatorData::free_offset, HASH_ELEM, HASH_ENTER, hash_estimate_size(), HASH_FIXED_SIZE, hash_search(), HASH_STRINGS, ShmemAllocatorData::index, ShmemAllocatorData::index_lock, ShmemAllocatorData::index_size, IsUnderPostmaster, HASHCTL::keysize, list_length(), LWLockInitialize(), MAXALIGN, pending_shmem_requests, result, shmem_hash_create(), SHMEM_INDEX_ADDITIONAL_SIZE, SHMEM_INDEX_KEYSIZE, ShmemAllocatorData::shmem_lock, ShmemAlloc(), ShmemAllocator, ShmemBase, ShmemEnd, ShmemIndex, ShmemSegHdr, SpinLockInit(), SRS_INITIAL, SRS_INITIALIZING, SRS_REQUESTING, and PGShmemHeader::totalsize.

Referenced by CreateSharedMemoryAndSemaphores().

pg_get_shmem_pagesize()

PGDLLIMPORT Size pg_get_shmem_pagesize ( void  )

extern

Definition at line 1273 of file shmem.c.

{
    Size        os_page_size;
#ifdef WIN32
    SYSTEM_INFO sysinfo;
 
    GetSystemInfo(&sysinfo);
    os_page_size = sysinfo.dwPageSize;
#else
    os_page_size = sysconf(_SC_PAGESIZE);
#endif
 
    Assert(IsUnderPostmaster);
    Assert(huge_pages_status != HUGE_PAGES_UNKNOWN);
 
    if (huge_pages_status == HUGE_PAGES_ON)
        GetHugePageSize(&os_page_size, NULL);
 
    return os_page_size;
}

References Assert, fb(), GetHugePageSize(), HUGE_PAGES_ON, huge_pages_status, HUGE_PAGES_UNKNOWN, and IsUnderPostmaster.

Referenced by pg_buffercache_os_pages_internal(), and pg_get_shmem_allocations_numa().

ResetShmemAllocator()

void ResetShmemAllocator ( void  )

extern

Definition at line 742 of file shmem.c.

{
    Assert(!IsUnderPostmaster);
    shmem_request_state = SRS_INITIAL;
 
    pending_shmem_requests = NIL;
 
    /*
     * Note that we don't clear the registered callbacks.  We will need to
     * call them again as we restart
     */
}

References Assert, IsUnderPostmaster, NIL, pending_shmem_requests, and SRS_INITIAL.

Referenced by PostmasterStateMachine().

shmem_hash_attach()

void shmem_hash_attach ( void *  location, ShmemStructOpts *  base_options  )

extern

Definition at line 79 of file shmem_hash.c.

{
    ShmemHashOpts *options = (ShmemHashOpts *) base_options;
    int         hash_flags = options->hash_flags;
    HTAB       *htab;
 
    /* attach to it rather than allocate and initialize new space */
    hash_flags |= HASH_ATTACH;
    options->hash_info.hctl = location;
    Assert(options->hash_info.hctl != NULL);
    htab = shmem_hash_create(location, options->base.size, true,
                             options->name,
                             options->nelems, &options->hash_info, hash_flags);
 
    if (options->ptr)
        *options->ptr = htab;
}

References Assert, fb(), HASH_ATTACH, and shmem_hash_create().

Referenced by AttachShmemIndexEntry().

shmem_hash_create()

HTAB * shmem_hash_create ( void *  location, size_t  size, bool  found, const char *  name, int64  nelems, HASHCTL *  infoP, int  hash_flags  )

extern

Definition at line 149 of file shmem_hash.c.

{
    shmem_hash_allocator allocator;
 
    /*
     * Hash tables allocated in shared memory have a fixed directory and have
     * all elements allocated upfront.  We don't support growing because we'd
     * need to grow the underlying shmem region with it.
     *
     * The shared memory allocator must be specified too.
     */
    infoP->alloc = ShmemHashAlloc;
    infoP->alloc_arg = NULL;
    hash_flags |= HASH_SHARED_MEM | HASH_ALLOC | HASH_FIXED_SIZE;
 
    /*
     * if it already exists, attach to it rather than allocate and initialize
     * new space
     */
    if (!found)
    {
        allocator.next = (char *) location;
        allocator.end = (char *) location + size;
        infoP->alloc_arg = &allocator;
    }
    else
    {
        /* Pass location of hashtable header to hash_create */
        infoP->hctl = (HASHHDR *) location;
        hash_flags |= HASH_ATTACH;
    }
 
    return hash_create(name, nelems, infoP, hash_flags);
}

References fb(), HASH_ALLOC, HASH_ATTACH, hash_create(), HASH_FIXED_SIZE, HASH_SHARED_MEM, name, shmem_hash_allocator::next, and ShmemHashAlloc().

Referenced by InitShmemAllocator(), shmem_hash_attach(), shmem_hash_init(), and ShmemInitHash().

shmem_hash_init()

void shmem_hash_init ( void *  location, ShmemStructOpts *  base_options  )

extern

Definition at line 63 of file shmem_hash.c.

{
    ShmemHashOpts *options = (ShmemHashOpts *) base_options;
    int         hash_flags = options->hash_flags;
    HTAB       *htab;
 
    options->hash_info.hctl = location;
    htab = shmem_hash_create(location, options->base.size, false,
                             options->name,
                             options->nelems, &options->hash_info, hash_flags);
 
    if (options->ptr)
        *options->ptr = htab;
}

References fb(), and shmem_hash_create().

Referenced by InitShmemIndexEntry().

ShmemCallRequestCallbacks()

void ShmemCallRequestCallbacks ( void  )

extern

Definition at line 978 of file shmem.c.

{
    ListCell   *lc;
 
    Assert(shmem_request_state == SRS_INITIAL);
    shmem_request_state = SRS_REQUESTING;
 
    foreach(lc, registered_shmem_callbacks)
    {
        const ShmemCallbacks *callbacks = (const ShmemCallbacks *) lfirst(lc);
 
        if (callbacks->request_fn)
            callbacks->request_fn(callbacks->opaque_arg);
    }
}

References Assert, fb(), lfirst, ShmemCallbacks::opaque_arg, registered_shmem_callbacks, ShmemCallbacks::request_fn, SRS_INITIAL, and SRS_REQUESTING.

Referenced by BootstrapModeMain(), PostgresSingleUserMain(), PostmasterMain(), and PostmasterStateMachine().

ShmemGetRequestedSize()

size_t ShmemGetRequestedSize ( void  )

extern

Definition at line 391 of file shmem.c.

{
    size_t      size;
 
    /* memory needed for the ShmemIndex */
    size = hash_estimate_size(list_length(pending_shmem_requests) + SHMEM_INDEX_ADDITIONAL_SIZE,
                              sizeof(ShmemIndexEnt));
    size = CACHELINEALIGN(size);
 
    /* memory needed for all the requested areas */
    foreach_ptr(ShmemRequest, request, pending_shmem_requests)
    {
        size_t      alignment = request->options->alignment;
 
        /* pad the start address for alignment like ShmemAllocRaw() does */
        if (alignment < PG_CACHE_LINE_SIZE)
            alignment = PG_CACHE_LINE_SIZE;
        size = TYPEALIGN(alignment, size);
 
        size = add_size(size, request->options->size);
    }
 
    return size;
}

References add_size(), CACHELINEALIGN, fb(), foreach_ptr, hash_estimate_size(), list_length(), pending_shmem_requests, PG_CACHE_LINE_SIZE, SHMEM_INDEX_ADDITIONAL_SIZE, and TYPEALIGN.

Referenced by CalculateShmemSize().

ShmemInitRequested()

void ShmemInitRequested ( void  )

extern

Definition at line 424 of file shmem.c.

{
    /* should be called only by the postmaster or a standalone backend */
    Assert(!IsUnderPostmaster);
    Assert(shmem_request_state == SRS_INITIALIZING);
 
    /*
     * Initialize the ShmemIndex entries and perform basic initialization of
     * all the requested memory areas.  There are no concurrent processes yet,
     * so no need for locking.
     */
    foreach_ptr(ShmemRequest, request, pending_shmem_requests)
    {
        InitShmemIndexEntry(request);
        pfree(request->options);
    }
    list_free_deep(pending_shmem_requests);
    pending_shmem_requests = NIL;
 
    /*
     * Call the subsystem-specific init callbacks to finish initialization of
     * all the areas.
     */
    foreach_ptr(const ShmemCallbacks, callbacks, registered_shmem_callbacks)
    {
        if (callbacks->init_fn)
            callbacks->init_fn(callbacks->opaque_arg);
    }
 
    shmem_request_state = SRS_DONE;
}

References Assert, fb(), foreach_ptr, InitShmemIndexEntry(), IsUnderPostmaster, list_free_deep(), NIL, pending_shmem_requests, pfree(), registered_shmem_callbacks, SRS_DONE, and SRS_INITIALIZING.

Referenced by CreateSharedMemoryAndSemaphores().

ShmemRequestInternal()

void ShmemRequestInternal ( ShmemStructOpts *  options, ShmemRequestKind  kind  )

extern

Definition at line 336 of file shmem.c.

{
    ShmemRequest *request;
 
    /* Check the options */
    if (options->name == NULL)
        elog(ERROR, "shared memory request is missing 'name' option");
 
    if (IsUnderPostmaster)
    {
        if (options->size <= 0 && options->size != SHMEM_ATTACH_UNKNOWN_SIZE)
            elog(ERROR, "invalid size %zd for shared memory request for \"%s\"",
                 options->size, options->name);
    }
    else
    {
        if (options->size == SHMEM_ATTACH_UNKNOWN_SIZE)
            elog(ERROR, "SHMEM_ATTACH_UNKNOWN_SIZE cannot be used during startup");
        if (options->size <= 0)
            elog(ERROR, "invalid size %zd for shared memory request for \"%s\"",
                 options->size, options->name);
    }
 
    if (options->alignment != 0 && pg_nextpower2_size_t(options->alignment) != options->alignment)
        elog(ERROR, "invalid alignment %zu for shared memory request for \"%s\"",
             options->alignment, options->name);
 
    /* Check that we're in the right state */
    if (shmem_request_state != SRS_REQUESTING)
        elog(ERROR, "ShmemRequestStruct can only be called from a shmem_request callback");
 
    /* Check that it's not already registered in this process */
    foreach_ptr(ShmemRequest, existing, pending_shmem_requests)
    {
        if (strcmp(existing->options->name, options->name) == 0)
            ereport(ERROR,
                    (errmsg("shared memory struct \"%s\" is already registered",
                            options->name)));
    }
 
    /* Request looks valid, remember it */
    request = palloc(sizeof(ShmemRequest));
    request->options = options;
    request->kind = kind;
    pending_shmem_requests = lappend(pending_shmem_requests, request);
}

References elog, ereport, errmsg, ERROR, fb(), foreach_ptr, IsUnderPostmaster, lappend(), palloc(), pending_shmem_requests, pg_nextpower2_size_t, SHMEM_ATTACH_UNKNOWN_SIZE, and SRS_REQUESTING.

Referenced by ShmemRequestHashWithOpts(), ShmemRequestStructWithOpts(), and SimpleLruRequestWithOpts().