diff options
Diffstat (limited to 'src/backend/port/sysv_shmem.c')
| -rw-r--r-- | src/backend/port/sysv_shmem.c | 400 |
1 files changed, 400 insertions, 0 deletions
diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c new file mode 100644 index 00000000000..41d5bdd374c --- /dev/null +++ b/src/backend/port/sysv_shmem.c @@ -0,0 +1,400 @@ +/*------------------------------------------------------------------------- + * + * sysv_shmem.c + * Implement shared memory using SysV facilities + * + * These routines represent a fairly thin layer on top of SysV shared + * memory functionality. + * + * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * IDENTIFICATION + * $Header: /cvsroot/pgsql/src/backend/port/sysv_shmem.c,v 1.1 2002/05/05 00:03:28 tgl Exp $ + * + *------------------------------------------------------------------------- + */ +#include "postgres.h" + +#include <errno.h> +#include <signal.h> +#include <unistd.h> +#include <sys/file.h> +#include <sys/types.h> +#ifdef HAVE_SYS_IPC_H +#include <sys/ipc.h> +#endif +#ifdef HAVE_SYS_SHM_H +#include <sys/shm.h> +#endif +#ifdef HAVE_KERNEL_OS_H +#include <kernel/OS.h> +#endif + +#include "miscadmin.h" +#include "storage/ipc.h" +#include "storage/pg_shmem.h" + + +typedef uint32 IpcMemoryKey; /* shared memory key passed to shmget(2) */ +typedef int IpcMemoryId; /* shared memory ID returned by shmget(2) */ + +#define IPCProtection (0600) /* access/modify by user only */ + + +static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, uint32 size); +static void IpcMemoryDetach(int status, Datum shmaddr); +static void IpcMemoryDelete(int status, Datum shmId); +static void *PrivateMemoryCreate(uint32 size); +static void PrivateMemoryDelete(int status, Datum memaddr); + + +/* + * InternalIpcMemoryCreate(memKey, size) + * + * Attempt to create a new shared memory segment with the specified key. + * Will fail (return NULL) if such a segment already exists. If successful, + * attach the segment to the current process and return its attached address. + * On success, callbacks are registered with on_shmem_exit to detach and + * delete the segment when on_shmem_exit is called. + * + * If we fail with a failure code other than collision-with-existing-segment, + * print out an error and abort. Other types of errors are not recoverable. + */ +static void * +InternalIpcMemoryCreate(IpcMemoryKey memKey, uint32 size) +{ + IpcMemoryId shmid; + void *memAddress; + + shmid = shmget(memKey, size, IPC_CREAT | IPC_EXCL | IPCProtection); + + if (shmid < 0) + { + /* + * Fail quietly if error indicates a collision with existing + * segment. One would expect EEXIST, given that we said IPC_EXCL, + * but perhaps we could get a permission violation instead? Also, + * EIDRM might occur if an old seg is slated for destruction but + * not gone yet. + */ + if (errno == EEXIST || errno == EACCES +#ifdef EIDRM + || errno == EIDRM +#endif + ) + return NULL; + + /* + * Else complain and abort + */ + fprintf(stderr, "IpcMemoryCreate: shmget(key=%d, size=%u, 0%o) failed: %s\n", + (int) memKey, size, (IPC_CREAT | IPC_EXCL | IPCProtection), + strerror(errno)); + + if (errno == EINVAL) + fprintf(stderr, + "\nThis error usually means that PostgreSQL's request for a shared memory\n" + "segment exceeded your kernel's SHMMAX parameter. You can either\n" + "reduce the request size or reconfigure the kernel with larger SHMMAX.\n" + "To reduce the request size (currently %u bytes), reduce\n" + "PostgreSQL's shared_buffers parameter (currently %d) and/or\n" + "its max_connections parameter (currently %d).\n" + "\n" + "If the request size is already small, it's possible that it is less than\n" + "your kernel's SHMMIN parameter, in which case raising the request size or\n" + "reconfiguring SHMMIN is called for.\n" + "\n" + "The PostgreSQL Administrator's Guide contains more information about\n" + "shared memory configuration.\n\n", + size, NBuffers, MaxBackends); + + else if (errno == ENOMEM) + fprintf(stderr, + "\nThis error usually means that PostgreSQL's request for a shared\n" + "memory segment exceeded available memory or swap space.\n" + "To reduce the request size (currently %u bytes), reduce\n" + "PostgreSQL's shared_buffers parameter (currently %d) and/or\n" + "its max_connections parameter (currently %d).\n" + "\n" + "The PostgreSQL Administrator's Guide contains more information about\n" + "shared memory configuration.\n\n", + size, NBuffers, MaxBackends); + + else if (errno == ENOSPC) + fprintf(stderr, + "\nThis error does *not* mean that you have run out of disk space.\n" + "\n" + "It occurs either if all available shared memory IDs have been taken,\n" + "in which case you need to raise the SHMMNI parameter in your kernel,\n" + "or because the system's overall limit for shared memory has been\n" + "reached. If you cannot increase the shared memory limit,\n" + "reduce PostgreSQL's shared memory request (currently %u bytes),\n" + "by reducing its shared_buffers parameter (currently %d) and/or\n" + "its max_connections parameter (currently %d).\n" + "\n" + "The PostgreSQL Administrator's Guide contains more information about\n" + "shared memory configuration.\n\n", + size, NBuffers, MaxBackends); + + proc_exit(1); + } + + /* Register on-exit routine to delete the new segment */ + on_shmem_exit(IpcMemoryDelete, Int32GetDatum(shmid)); + + /* OK, should be able to attach to the segment */ +#if defined(solaris) && defined(__sparc__) + /* use intimate shared memory on SPARC Solaris */ + memAddress = shmat(shmid, 0, SHM_SHARE_MMU); +#else + memAddress = shmat(shmid, 0, 0); +#endif + + if (memAddress == (void *) -1) + { + fprintf(stderr, "IpcMemoryCreate: shmat(id=%d) failed: %s\n", + shmid, strerror(errno)); + proc_exit(1); + } + + /* Register on-exit routine to detach new segment before deleting */ + on_shmem_exit(IpcMemoryDetach, PointerGetDatum(memAddress)); + + /* Record key and ID in lockfile for data directory. */ + RecordSharedMemoryInLockFile((unsigned long) memKey, + (unsigned long) shmid); + + return memAddress; +} + +/****************************************************************************/ +/* IpcMemoryDetach(status, shmaddr) removes a shared memory segment */ +/* from process' address spaceq */ +/* (called as an on_shmem_exit callback, hence funny argument list) */ +/****************************************************************************/ +static void +IpcMemoryDetach(int status, Datum shmaddr) +{ + if (shmdt(DatumGetPointer(shmaddr)) < 0) + fprintf(stderr, "IpcMemoryDetach: shmdt(%p) failed: %s\n", + DatumGetPointer(shmaddr), strerror(errno)); + + /* + * We used to report a failure via elog(WARNING), but that's pretty + * pointless considering any client has long since disconnected ... + */ +} + +/****************************************************************************/ +/* IpcMemoryDelete(status, shmId) deletes a shared memory segment */ +/* (called as an on_shmem_exit callback, hence funny argument list) */ +/****************************************************************************/ +static void +IpcMemoryDelete(int status, Datum shmId) +{ + if (shmctl(DatumGetInt32(shmId), IPC_RMID, (struct shmid_ds *) NULL) < 0) + fprintf(stderr, "IpcMemoryDelete: shmctl(%d, %d, 0) failed: %s\n", + DatumGetInt32(shmId), IPC_RMID, strerror(errno)); + + /* + * We used to report a failure via elog(WARNING), but that's pretty + * pointless considering any client has long since disconnected ... + */ +} + +/* + * PGSharedMemoryIsInUse + * + * Is a previously-existing shmem segment still existing and in use? + */ +bool +PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2) +{ + IpcMemoryId shmId = (IpcMemoryId) id2; + struct shmid_ds shmStat; + + /* + * We detect whether a shared memory segment is in use by seeing + * whether it (a) exists and (b) has any processes are attached to it. + * + * If we are unable to perform the stat operation for a reason other than + * nonexistence of the segment (most likely, because it doesn't belong + * to our userid), assume it is in use. + */ + if (shmctl(shmId, IPC_STAT, &shmStat) < 0) + { + /* + * EINVAL actually has multiple possible causes documented in the + * shmctl man page, but we assume it must mean the segment no + * longer exists. + */ + if (errno == EINVAL) + return false; + /* Else assume segment is in use */ + return true; + } + /* If it has attached processes, it's in use */ + if (shmStat.shm_nattch != 0) + return true; + return false; +} + + +/* ---------------------------------------------------------------- + * private memory support + * + * Rather than allocating shmem segments with IPC_PRIVATE key, we + * just malloc() the requested amount of space. This code emulates + * the needed shmem functions. + * ---------------------------------------------------------------- + */ + +static void * +PrivateMemoryCreate(uint32 size) +{ + void *memAddress; + + memAddress = malloc(size); + if (!memAddress) + { + fprintf(stderr, "PrivateMemoryCreate: malloc(%u) failed\n", size); + proc_exit(1); + } + MemSet(memAddress, 0, size); /* keep Purify quiet */ + + /* Register on-exit routine to release storage */ + on_shmem_exit(PrivateMemoryDelete, PointerGetDatum(memAddress)); + + return memAddress; +} + +static void +PrivateMemoryDelete(int status, Datum memaddr) +{ + free(DatumGetPointer(memaddr)); +} + + +/* + * PGSharedMemoryCreate + * + * Create a shared memory segment of the given size and initialize its + * standard header. Also, register an on_shmem_exit callback to release + * the storage. + * + * Dead Postgres segments are recycled if found, but we do not fail upon + * collision with non-Postgres shmem segments. The idea here is to detect and + * re-use keys that may have been assigned by a crashed postmaster or backend. + * + * The port number is passed for possible use as a key (for SysV, we use + * it to generate the starting shmem key). In a standalone backend, + * zero will be passed. + */ +PGShmemHeader * +PGSharedMemoryCreate(uint32 size, bool makePrivate, int port) +{ + IpcMemoryKey NextShmemSegID; + void *memAddress; + PGShmemHeader *hdr; + + /* Room for a header? */ + Assert(size > MAXALIGN(sizeof(PGShmemHeader))); + + /* Loop till we find a free IPC key */ + NextShmemSegID = port * 1000; + + for (NextShmemSegID++;; NextShmemSegID++) + { + IpcMemoryId shmid; + + /* Special case if creating a private segment --- just malloc() it */ + if (makePrivate) + { + memAddress = PrivateMemoryCreate(size); + break; + } + + /* Try to create new segment */ + memAddress = InternalIpcMemoryCreate(NextShmemSegID, size); + if (memAddress) + break; /* successful create and attach */ + + /* See if it looks to be leftover from a dead Postgres process */ + shmid = shmget(NextShmemSegID, sizeof(PGShmemHeader), 0); + if (shmid < 0) + continue; /* failed: must be some other app's */ + +#if defined(solaris) && defined(__sparc__) + /* use intimate shared memory on SPARC Solaris */ + memAddress = shmat(shmid, 0, SHM_SHARE_MMU); +#else + memAddress = shmat(shmid, 0, 0); +#endif + + if (memAddress == (void *) -1) + continue; /* failed: must be some other app's */ + hdr = (PGShmemHeader *) memAddress; + if (hdr->magic != PGShmemMagic) + { + shmdt(memAddress); + continue; /* segment belongs to a non-Postgres app */ + } + + /* + * If the creator PID is my own PID or does not belong to any + * extant process, it's safe to zap it. + */ + if (hdr->creatorPID != getpid()) + { + if (kill(hdr->creatorPID, 0) == 0 || + errno != ESRCH) + { + shmdt(memAddress); + continue; /* segment belongs to a live process */ + } + } + + /* + * The segment appears to be from a dead Postgres process, or from + * a previous cycle of life in this same process. Zap it, if + * possible. This probably shouldn't fail, but if it does, assume + * the segment belongs to someone else after all, and continue + * quietly. + */ + shmdt(memAddress); + if (shmctl(shmid, IPC_RMID, (struct shmid_ds *) NULL) < 0) + continue; + + /* + * Now try again to create the segment. + */ + memAddress = InternalIpcMemoryCreate(NextShmemSegID, size); + if (memAddress) + break; /* successful create and attach */ + + /* + * Can only get here if some other process managed to create the + * same shmem key before we did. Let him have that one, loop + * around to try next key. + */ + } + + /* + * OK, we created a new segment. Mark it as created by this process. + * The order of assignments here is critical so that another Postgres + * process can't see the header as valid but belonging to an invalid + * PID! + */ + hdr = (PGShmemHeader *) memAddress; + hdr->creatorPID = getpid(); + hdr->magic = PGShmemMagic; + + /* + * Initialize space allocation status for segment. + */ + hdr->totalsize = size; + hdr->freeoffset = MAXALIGN(sizeof(PGShmemHeader)); + + return hdr; +} |