dsm_impl.c File Reference

#include "postgres.h"
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include "common/file_perm.h"
#include "libpq/pqsignal.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "portability/mem.h"
#include "postmaster/postmaster.h"
#include "storage/dsm_impl.h"
#include "storage/fd.h"
#include "utils/guc.h"
#include "utils/memutils.h"

Include dependency graph for dsm_impl.c:

Go to the source code of this file.

Macros
#define	ZBUFFER_SIZE   8192
#define	SEGMENT_NAME_PREFIX   "Global/PostgreSQL"

Functions
static bool	dsm_impl_posix (dsm_op op, dsm_handle handle, Size request_size, void **impl_private, void **mapped_address, Size *mapped_size, int elevel)
static int	dsm_impl_posix_resize (int fd, off_t size)
static bool	dsm_impl_sysv (dsm_op op, dsm_handle handle, Size request_size, void **impl_private, void **mapped_address, Size *mapped_size, int elevel)
static bool	dsm_impl_mmap (dsm_op op, dsm_handle handle, Size request_size, void **impl_private, void **mapped_address, Size *mapped_size, int elevel)
static int	errcode_for_dynamic_shared_memory (void)
bool	dsm_impl_op (dsm_op op, dsm_handle handle, Size request_size, void **impl_private, void **mapped_address, Size *mapped_size, int elevel)
void	dsm_impl_pin_segment (dsm_handle handle, void *impl_private, void **impl_private_pm_handle)
void	dsm_impl_unpin_segment (dsm_handle handle, void **impl_private)

Variables
const struct config_enum_entry	dynamic_shared_memory_options []
int	dynamic_shared_memory_type = DEFAULT_DYNAMIC_SHARED_MEMORY_TYPE
int	min_dynamic_shared_memory

Macro Definition Documentation

SEGMENT_NAME_PREFIX

#define SEGMENT_NAME_PREFIX   "Global/PostgreSQL"

Definition at line 120 of file dsm_impl.c.

ZBUFFER_SIZE

#define ZBUFFER_SIZE   8192

Definition at line 118 of file dsm_impl.c.

Function Documentation

dsm_impl_mmap()

static bool dsm_impl_mmap ( dsm_op  op, dsm_handle  handle, Size  request_size, void **  impl_private, void **  mapped_address, Size *  mapped_size, int  elevel  )

static

Definition at line 792 of file dsm_impl.c.

{
    char        name[64];
    int         flags;
    int         fd;
    char       *address;
 
    snprintf(name, 64, PG_DYNSHMEM_DIR "/" PG_DYNSHMEM_MMAP_FILE_PREFIX "%u",
             handle);
 
    /* Handle teardown cases. */
    if (op == DSM_OP_DETACH || op == DSM_OP_DESTROY)
    {
        if (*mapped_address != NULL
            && munmap(*mapped_address, *mapped_size) != 0)
        {
            ereport(elevel,
                    (errcode_for_dynamic_shared_memory(),
                     errmsg("could not unmap shared memory segment \"%s\": %m",
                            name)));
            return false;
        }
        *mapped_address = NULL;
        *mapped_size = 0;
        if (op == DSM_OP_DESTROY && unlink(name) != 0)
        {
            ereport(elevel,
                    (errcode_for_dynamic_shared_memory(),
                     errmsg("could not remove shared memory segment \"%s\": %m",
                            name)));
            return false;
        }
        return true;
    }
 
    /* Create new segment or open an existing one for attach. */
    flags = O_RDWR | (op == DSM_OP_CREATE ? O_CREAT | O_EXCL : 0);
    if ((fd = OpenTransientFile(name, flags)) == -1)
    {
        if (op == DSM_OP_ATTACH || errno != EEXIST)
            ereport(elevel,
                    (errcode_for_dynamic_shared_memory(),
                     errmsg("could not open shared memory segment \"%s\": %m",
                            name)));
        return false;
    }
 
    /*
     * If we're attaching the segment, determine the current size; if we are
     * creating the segment, set the size to the requested value.
     */
    if (op == DSM_OP_ATTACH)
    {
        struct stat st;
 
        if (fstat(fd, &st) != 0)
        {
            int         save_errno;
 
            /* Back out what's already been done. */
            save_errno = errno;
            CloseTransientFile(fd);
            errno = save_errno;
 
            ereport(elevel,
                    (errcode_for_dynamic_shared_memory(),
                     errmsg("could not stat shared memory segment \"%s\": %m",
                            name)));
            return false;
        }
        request_size = st.st_size;
    }
    else
    {
        /*
         * Allocate a buffer full of zeros.
         *
         * Note: palloc zbuffer, instead of just using a local char array, to
         * ensure it is reasonably well-aligned; this may save a few cycles
         * transferring data to the kernel.
         */
        char       *zbuffer = (char *) palloc0(ZBUFFER_SIZE);
        Size        remaining = request_size;
        bool        success = true;
 
        /*
         * Zero-fill the file. We have to do this the hard way to ensure that
         * all the file space has really been allocated, so that we don't
         * later seg fault when accessing the memory mapping.  This is pretty
         * pessimal.
         */
        while (success && remaining > 0)
        {
            Size        goal = remaining;
 
            if (goal > ZBUFFER_SIZE)
                goal = ZBUFFER_SIZE;
            pgstat_report_wait_start(WAIT_EVENT_DSM_FILL_ZERO_WRITE);
            if (write(fd, zbuffer, goal) == goal)
                remaining -= goal;
            else
                success = false;
            pgstat_report_wait_end();
        }
 
        if (!success)
        {
            int         save_errno;
 
            /* Back out what's already been done. */
            save_errno = errno;
            CloseTransientFile(fd);
            unlink(name);
            errno = save_errno ? save_errno : ENOSPC;
 
            ereport(elevel,
                    (errcode_for_dynamic_shared_memory(),
                     errmsg("could not resize shared memory segment \"%s\" to %zu bytes: %m",
                            name, request_size)));
            return false;
        }
    }
 
    /* Map it. */
    address = mmap(NULL, request_size, PROT_READ | PROT_WRITE,
                   MAP_SHARED | MAP_HASSEMAPHORE | MAP_NOSYNC, fd, 0);
    if (address == MAP_FAILED)
    {
        int         save_errno;
 
        /* Back out what's already been done. */
        save_errno = errno;
        CloseTransientFile(fd);
        if (op == DSM_OP_CREATE)
            unlink(name);
        errno = save_errno;
 
        ereport(elevel,
                (errcode_for_dynamic_shared_memory(),
                 errmsg("could not map shared memory segment \"%s\": %m",
                        name)));
        return false;
    }
    *mapped_address = address;
    *mapped_size = request_size;
 
    if (CloseTransientFile(fd) != 0)
    {
        ereport(elevel,
                (errcode_for_file_access(),
                 errmsg("could not close shared memory segment \"%s\": %m",
                        name)));
        return false;
    }
 
    return true;
}

References CloseTransientFile(), DSM_OP_ATTACH, DSM_OP_CREATE, DSM_OP_DESTROY, DSM_OP_DETACH, ereport, errcode_for_dynamic_shared_memory(), errcode_for_file_access(), errmsg(), fd(), fstat, MAP_FAILED, MAP_HASSEMAPHORE, MAP_NOSYNC, name, OpenTransientFile(), palloc0(), PG_DYNSHMEM_DIR, PG_DYNSHMEM_MMAP_FILE_PREFIX, pgstat_report_wait_end(), pgstat_report_wait_start(), remaining, snprintf, stat::st_size, success, write, and ZBUFFER_SIZE.

Referenced by dsm_impl_op().

dsm_impl_op()

bool dsm_impl_op	(	dsm_op	op,
		dsm_handle	handle,
		Size	request_size,
		void **	impl_private,
		void **	mapped_address,
		Size *	mapped_size,
		int	elevel
	)

Definition at line 159 of file dsm_impl.c.

{
    Assert(op == DSM_OP_CREATE || request_size == 0);
    Assert((op != DSM_OP_CREATE && op != DSM_OP_ATTACH) ||
           (*mapped_address == NULL && *mapped_size == 0));
 
    switch (dynamic_shared_memory_type)
    {
#ifdef USE_DSM_POSIX
        case DSM_IMPL_POSIX:
            return dsm_impl_posix(op, handle, request_size, impl_private,
                                  mapped_address, mapped_size, elevel);
#endif
#ifdef USE_DSM_SYSV
        case DSM_IMPL_SYSV:
            return dsm_impl_sysv(op, handle, request_size, impl_private,
                                 mapped_address, mapped_size, elevel);
#endif
#ifdef USE_DSM_WINDOWS
        case DSM_IMPL_WINDOWS:
            return dsm_impl_windows(op, handle, request_size, impl_private,
                                    mapped_address, mapped_size, elevel);
#endif
#ifdef USE_DSM_MMAP
        case DSM_IMPL_MMAP:
            return dsm_impl_mmap(op, handle, request_size, impl_private,
                                 mapped_address, mapped_size, elevel);
#endif
        default:
            elog(ERROR, "unexpected dynamic shared memory type: %d",
                 dynamic_shared_memory_type);
            return false;
    }
}

References Assert(), dsm_impl_mmap(), DSM_IMPL_MMAP, dsm_impl_posix(), DSM_IMPL_POSIX, dsm_impl_sysv(), DSM_IMPL_SYSV, DSM_IMPL_WINDOWS, DSM_OP_ATTACH, DSM_OP_CREATE, dynamic_shared_memory_type, elog, and ERROR.

Referenced by dsm_attach(), dsm_backend_startup(), dsm_cleanup_using_control_segment(), dsm_create(), dsm_detach(), dsm_detach_all(), dsm_postmaster_shutdown(), dsm_postmaster_startup(), and dsm_unpin_segment().

dsm_impl_pin_segment()

void dsm_impl_pin_segment	(	dsm_handle	handle,
		void *	impl_private,
		void **	impl_private_pm_handle
	)

Definition at line 963 of file dsm_impl.c.

{
    switch (dynamic_shared_memory_type)
    {
#ifdef USE_DSM_WINDOWS
        case DSM_IMPL_WINDOWS:
            if (IsUnderPostmaster)
            {
                HANDLE      hmap;
 
                if (!DuplicateHandle(GetCurrentProcess(), impl_private,
                                     PostmasterHandle, &hmap, 0, FALSE,
                                     DUPLICATE_SAME_ACCESS))
                {
                    char        name[64];
 
                    snprintf(name, 64, "%s.%u", SEGMENT_NAME_PREFIX, handle);
                    _dosmaperr(GetLastError());
                    ereport(ERROR,
                            (errcode_for_dynamic_shared_memory(),
                             errmsg("could not duplicate handle for \"%s\": %m",
                                    name)));
                }
 
                /*
                 * Here, we remember the handle that we created in the
                 * postmaster process.  This handle isn't actually usable in
                 * any process other than the postmaster, but that doesn't
                 * matter.  We're just holding onto it so that, if the segment
                 * is unpinned, dsm_impl_unpin_segment can close it.
                 */
                *impl_private_pm_handle = hmap;
            }
            break;
#endif
        default:
            break;
    }
}

References _dosmaperr(), DSM_IMPL_WINDOWS, dynamic_shared_memory_type, ereport, errcode_for_dynamic_shared_memory(), errmsg(), ERROR, IsUnderPostmaster, name, SEGMENT_NAME_PREFIX, and snprintf.

Referenced by dsm_pin_segment().

dsm_impl_posix()

static bool dsm_impl_posix ( dsm_op  op, dsm_handle  handle, Size  request_size, void **  impl_private, void **  mapped_address, Size *  mapped_size, int  elevel  )

static

Definition at line 212 of file dsm_impl.c.

{
    char        name[64];
    int         flags;
    int         fd;
    char       *address;
 
    snprintf(name, 64, "/PostgreSQL.%u", handle);
 
    /* Handle teardown cases. */
    if (op == DSM_OP_DETACH || op == DSM_OP_DESTROY)
    {
        if (*mapped_address != NULL
            && munmap(*mapped_address, *mapped_size) != 0)
        {
            ereport(elevel,
                    (errcode_for_dynamic_shared_memory(),
                     errmsg("could not unmap shared memory segment \"%s\": %m",
                            name)));
            return false;
        }
        *mapped_address = NULL;
        *mapped_size = 0;
        if (op == DSM_OP_DESTROY && shm_unlink(name) != 0)
        {
            ereport(elevel,
                    (errcode_for_dynamic_shared_memory(),
                     errmsg("could not remove shared memory segment \"%s\": %m",
                            name)));
            return false;
        }
        return true;
    }
 
    /*
     * Create new segment or open an existing one for attach.
     *
     * Even though we will close the FD before returning, it seems desirable
     * to use Reserve/ReleaseExternalFD, to reduce the probability of EMFILE
     * failure.  The fact that we won't hold the FD open long justifies using
     * ReserveExternalFD rather than AcquireExternalFD, though.
     */
    ReserveExternalFD();
 
    flags = O_RDWR | (op == DSM_OP_CREATE ? O_CREAT | O_EXCL : 0);
    if ((fd = shm_open(name, flags, PG_FILE_MODE_OWNER)) == -1)
    {
        ReleaseExternalFD();
        if (op == DSM_OP_ATTACH || errno != EEXIST)
            ereport(elevel,
                    (errcode_for_dynamic_shared_memory(),
                     errmsg("could not open shared memory segment \"%s\": %m",
                            name)));
        return false;
    }
 
    /*
     * If we're attaching the segment, determine the current size; if we are
     * creating the segment, set the size to the requested value.
     */
    if (op == DSM_OP_ATTACH)
    {
        struct stat st;
 
        if (fstat(fd, &st) != 0)
        {
            int         save_errno;
 
            /* Back out what's already been done. */
            save_errno = errno;
            close(fd);
            ReleaseExternalFD();
            errno = save_errno;
 
            ereport(elevel,
                    (errcode_for_dynamic_shared_memory(),
                     errmsg("could not stat shared memory segment \"%s\": %m",
                            name)));
            return false;
        }
        request_size = st.st_size;
    }
    else if (dsm_impl_posix_resize(fd, request_size) != 0)
    {
        int         save_errno;
 
        /* Back out what's already been done. */
        save_errno = errno;
        close(fd);
        ReleaseExternalFD();
        shm_unlink(name);
        errno = save_errno;
 
        ereport(elevel,
                (errcode_for_dynamic_shared_memory(),
                 errmsg("could not resize shared memory segment \"%s\" to %zu bytes: %m",
                        name, request_size)));
        return false;
    }
 
    /* Map it. */
    address = mmap(NULL, request_size, PROT_READ | PROT_WRITE,
                   MAP_SHARED | MAP_HASSEMAPHORE | MAP_NOSYNC, fd, 0);
    if (address == MAP_FAILED)
    {
        int         save_errno;
 
        /* Back out what's already been done. */
        save_errno = errno;
        close(fd);
        ReleaseExternalFD();
        if (op == DSM_OP_CREATE)
            shm_unlink(name);
        errno = save_errno;
 
        ereport(elevel,
                (errcode_for_dynamic_shared_memory(),
                 errmsg("could not map shared memory segment \"%s\": %m",
                        name)));
        return false;
    }
    *mapped_address = address;
    *mapped_size = request_size;
    close(fd);
    ReleaseExternalFD();
 
    return true;
}

References close, dsm_impl_posix_resize(), DSM_OP_ATTACH, DSM_OP_CREATE, DSM_OP_DESTROY, DSM_OP_DETACH, ereport, errcode_for_dynamic_shared_memory(), errmsg(), fd(), fstat, MAP_FAILED, MAP_HASSEMAPHORE, MAP_NOSYNC, name, PG_FILE_MODE_OWNER, ReleaseExternalFD(), ReserveExternalFD(), snprintf, and stat::st_size.

Referenced by dsm_impl_op().

dsm_impl_posix_resize()

static int dsm_impl_posix_resize ( int  fd, off_t  size  )

static

Definition at line 351 of file dsm_impl.c.

{
    int         rc;
    int         save_errno;
    sigset_t    save_sigmask;
 
    /*
     * Block all blockable signals, except SIGQUIT.  posix_fallocate() can run
     * for quite a long time, and is an all-or-nothing operation.  If we
     * allowed SIGUSR1 to interrupt us repeatedly (for example, due to
     * recovery conflicts), the retry loop might never succeed.
     */
    if (IsUnderPostmaster)
        sigprocmask(SIG_SETMASK, &BlockSig, &save_sigmask);
 
    pgstat_report_wait_start(WAIT_EVENT_DSM_ALLOCATE);
#if defined(HAVE_POSIX_FALLOCATE) && defined(__linux__)
 
    /*
     * On Linux, a shm_open fd is backed by a tmpfs file.  If we were to use
     * ftruncate, the file would contain a hole.  Accessing memory backed by a
     * hole causes tmpfs to allocate pages, which fails with SIGBUS if there
     * is no more tmpfs space available.  So we ask tmpfs to allocate pages
     * here, so we can fail gracefully with ENOSPC now rather than risking
     * SIGBUS later.
     *
     * We still use a traditional EINTR retry loop to handle SIGCONT.
     * posix_fallocate() doesn't restart automatically, and we don't want this
     * to fail if you attach a debugger.
     */
    do
    {
        rc = posix_fallocate(fd, 0, size);
    } while (rc == EINTR);
 
    /*
     * The caller expects errno to be set, but posix_fallocate() doesn't set
     * it.  Instead it returns error numbers directly.  So set errno, even
     * though we'll also return rc to indicate success or failure.
     */
    errno = rc;
#else
    /* Extend the file to the requested size. */
    do
    {
        rc = ftruncate(fd, size);
    } while (rc < 0 && errno == EINTR);
#endif
    pgstat_report_wait_end();
 
    if (IsUnderPostmaster)
    {
        save_errno = errno;
        sigprocmask(SIG_SETMASK, &save_sigmask, NULL);
        errno = save_errno;
    }
 
    return rc;
}

References BlockSig, EINTR, fd(), IsUnderPostmaster, pgstat_report_wait_end(), and pgstat_report_wait_start().

Referenced by dsm_impl_posix().

dsm_impl_sysv()

static bool dsm_impl_sysv ( dsm_op  op, dsm_handle  handle, Size  request_size, void **  impl_private, void **  mapped_address, Size *  mapped_size, int  elevel  )

static

Definition at line 423 of file dsm_impl.c.

{
    key_t       key;
    int         ident;
    char       *address;
    char        name[64];
    int        *ident_cache;
 
    /*
     * POSIX shared memory and mmap-based shared memory identify segments with
     * names.  To avoid needless error message variation, we use the handle as
     * the name.
     */
    snprintf(name, 64, "%u", handle);
 
    /*
     * The System V shared memory namespace is very restricted; names are of
     * type key_t, which is expected to be some sort of integer data type, but
     * not necessarily the same one as dsm_handle.  Since we use dsm_handle to
     * identify shared memory segments across processes, this might seem like
     * a problem, but it's really not.  If dsm_handle is bigger than key_t,
     * the cast below might truncate away some bits from the handle the
     * user-provided, but it'll truncate exactly the same bits away in exactly
     * the same fashion every time we use that handle, which is all that
     * really matters.  Conversely, if dsm_handle is smaller than key_t, we
     * won't use the full range of available key space, but that's no big deal
     * either.
     *
     * We do make sure that the key isn't negative, because that might not be
     * portable.
     */
    key = (key_t) handle;
    if (key < 1)                /* avoid compiler warning if type is unsigned */
        key = -key;
 
    /*
     * There's one special key, IPC_PRIVATE, which can't be used.  If we end
     * up with that value by chance during a create operation, just pretend it
     * already exists, so that caller will retry.  If we run into it anywhere
     * else, the caller has passed a handle that doesn't correspond to
     * anything we ever created, which should not happen.
     */
    if (key == IPC_PRIVATE)
    {
        if (op != DSM_OP_CREATE)
            elog(DEBUG4, "System V shared memory key may not be IPC_PRIVATE");
        errno = EEXIST;
        return false;
    }
 
    /*
     * Before we can do anything with a shared memory segment, we have to map
     * the shared memory key to a shared memory identifier using shmget(). To
     * avoid repeated lookups, we store the key using impl_private.
     */
    if (*impl_private != NULL)
    {
        ident_cache = *impl_private;
        ident = *ident_cache;
    }
    else
    {
        int         flags = IPCProtection;
        size_t      segsize;
 
        /*
         * Allocate the memory BEFORE acquiring the resource, so that we don't
         * leak the resource if memory allocation fails.
         */
        ident_cache = MemoryContextAlloc(TopMemoryContext, sizeof(int));
 
        /*
         * When using shmget to find an existing segment, we must pass the
         * size as 0.  Passing a non-zero size which is greater than the
         * actual size will result in EINVAL.
         */
        segsize = 0;
 
        if (op == DSM_OP_CREATE)
        {
            flags |= IPC_CREAT | IPC_EXCL;
            segsize = request_size;
        }
 
        if ((ident = shmget(key, segsize, flags)) == -1)
        {
            if (op == DSM_OP_ATTACH || errno != EEXIST)
            {
                int         save_errno = errno;
 
                pfree(ident_cache);
                errno = save_errno;
                ereport(elevel,
                        (errcode_for_dynamic_shared_memory(),
                         errmsg("could not get shared memory segment: %m")));
            }
            return false;
        }
 
        *ident_cache = ident;
        *impl_private = ident_cache;
    }
 
    /* Handle teardown cases. */
    if (op == DSM_OP_DETACH || op == DSM_OP_DESTROY)
    {
        pfree(ident_cache);
        *impl_private = NULL;
        if (*mapped_address != NULL && shmdt(*mapped_address) != 0)
        {
            ereport(elevel,
                    (errcode_for_dynamic_shared_memory(),
                     errmsg("could not unmap shared memory segment \"%s\": %m",
                            name)));
            return false;
        }
        *mapped_address = NULL;
        *mapped_size = 0;
        if (op == DSM_OP_DESTROY && shmctl(ident, IPC_RMID, NULL) < 0)
        {
            ereport(elevel,
                    (errcode_for_dynamic_shared_memory(),
                     errmsg("could not remove shared memory segment \"%s\": %m",
                            name)));
            return false;
        }
        return true;
    }
 
    /* If we're attaching it, we must use IPC_STAT to determine the size. */
    if (op == DSM_OP_ATTACH)
    {
        struct shmid_ds shm;
 
        if (shmctl(ident, IPC_STAT, &shm) != 0)
        {
            ereport(elevel,
                    (errcode_for_dynamic_shared_memory(),
                     errmsg("could not stat shared memory segment \"%s\": %m",
                            name)));
            return false;
        }
        request_size = shm.shm_segsz;
    }
 
    /* Map it. */
    address = shmat(ident, NULL, PG_SHMAT_FLAGS);
    if (address == (void *) -1)
    {
        int         save_errno;
 
        /* Back out what's already been done. */
        save_errno = errno;
        if (op == DSM_OP_CREATE)
            shmctl(ident, IPC_RMID, NULL);
        errno = save_errno;
 
        ereport(elevel,
                (errcode_for_dynamic_shared_memory(),
                 errmsg("could not map shared memory segment \"%s\": %m",
                        name)));
        return false;
    }
    *mapped_address = address;
    *mapped_size = request_size;
 
    return true;
}

References DEBUG4, DSM_OP_ATTACH, DSM_OP_CREATE, DSM_OP_DESTROY, DSM_OP_DETACH, elog, ereport, errcode_for_dynamic_shared_memory(), errmsg(), ident, IPC_CREAT, IPC_EXCL, IPC_PRIVATE, IPC_RMID, IPC_STAT, IPCProtection, sort-test::key, MemoryContextAlloc(), name, pfree(), PG_SHMAT_FLAGS, snprintf, and TopMemoryContext.

Referenced by dsm_impl_op().

dsm_impl_unpin_segment()

void dsm_impl_unpin_segment	(	dsm_handle	handle,
		void **	impl_private
	)

Definition at line 1014 of file dsm_impl.c.

{
    switch (dynamic_shared_memory_type)
    {
#ifdef USE_DSM_WINDOWS
        case DSM_IMPL_WINDOWS:
            if (IsUnderPostmaster)
            {
                if (*impl_private &&
                    !DuplicateHandle(PostmasterHandle, *impl_private,
                                     NULL, NULL, 0, FALSE,
                                     DUPLICATE_CLOSE_SOURCE))
                {
                    char        name[64];
 
                    snprintf(name, 64, "%s.%u", SEGMENT_NAME_PREFIX, handle);
                    _dosmaperr(GetLastError());
                    ereport(ERROR,
                            (errcode_for_dynamic_shared_memory(),
                             errmsg("could not duplicate handle for \"%s\": %m",
                                    name)));
                }
 
                *impl_private = NULL;
            }
            break;
#endif
        default:
            break;
    }
}

References _dosmaperr(), DSM_IMPL_WINDOWS, dynamic_shared_memory_type, ereport, errcode_for_dynamic_shared_memory(), errmsg(), ERROR, IsUnderPostmaster, name, SEGMENT_NAME_PREFIX, and snprintf.

Referenced by dsm_unpin_segment().

errcode_for_dynamic_shared_memory()

static int errcode_for_dynamic_shared_memory ( void  )

static

Definition at line 1047 of file dsm_impl.c.

{
    if (errno == EFBIG || errno == ENOMEM)
        return errcode(ERRCODE_OUT_OF_MEMORY);
    else
        return errcode_for_file_access();
}

References errcode(), and errcode_for_file_access().

Referenced by dsm_impl_mmap(), dsm_impl_pin_segment(), dsm_impl_posix(), dsm_impl_sysv(), and dsm_impl_unpin_segment().

Variable Documentation

dynamic_shared_memory_options

const struct config_enum_entry dynamic_shared_memory_options[]

Initial value:

= {
 
    {"posix", DSM_IMPL_POSIX, false},
 
 
    {"sysv", DSM_IMPL_SYSV, false},
 
 
 
 
 
    {"mmap", DSM_IMPL_MMAP, false},
 
    {NULL, 0, false}
}

Definition at line 95 of file dsm_impl.c.

dynamic_shared_memory_type

int dynamic_shared_memory_type = DEFAULT_DYNAMIC_SHARED_MEMORY_TYPE

Definition at line 112 of file dsm_impl.c.

Referenced by dsm_impl_op(), dsm_impl_pin_segment(), dsm_impl_unpin_segment(), and dsm_postmaster_startup().

min_dynamic_shared_memory

int min_dynamic_shared_memory

Definition at line 115 of file dsm_impl.c.

Referenced by dsm_estimate_size().