dsm.h File Reference

#include "storage/dsm_impl.h"

Include dependency graph for dsm.h:

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

Go to the source code of this file.

Macros
#define	DSM_CREATE_NULL_IF_MAXSEGMENTS   0x0001
#define	DSM_HANDLE_INVALID   0

Typedefs
typedef struct dsm_segment	dsm_segment
typedef void(*	on_dsm_detach_callback) (dsm_segment *, Datum arg)

Functions
void	dsm_cleanup_using_control_segment (dsm_handle old_control_handle)
void	dsm_postmaster_startup (struct PGShmemHeader *)
void	dsm_backend_shutdown (void)
void	dsm_detach_all (void)
size_t	dsm_estimate_size (void)
void	dsm_shmem_init (void)
dsm_segment *	dsm_create (Size size, int flags)
dsm_segment *	dsm_attach (dsm_handle h)
void	dsm_detach (dsm_segment *seg)
void	dsm_pin_mapping (dsm_segment *seg)
void	dsm_unpin_mapping (dsm_segment *seg)
void	dsm_pin_segment (dsm_segment *seg)
void	dsm_unpin_segment (dsm_handle h)
dsm_segment *	dsm_find_mapping (dsm_handle h)
void *	dsm_segment_address (dsm_segment *seg)
Size	dsm_segment_map_length (dsm_segment *seg)
dsm_handle	dsm_segment_handle (dsm_segment *seg)
void	on_dsm_detach (dsm_segment *seg, on_dsm_detach_callback function, Datum arg)
void	cancel_on_dsm_detach (dsm_segment *seg, on_dsm_detach_callback function, Datum arg)
void	reset_on_dsm_detach (void)

Macro Definition Documentation

DSM_CREATE_NULL_IF_MAXSEGMENTS

#define DSM_CREATE_NULL_IF_MAXSEGMENTS   0x0001

Definition at line 20 of file dsm.h.

Referenced by dsm_create(), GetSessionDsmHandle(), and InitializeParallelDSM().

DSM_HANDLE_INVALID

#define DSM_HANDLE_INVALID   0

Definition at line 23 of file dsm.h.

Referenced by apw_load_buffers(), destroy_superblock(), dsa_attach_in_place(), dsa_create_in_place(), dsa_get_handle(), dsa_release_in_place(), dsm_create(), dsm_postmaster_startup(), get_segment_by_index(), GetSessionDsmHandle(), InitializeParallelDSM(), and make_new_segment().

Typedef Documentation

dsm_segment

typedef struct dsm_segment dsm_segment

Definition at line 18 of file dsm.h.

on_dsm_detach_callback

typedef void(* on_dsm_detach_callback) (dsm_segment *, Datum arg)

Definition at line 57 of file dsm.h.

Function Documentation

cancel_on_dsm_detach()

void cancel_on_dsm_detach	(	dsm_segment *	seg,
		on_dsm_detach_callback	function,
		Datum	arg
	)

Definition at line 1111 of file dsm.c.

References dsm_segment_detach_callback::arg, slist_mutable_iter::cur, dsm_segment_detach_callback::function, dsm_segment_detach_callback::node, dsm_segment::on_detach, pfree(), slist_container, slist_delete_current(), and slist_foreach_modify.

Referenced by shm_mq_detach(), and test_shm_mq_setup().

{
    slist_mutable_iter iter;

    slist_foreach_modify(iter, &seg->on_detach)
    {
        dsm_segment_detach_callback *cb;

        cb = slist_container(dsm_segment_detach_callback, node, iter.cur);
        if (cb->function == function && cb->arg == arg)
        {
            slist_delete_current(&iter);
            pfree(cb);
            break;
        }
    }
}

dsm_attach()

dsm_segment* dsm_attach

(

dsm_handle

h

)

Definition at line 631 of file dsm.c.

References Assert, dsm_segment::control_slot, dlist_iter::cur, dlist_container, dlist_foreach, dsm_backend_startup(), dsm_create_descriptor(), dsm_detach(), dsm_impl_op(), dsm_init_done, dsm_main_space_begin, DSM_OP_ATTACH, elog, ERROR, dsm_control_item::first_page, FPM_PAGE_SIZE, dsm_segment::handle, dsm_control_item::handle, i, dsm_segment::impl_private, INVALID_CONTROL_SLOT, is_main_region_dsm_handle(), IsUnderPostmaster, dsm_control_header::item, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), dsm_segment::mapped_address, dsm_segment::mapped_size, dsm_control_header::nitems, dsm_segment_detach_callback::node, dsm_control_item::npages, and dsm_control_item::refcnt.

Referenced by AttachSession(), autoprewarm_database_main(), dsa_attach(), get_segment_by_index(), ParallelWorkerMain(), and test_shm_mq_main().

{
    dsm_segment *seg;
    dlist_iter  iter;
    uint32      i;
    uint32      nitems;

    /* Unsafe in postmaster (and pointless in a stand-alone backend). */
    Assert(IsUnderPostmaster);

    if (!dsm_init_done)
        dsm_backend_startup();

    /*
     * Since this is just a debugging cross-check, we could leave it out
     * altogether, or include it only in assert-enabled builds.  But since the
     * list of attached segments should normally be very short, let's include
     * it always for right now.
     *
     * If you're hitting this error, you probably want to attempt to find an
     * existing mapping via dsm_find_mapping() before calling dsm_attach() to
     * create a new one.
     */
    dlist_foreach(iter, &dsm_segment_list)
    {
        seg = dlist_container(dsm_segment, node, iter.cur);
        if (seg->handle == h)
            elog(ERROR, "can't attach the same segment more than once");
    }

    /* Create a new segment descriptor. */
    seg = dsm_create_descriptor();
    seg->handle = h;

    /* Bump reference count for this segment in shared memory. */
    LWLockAcquire(DynamicSharedMemoryControlLock, LW_EXCLUSIVE);
    nitems = dsm_control->nitems;
    for (i = 0; i < nitems; ++i)
    {
        /*
         * If the reference count is 0, the slot is actually unused.  If the
         * reference count is 1, the slot is still in use, but the segment is
         * in the process of going away; even if the handle matches, another
         * slot may already have started using the same handle value by
         * coincidence so we have to keep searching.
         */
        if (dsm_control->item[i].refcnt <= 1)
            continue;

        /* If the handle doesn't match, it's not the slot we want. */
        if (dsm_control->item[i].handle != seg->handle)
            continue;

        /* Otherwise we've found a match. */
        dsm_control->item[i].refcnt++;
        seg->control_slot = i;
        if (is_main_region_dsm_handle(seg->handle))
        {
            seg->mapped_address = (char *) dsm_main_space_begin +
                dsm_control->item[i].first_page * FPM_PAGE_SIZE;
            seg->mapped_size = dsm_control->item[i].npages * FPM_PAGE_SIZE;
        }
        break;
    }
    LWLockRelease(DynamicSharedMemoryControlLock);

    /*
     * If we didn't find the handle we're looking for in the control segment,
     * it probably means that everyone else who had it mapped, including the
     * original creator, died before we got to this point. It's up to the
     * caller to decide what to do about that.
     */
    if (seg->control_slot == INVALID_CONTROL_SLOT)
    {
        dsm_detach(seg);
        return NULL;
    }

    /* Here's where we actually try to map the segment. */
    if (!is_main_region_dsm_handle(seg->handle))
        dsm_impl_op(DSM_OP_ATTACH, seg->handle, 0, &seg->impl_private,
                    &seg->mapped_address, &seg->mapped_size, ERROR);

    return seg;
}

dsm_backend_shutdown()

void dsm_backend_shutdown

(

void

)

Definition at line 723 of file dsm.c.

References dlist_head_element, dlist_is_empty(), dsm_detach(), and dsm_segment_detach_callback::node.

Referenced by shmem_exit().

{
    while (!dlist_is_empty(&dsm_segment_list))
    {
        dsm_segment *seg;

        seg = dlist_head_element(dsm_segment, node, &dsm_segment_list);
        dsm_detach(seg);
    }
}

dsm_cleanup_using_control_segment()

void dsm_cleanup_using_control_segment

(

dsm_handle

old_control_handle

)

Definition at line 210 of file dsm.c.

References DEBUG1, DEBUG2, dsm_control_segment_sane(), dsm_impl_op(), DSM_OP_ATTACH, DSM_OP_DESTROY, DSM_OP_DETACH, elog, dsm_control_item::handle, i, is_main_region_dsm_handle(), dsm_control_header::item, LOG, dsm_control_header::nitems, and dsm_control_item::refcnt.

Referenced by PGSharedMemoryCreate().

{
    void       *mapped_address = NULL;
    void       *junk_mapped_address = NULL;
    void       *impl_private = NULL;
    void       *junk_impl_private = NULL;
    Size        mapped_size = 0;
    Size        junk_mapped_size = 0;
    uint32      nitems;
    uint32      i;
    dsm_control_header *old_control;

    /*
     * Try to attach the segment.  If this fails, it probably just means that
     * the operating system has been rebooted and the segment no longer
     * exists, or an unrelated process has used the same shm ID.  So just fall
     * out quietly.
     */
    if (!dsm_impl_op(DSM_OP_ATTACH, old_control_handle, 0, &impl_private,
                     &mapped_address, &mapped_size, DEBUG1))
        return;

    /*
     * We've managed to reattach it, but the contents might not be sane. If
     * they aren't, we disregard the segment after all.
     */
    old_control = (dsm_control_header *) mapped_address;
    if (!dsm_control_segment_sane(old_control, mapped_size))
    {
        dsm_impl_op(DSM_OP_DETACH, old_control_handle, 0, &impl_private,
                    &mapped_address, &mapped_size, LOG);
        return;
    }

    /*
     * OK, the control segment looks basically valid, so we can use it to get
     * a list of segments that need to be removed.
     */
    nitems = old_control->nitems;
    for (i = 0; i < nitems; ++i)
    {
        dsm_handle  handle;
        uint32      refcnt;

        /* If the reference count is 0, the slot is actually unused. */
        refcnt = old_control->item[i].refcnt;
        if (refcnt == 0)
            continue;

        /* If it was using the main shmem area, there is nothing to do. */
        handle = old_control->item[i].handle;
        if (is_main_region_dsm_handle(handle))
            continue;

        /* Log debugging information. */
        elog(DEBUG2, "cleaning up orphaned dynamic shared memory with ID %u (reference count %u)",
             handle, refcnt);

        /* Destroy the referenced segment. */
        dsm_impl_op(DSM_OP_DESTROY, handle, 0, &junk_impl_private,
                    &junk_mapped_address, &junk_mapped_size, LOG);
    }

    /* Destroy the old control segment, too. */
    elog(DEBUG2,
         "cleaning up dynamic shared memory control segment with ID %u",
         old_control_handle);
    dsm_impl_op(DSM_OP_DESTROY, old_control_handle, 0, &impl_private,
                &mapped_address, &mapped_size, LOG);
}

dsm_create()

dsm_segment* dsm_create	(	Size	size,
		int	flags
	)

Definition at line 487 of file dsm.c.

References Assert, dsm_segment::control_slot, dlist_delete(), dsm_backend_startup(), dsm_create_descriptor(), DSM_CREATE_NULL_IF_MAXSEGMENTS, DSM_HANDLE_INVALID, dsm_impl_op(), dsm_init_done, dsm_main_space_begin, DSM_OP_CREATE, DSM_OP_DESTROY, ereport, errcode(), errmsg(), ERROR, dsm_control_item::first_page, FPM_PAGE_SIZE, FreePageManagerGet(), FreePageManagerPut(), dsm_segment::handle, dsm_control_item::handle, i, dsm_segment::impl_private, dsm_control_item::impl_private_pm_handle, is_main_region_dsm_handle(), IsUnderPostmaster, dsm_control_header::item, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), make_main_region_dsm_handle(), dsm_segment::mapped_address, dsm_segment::mapped_size, dsm_control_header::maxitems, dsm_control_header::nitems, dsm_segment::node, dsm_control_item::npages, pfree(), dsm_control_item::pinned, random(), dsm_control_item::refcnt, ResourceOwnerForgetDSM(), dsm_segment::resowner, and WARNING.

Referenced by apw_load_buffers(), dsa_create(), GetSessionDsmHandle(), InitializeParallelDSM(), make_new_segment(), and setup_dynamic_shared_memory().

{
    dsm_segment *seg;
    uint32      i;
    uint32      nitems;
    size_t      npages = 0;
    size_t      first_page = 0;
    FreePageManager *dsm_main_space_fpm = dsm_main_space_begin;
    bool        using_main_dsm_region = false;

    /* Unsafe in postmaster (and pointless in a stand-alone backend). */
    Assert(IsUnderPostmaster);

    if (!dsm_init_done)
        dsm_backend_startup();

    /* Create a new segment descriptor. */
    seg = dsm_create_descriptor();

    /*
     * Lock the control segment while we try to allocate from the main shared
     * memory area, if configured.
     */
    if (dsm_main_space_fpm)
    {
        npages = size / FPM_PAGE_SIZE;
        if (size % FPM_PAGE_SIZE > 0)
            ++npages;

        LWLockAcquire(DynamicSharedMemoryControlLock, LW_EXCLUSIVE);
        if (FreePageManagerGet(dsm_main_space_fpm, npages, &first_page))
        {
            /* We can carve out a piece of the main shared memory segment. */
            seg->mapped_address = (char *) dsm_main_space_begin +
                first_page * FPM_PAGE_SIZE;
            seg->mapped_size = npages * FPM_PAGE_SIZE;
            using_main_dsm_region = true;
            /* We'll choose a handle below. */
        }
    }

    if (!using_main_dsm_region)
    {
        /*
         * We need to create a new memory segment.  Loop until we find an
         * unused segment identifier.
         */
        if (dsm_main_space_fpm)
            LWLockRelease(DynamicSharedMemoryControlLock);
        for (;;)
        {
            Assert(seg->mapped_address == NULL && seg->mapped_size == 0);
            seg->handle = random() << 1;    /* Even numbers only */
            if (seg->handle == DSM_HANDLE_INVALID)  /* Reserve sentinel */
                continue;
            if (dsm_impl_op(DSM_OP_CREATE, seg->handle, size, &seg->impl_private,
                            &seg->mapped_address, &seg->mapped_size, ERROR))
                break;
        }
        LWLockAcquire(DynamicSharedMemoryControlLock, LW_EXCLUSIVE);
    }

    /* Search the control segment for an unused slot. */
    nitems = dsm_control->nitems;
    for (i = 0; i < nitems; ++i)
    {
        if (dsm_control->item[i].refcnt == 0)
        {
            if (using_main_dsm_region)
            {
                seg->handle = make_main_region_dsm_handle(i);
                dsm_control->item[i].first_page = first_page;
                dsm_control->item[i].npages = npages;
            }
            else
                Assert(!is_main_region_dsm_handle(seg->handle));
            dsm_control->item[i].handle = seg->handle;
            /* refcnt of 1 triggers destruction, so start at 2 */
            dsm_control->item[i].refcnt = 2;
            dsm_control->item[i].impl_private_pm_handle = NULL;
            dsm_control->item[i].pinned = false;
            seg->control_slot = i;
            LWLockRelease(DynamicSharedMemoryControlLock);
            return seg;
        }
    }

    /* Verify that we can support an additional mapping. */
    if (nitems >= dsm_control->maxitems)
    {
        if (using_main_dsm_region)
            FreePageManagerPut(dsm_main_space_fpm, first_page, npages);
        LWLockRelease(DynamicSharedMemoryControlLock);
        if (!using_main_dsm_region)
            dsm_impl_op(DSM_OP_DESTROY, seg->handle, 0, &seg->impl_private,
                        &seg->mapped_address, &seg->mapped_size, WARNING);
        if (seg->resowner != NULL)
            ResourceOwnerForgetDSM(seg->resowner, seg);
        dlist_delete(&seg->node);
        pfree(seg);

        if ((flags & DSM_CREATE_NULL_IF_MAXSEGMENTS) != 0)
            return NULL;
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_RESOURCES),
                 errmsg("too many dynamic shared memory segments")));
    }

    /* Enter the handle into a new array slot. */
    if (using_main_dsm_region)
    {
        seg->handle = make_main_region_dsm_handle(nitems);
        dsm_control->item[i].first_page = first_page;
        dsm_control->item[i].npages = npages;
    }
    dsm_control->item[nitems].handle = seg->handle;
    /* refcnt of 1 triggers destruction, so start at 2 */
    dsm_control->item[nitems].refcnt = 2;
    dsm_control->item[nitems].impl_private_pm_handle = NULL;
    dsm_control->item[nitems].pinned = false;
    seg->control_slot = nitems;
    dsm_control->nitems++;
    LWLockRelease(DynamicSharedMemoryControlLock);

    return seg;
}

dsm_detach()

void dsm_detach

(

dsm_segment *

seg

)

Definition at line 769 of file dsm.c.

References dsm_segment_detach_callback::arg, Assert, dsm_segment::control_slot, dlist_delete(), dsm_impl_op(), dsm_main_space_begin, DSM_OP_DESTROY, DSM_OP_DETACH, dsm_control_item::first_page, FreePageManagerPut(), dsm_segment_detach_callback::function, dsm_segment::handle, dsm_control_item::handle, HOLD_INTERRUPTS, dsm_segment::impl_private, INVALID_CONTROL_SLOT, is_main_region_dsm_handle(), dsm_control_header::item, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), dsm_segment::mapped_address, dsm_segment::mapped_size, dsm_segment_detach_callback::node, dsm_segment::node, dsm_control_item::npages, dsm_segment::on_detach, pfree(), dsm_control_item::pinned, dsm_control_item::refcnt, ResourceOwnerForgetDSM(), dsm_segment::resowner, RESUME_INTERRUPTS, slist_container, slist_is_empty(), slist_pop_head_node(), and WARNING.

Referenced by apw_load_buffers(), autoprewarm_database_main(), check_for_freed_segments_locked(), destroy_superblock(), DestroyParallelContext(), DetachSession(), dsa_detach(), dsm_attach(), dsm_backend_shutdown(), dsm_detach_all(), ResourceOwnerReleaseInternal(), test_shm_mq(), test_shm_mq_main(), and test_shm_mq_pipelined().

{
    /*
     * Invoke registered callbacks.  Just in case one of those callbacks
     * throws a further error that brings us back here, pop the callback
     * before invoking it, to avoid infinite error recursion.  Don't allow
     * interrupts while running the individual callbacks in non-error code
     * paths, to avoid leaving cleanup work unfinished if we're interrupted by
     * a statement timeout or similar.
     */
    HOLD_INTERRUPTS();
    while (!slist_is_empty(&seg->on_detach))
    {
        slist_node *node;
        dsm_segment_detach_callback *cb;
        on_dsm_detach_callback function;
        Datum       arg;

        node = slist_pop_head_node(&seg->on_detach);
        cb = slist_container(dsm_segment_detach_callback, node, node);
        function = cb->function;
        arg = cb->arg;
        pfree(cb);

        function(seg, arg);
    }
    RESUME_INTERRUPTS();

    /*
     * Try to remove the mapping, if one exists.  Normally, there will be, but
     * maybe not, if we failed partway through a create or attach operation.
     * We remove the mapping before decrementing the reference count so that
     * the process that sees a zero reference count can be certain that no
     * remaining mappings exist.  Even if this fails, we pretend that it
     * works, because retrying is likely to fail in the same way.
     */
    if (seg->mapped_address != NULL)
    {
        if (!is_main_region_dsm_handle(seg->handle))
            dsm_impl_op(DSM_OP_DETACH, seg->handle, 0, &seg->impl_private,
                        &seg->mapped_address, &seg->mapped_size, WARNING);
        seg->impl_private = NULL;
        seg->mapped_address = NULL;
        seg->mapped_size = 0;
    }

    /* Reduce reference count, if we previously increased it. */
    if (seg->control_slot != INVALID_CONTROL_SLOT)
    {
        uint32      refcnt;
        uint32      control_slot = seg->control_slot;

        LWLockAcquire(DynamicSharedMemoryControlLock, LW_EXCLUSIVE);
        Assert(dsm_control->item[control_slot].handle == seg->handle);
        Assert(dsm_control->item[control_slot].refcnt > 1);
        refcnt = --dsm_control->item[control_slot].refcnt;
        seg->control_slot = INVALID_CONTROL_SLOT;
        LWLockRelease(DynamicSharedMemoryControlLock);

        /* If new reference count is 1, try to destroy the segment. */
        if (refcnt == 1)
        {
            /* A pinned segment should never reach 1. */
            Assert(!dsm_control->item[control_slot].pinned);

            /*
             * If we fail to destroy the segment here, or are killed before we
             * finish doing so, the reference count will remain at 1, which
             * will mean that nobody else can attach to the segment.  At
             * postmaster shutdown time, or when a new postmaster is started
             * after a hard kill, another attempt will be made to remove the
             * segment.
             *
             * The main case we're worried about here is being killed by a
             * signal before we can finish removing the segment.  In that
             * case, it's important to be sure that the segment still gets
             * removed. If we actually fail to remove the segment for some
             * other reason, the postmaster may not have any better luck than
             * we did.  There's not much we can do about that, though.
             */
            if (is_main_region_dsm_handle(seg->handle) ||
                dsm_impl_op(DSM_OP_DESTROY, seg->handle, 0, &seg->impl_private,
                            &seg->mapped_address, &seg->mapped_size, WARNING))
            {
                LWLockAcquire(DynamicSharedMemoryControlLock, LW_EXCLUSIVE);
                if (is_main_region_dsm_handle(seg->handle))
                    FreePageManagerPut((FreePageManager *) dsm_main_space_begin,
                                       dsm_control->item[control_slot].first_page,
                                       dsm_control->item[control_slot].npages);
                Assert(dsm_control->item[control_slot].handle == seg->handle);
                Assert(dsm_control->item[control_slot].refcnt == 1);
                dsm_control->item[control_slot].refcnt = 0;
                LWLockRelease(DynamicSharedMemoryControlLock);
            }
        }
    }

    /* Clean up our remaining backend-private data structures. */
    if (seg->resowner != NULL)
        ResourceOwnerForgetDSM(seg->resowner, seg);
    dlist_delete(&seg->node);
    pfree(seg);
}

dsm_detach_all()

void dsm_detach_all

(

void

)

Definition at line 741 of file dsm.c.

References dlist_head_element, dlist_is_empty(), dsm_control, dsm_control_handle, dsm_control_impl_private, dsm_control_mapped_size, dsm_detach(), dsm_impl_op(), DSM_OP_DETACH, ERROR, and dsm_segment_detach_callback::node.

Referenced by pgarch_start(), pgstat_start(), StartBackgroundWorker(), and SysLogger_Start().

{
    void       *control_address = dsm_control;

    while (!dlist_is_empty(&dsm_segment_list))
    {
        dsm_segment *seg;

        seg = dlist_head_element(dsm_segment, node, &dsm_segment_list);
        dsm_detach(seg);
    }

    if (control_address != NULL)
        dsm_impl_op(DSM_OP_DETACH, dsm_control_handle, 0,
                    &dsm_control_impl_private, &control_address,
                    &dsm_control_mapped_size, ERROR);
}

dsm_estimate_size()

size_t dsm_estimate_size

(

void

)

Definition at line 441 of file dsm.c.

References min_dynamic_shared_memory.

Referenced by CreateSharedMemoryAndSemaphores(), and dsm_shmem_init().

{
    return 1024 * 1024 * (size_t) min_dynamic_shared_memory;
}

dsm_find_mapping()

dsm_segment* dsm_find_mapping

(

dsm_handle

h

)

Definition at line 1040 of file dsm.c.

References dlist_iter::cur, dlist_container, dlist_foreach, dsm_segment::handle, and dsm_segment_detach_callback::node.

{
    dlist_iter  iter;
    dsm_segment *seg;

    dlist_foreach(iter, &dsm_segment_list)
    {
        seg = dlist_container(dsm_segment, node, iter.cur);
        if (seg->handle == h)
            return seg;
    }

    return NULL;
}

dsm_pin_mapping()

void dsm_pin_mapping

(

dsm_segment *

seg

)

Definition at line 881 of file dsm.c.

References ResourceOwnerForgetDSM(), and dsm_segment::resowner.

Referenced by AttachSession(), dsa_pin_mapping(), get_segment_by_index(), GetSessionDsmHandle(), and make_new_segment().

{
    if (seg->resowner != NULL)
    {
        ResourceOwnerForgetDSM(seg->resowner, seg);
        seg->resowner = NULL;
    }
}

dsm_pin_segment()

void dsm_pin_segment

(

dsm_segment *

seg

)

Definition at line 921 of file dsm.c.

References dsm_segment::control_slot, dsm_impl_pin_segment(), elog, ERROR, dsm_segment::handle, dsm_segment::impl_private, dsm_control_item::impl_private_pm_handle, dsm_control_header::item, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), dsm_control_item::pinned, and dsm_control_item::refcnt.

Referenced by dsa_create(), and make_new_segment().

{
    void       *handle;

    /*
     * Bump reference count for this segment in shared memory. This will
     * ensure that even if there is no session which is attached to this
     * segment, it will remain until postmaster shutdown or an explicit call
     * to unpin.
     */
    LWLockAcquire(DynamicSharedMemoryControlLock, LW_EXCLUSIVE);
    if (dsm_control->item[seg->control_slot].pinned)
        elog(ERROR, "cannot pin a segment that is already pinned");
    dsm_impl_pin_segment(seg->handle, seg->impl_private, &handle);
    dsm_control->item[seg->control_slot].pinned = true;
    dsm_control->item[seg->control_slot].refcnt++;
    dsm_control->item[seg->control_slot].impl_private_pm_handle = handle;
    LWLockRelease(DynamicSharedMemoryControlLock);
}

dsm_postmaster_startup()

void dsm_postmaster_startup

(

struct PGShmemHeader *

)

Definition at line 149 of file dsm.c.

References Assert, DEBUG2, dsm_cleanup_for_mmap(), PGShmemHeader::dsm_control, dsm_control_bytes_needed(), dsm_control_handle, dsm_control_impl_private, dsm_control_mapped_size, DSM_HANDLE_INVALID, DSM_IMPL_MMAP, dsm_impl_op(), DSM_OP_CREATE, dsm_postmaster_shutdown(), dynamic_shared_memory_type, elog, ERROR, IsUnderPostmaster, dsm_control_header::magic, MaxBackends, dsm_control_header::maxitems, dsm_control_header::nitems, on_shmem_exit(), PG_DYNSHMEM_CONTROL_MAGIC, PG_DYNSHMEM_FIXED_SLOTS, PG_DYNSHMEM_SLOTS_PER_BACKEND, PointerGetDatum, and random().

Referenced by CreateSharedMemoryAndSemaphores().

{
    void       *dsm_control_address = NULL;
    uint32      maxitems;
    Size        segsize;

    Assert(!IsUnderPostmaster);

    /*
     * If we're using the mmap implementations, clean up any leftovers.
     * Cleanup isn't needed on Windows, and happens earlier in startup for
     * POSIX and System V shared memory, via a direct call to
     * dsm_cleanup_using_control_segment.
     */
    if (dynamic_shared_memory_type == DSM_IMPL_MMAP)
        dsm_cleanup_for_mmap();

    /* Determine size for new control segment. */
    maxitems = PG_DYNSHMEM_FIXED_SLOTS
        + PG_DYNSHMEM_SLOTS_PER_BACKEND * MaxBackends;
    elog(DEBUG2, "dynamic shared memory system will support %u segments",
         maxitems);
    segsize = dsm_control_bytes_needed(maxitems);

    /*
     * Loop until we find an unused identifier for the new control segment. We
     * sometimes use 0 as a sentinel value indicating that no control segment
     * is known to exist, so avoid using that value for a real control
     * segment.
     */
    for (;;)
    {
        Assert(dsm_control_address == NULL);
        Assert(dsm_control_mapped_size == 0);
        dsm_control_handle = random() << 1; /* Even numbers only */
        if (dsm_control_handle == DSM_HANDLE_INVALID)
            continue;
        if (dsm_impl_op(DSM_OP_CREATE, dsm_control_handle, segsize,
                        &dsm_control_impl_private, &dsm_control_address,
                        &dsm_control_mapped_size, ERROR))
            break;
    }
    dsm_control = dsm_control_address;
    on_shmem_exit(dsm_postmaster_shutdown, PointerGetDatum(shim));
    elog(DEBUG2,
         "created dynamic shared memory control segment %u (%zu bytes)",
         dsm_control_handle, segsize);
    shim->dsm_control = dsm_control_handle;

    /* Initialize control segment. */
    dsm_control->magic = PG_DYNSHMEM_CONTROL_MAGIC;
    dsm_control->nitems = 0;
    dsm_control->maxitems = maxitems;
}

dsm_segment_address()

void* dsm_segment_address

(

dsm_segment *

seg

)

Definition at line 1059 of file dsm.c.

References Assert, and dsm_segment::mapped_address.

Referenced by apw_load_buffers(), AttachSession(), autoprewarm_database_main(), dsa_attach(), dsa_create(), get_segment_by_index(), GetSessionDsmHandle(), InitializeParallelDSM(), make_new_segment(), ParallelWorkerMain(), setup_dynamic_shared_memory(), and test_shm_mq_main().

{
    Assert(seg->mapped_address != NULL);
    return seg->mapped_address;
}

dsm_segment_handle()

dsm_handle dsm_segment_handle

(

dsm_segment *

seg

)

Definition at line 1087 of file dsm.c.

References dsm_segment::handle.

Referenced by apw_load_buffers(), destroy_superblock(), dsa_create(), GetSessionDsmHandle(), LaunchParallelWorkers(), make_new_segment(), PrintDSMLeakWarning(), ResourceOwnerForgetDSM(), and setup_background_workers().

{
    return seg->handle;
}

dsm_segment_map_length()

Size dsm_segment_map_length

(

dsm_segment *

seg

)

Definition at line 1069 of file dsm.c.

References Assert, dsm_segment::mapped_address, and dsm_segment::mapped_size.

{
    Assert(seg->mapped_address != NULL);
    return seg->mapped_size;
}

dsm_shmem_init()

void dsm_shmem_init

(

void

)

Definition at line 450 of file dsm.c.

References dsm_estimate_size(), dsm_main_space_begin, FPM_PAGE_SIZE, FreePageManagerInitialize(), FreePageManagerPut(), and ShmemInitStruct().

Referenced by CreateSharedMemoryAndSemaphores().

{
    size_t      size = dsm_estimate_size();
    bool        found;

    if (size == 0)
        return;

    dsm_main_space_begin = ShmemInitStruct("Preallocated DSM", size, &found);
    if (!found)
    {
        FreePageManager *fpm = (FreePageManager *) dsm_main_space_begin;
        size_t      first_page = 0;
        size_t      pages;

        /* Reserve space for the FreePageManager. */
        while (first_page * FPM_PAGE_SIZE < sizeof(FreePageManager))
            ++first_page;

        /* Initialize it and give it all the rest of the space. */
        FreePageManagerInitialize(fpm, dsm_main_space_begin);
        pages = (size / FPM_PAGE_SIZE) - first_page;
        FreePageManagerPut(fpm, first_page, pages);
    }
}

dsm_unpin_mapping()

void dsm_unpin_mapping

(

dsm_segment *

seg

)

Definition at line 900 of file dsm.c.

References Assert, CurrentResourceOwner, ResourceOwnerEnlargeDSMs(), ResourceOwnerRememberDSM(), and dsm_segment::resowner.

{
    Assert(seg->resowner == NULL);
    ResourceOwnerEnlargeDSMs(CurrentResourceOwner);
    seg->resowner = CurrentResourceOwner;
    ResourceOwnerRememberDSM(seg->resowner, seg);
}

dsm_unpin_segment()

void dsm_unpin_segment

(

dsm_handle

h

)

Definition at line 953 of file dsm.c.

References Assert, dsm_impl_op(), dsm_impl_unpin_segment(), dsm_main_space_begin, DSM_OP_DESTROY, elog, ERROR, dsm_control_item::first_page, FreePageManagerPut(), dsm_control_item::handle, i, dsm_control_item::impl_private_pm_handle, INVALID_CONTROL_SLOT, is_main_region_dsm_handle(), dsm_control_header::item, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), dsm_control_header::nitems, dsm_control_item::npages, dsm_control_item::pinned, dsm_control_item::refcnt, and WARNING.

Referenced by destroy_superblock(), and dsa_release_in_place().

{
    uint32      control_slot = INVALID_CONTROL_SLOT;
    bool        destroy = false;
    uint32      i;

    /* Find the control slot for the given handle. */
    LWLockAcquire(DynamicSharedMemoryControlLock, LW_EXCLUSIVE);
    for (i = 0; i < dsm_control->nitems; ++i)
    {
        /* Skip unused slots and segments that are concurrently going away. */
        if (dsm_control->item[i].refcnt <= 1)
            continue;

        /* If we've found our handle, we can stop searching. */
        if (dsm_control->item[i].handle == handle)
        {
            control_slot = i;
            break;
        }
    }

    /*
     * We should definitely have found the slot, and it should not already be
     * in the process of going away, because this function should only be
     * called on a segment which is pinned.
     */
    if (control_slot == INVALID_CONTROL_SLOT)
        elog(ERROR, "cannot unpin unknown segment handle");
    if (!dsm_control->item[control_slot].pinned)
        elog(ERROR, "cannot unpin a segment that is not pinned");
    Assert(dsm_control->item[control_slot].refcnt > 1);

    /*
     * Allow implementation-specific code to run.  We have to do this before
     * releasing the lock, because impl_private_pm_handle may get modified by
     * dsm_impl_unpin_segment.
     */
    dsm_impl_unpin_segment(handle,
                           &dsm_control->item[control_slot].impl_private_pm_handle);

    /* Note that 1 means no references (0 means unused slot). */
    if (--dsm_control->item[control_slot].refcnt == 1)
        destroy = true;
    dsm_control->item[control_slot].pinned = false;

    /* Now we can release the lock. */
    LWLockRelease(DynamicSharedMemoryControlLock);

    /* Clean up resources if that was the last reference. */
    if (destroy)
    {
        void       *junk_impl_private = NULL;
        void       *junk_mapped_address = NULL;
        Size        junk_mapped_size = 0;

        /*
         * For an explanation of how error handling works in this case, see
         * comments in dsm_detach.  Note that if we reach this point, the
         * current process certainly does not have the segment mapped, because
         * if it did, the reference count would have still been greater than 1
         * even after releasing the reference count held by the pin.  The fact
         * that there can't be a dsm_segment for this handle makes it OK to
         * pass the mapped size, mapped address, and private data as NULL
         * here.
         */
        if (is_main_region_dsm_handle(handle) ||
            dsm_impl_op(DSM_OP_DESTROY, handle, 0, &junk_impl_private,
                        &junk_mapped_address, &junk_mapped_size, WARNING))
        {
            LWLockAcquire(DynamicSharedMemoryControlLock, LW_EXCLUSIVE);
            if (is_main_region_dsm_handle(handle))
                FreePageManagerPut((FreePageManager *) dsm_main_space_begin,
                                   dsm_control->item[control_slot].first_page,
                                   dsm_control->item[control_slot].npages);
            Assert(dsm_control->item[control_slot].handle == handle);
            Assert(dsm_control->item[control_slot].refcnt == 1);
            dsm_control->item[control_slot].refcnt = 0;
            LWLockRelease(DynamicSharedMemoryControlLock);
        }
    }
}

on_dsm_detach()

void on_dsm_detach	(	dsm_segment *	seg,
		on_dsm_detach_callback	function,
		Datum	arg
	)

Definition at line 1096 of file dsm.c.

References dsm_segment_detach_callback::arg, dsm_segment_detach_callback::function, MemoryContextAlloc(), dsm_segment_detach_callback::node, dsm_segment::on_detach, slist_push_head(), and TopMemoryContext.

Referenced by dsa_attach(), dsa_attach_in_place(), dsa_create(), dsa_create_in_place(), pq_redirect_to_shm_mq(), setup_background_workers(), SharedFileSetAttach(), SharedFileSetInit(), SharedRecordTypmodRegistryAttach(), SharedRecordTypmodRegistryInit(), and shm_mq_attach().

{
    dsm_segment_detach_callback *cb;

    cb = MemoryContextAlloc(TopMemoryContext,
                            sizeof(dsm_segment_detach_callback));
    cb->function = function;
    cb->arg = arg;
    slist_push_head(&seg->on_detach, &cb->node);
}

reset_on_dsm_detach()

void reset_on_dsm_detach

(

void

)

Definition at line 1134 of file dsm.c.

References dsm_segment::control_slot, dlist_iter::cur, dlist_container, dlist_foreach, INVALID_CONTROL_SLOT, dsm_segment_detach_callback::node, dsm_segment::on_detach, pfree(), slist_container, slist_is_empty(), and slist_pop_head_node().

Referenced by on_exit_reset().

{
    dlist_iter  iter;

    dlist_foreach(iter, &dsm_segment_list)
    {
        dsm_segment *seg = dlist_container(dsm_segment, node, iter.cur);

        /* Throw away explicit on-detach actions one by one. */
        while (!slist_is_empty(&seg->on_detach))
        {
            slist_node *node;
            dsm_segment_detach_callback *cb;

            node = slist_pop_head_node(&seg->on_detach);
            cb = slist_container(dsm_segment_detach_callback, node, node);
            pfree(cb);
        }

        /*
         * Decrementing the reference count is a sort of implicit on-detach
         * action; make sure we don't do that, either.
         */
        seg->control_slot = INVALID_CONTROL_SLOT;
    }
}