Create an internal semaphore API that is not tied to SysV semaphores.

As proof of concept, provide an alternate implementation based on POSIX
semaphores.  Also push the SysV shared-memory implementation into a
separate file so that it can be replaced conveniently.

1 files changed, 7 insertions, 805 deletions

diff --git a/src/backend/storage/ipc/ipc.c b/src/backend/storage/ipc/ipc.c
index 10d3d6e7edb..fad78835416 100644
--- a/src/backend/storage/ipc/ipc.c
+++ b/src/backend/storage/ipc/ipc.c
@@ -3,25 +3,17 @@
  * ipc.c
  *	  POSTGRES inter-process communication definitions.
  *
+ * This file is misnamed, as it no longer has much of anything directly
+ * to do with IPC.  The functionality here is concerned with managing
+ * exit-time cleanup for either a postmaster or a backend.
+ *
+ *
  * 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/storage/ipc/ipc.c,v 1.78 2002/04/13 19:52:51 momjian Exp $
- *
- * NOTES
- *
- *	  Currently, semaphores are used (my understanding anyway) in two
- *	  different ways:
- *		1. as mutexes on machines that don't have test-and-set (eg.
- *		   mips R3000).
- *		2. for putting processes to sleep when waiting on a lock
- *		   and waking them up when the lock is free.
- *	  The number of semaphores in (1) is fixed and those are shared
- *	  among all backends. In (2), there is 1 semaphore per process and those
- *	  are not shared with anyone else.
- *														  -ay 4/95
+ *	  $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipc.c,v 1.79 2002/05/05 00:03:28 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -30,27 +22,9 @@
 #include <errno.h>
 #include <signal.h>
 #include <unistd.h>
-#include <sys/file.h>
-
-#include "storage/ipc.h"
-/* In Ultrix, sem.h and shm.h must be included AFTER ipc.h */
-#ifdef HAVE_SYS_SEM_H
-#include <sys/sem.h>
-#endif
-#ifdef HAVE_SYS_SHM_H
-#include <sys/shm.h>
-#endif
-#ifdef HAVE_KERNEL_OS_H
-#include <kernel/OS.h>
-#endif
-
-#if defined(__darwin__)
-#include "port/darwin/sem.h"
-#endif
 
 #include "miscadmin.h"
-#include "utils/memutils.h"
-#include "libpq/libpq.h"
+#include "storage/ipc.h"
 
 
 /*
@@ -60,17 +34,6 @@
  */
 bool		proc_exit_inprogress = false;
 
-static IpcSemaphoreId InternalIpcSemaphoreCreate(IpcSemaphoreKey semKey,
-						   int numSems, int permission,
-						   int semStartValue, bool removeOnExit);
-static void CallbackSemaphoreKill(int status, Datum semId);
-static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, uint32 size,
-						int permission);
-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);
-
 
 /* ----------------------------------------------------------------
  *						exit() handling stuff
@@ -83,8 +46,6 @@ static void PrivateMemoryDelete(int status, Datum memaddr);
  * Callback functions can take zero, one, or two args: the first passed
  * arg is the integer exitcode, the second is the Datum supplied when
  * the callback was registered.
- *
- * XXX these functions probably ought to live in some other module.
  * ----------------------------------------------------------------
  */
 
@@ -230,762 +191,3 @@ on_exit_reset(void)
 	on_shmem_exit_index = 0;
 	on_proc_exit_index = 0;
 }
-
-
-/* ----------------------------------------------------------------
- *						Semaphore support
- *
- * These routines represent a fairly thin layer on top of SysV semaphore
- * functionality.
- * ----------------------------------------------------------------
- */
-
-/* ----------------------------------------------------------------
- *	InternalIpcSemaphoreCreate(semKey, numSems, permission,
- *							   semStartValue, removeOnExit)
- *
- * Attempt to create a new semaphore set with the specified key.
- * Will fail (return -1) if such a set already exists.
- * On success, a callback is optionally registered with on_shmem_exit
- * to delete the semaphore set when on_shmem_exit is called.
- *
- * If we fail with a failure code other than collision-with-existing-set,
- * print out an error and abort.  Other types of errors are not recoverable.
- * ----------------------------------------------------------------
- */
-static IpcSemaphoreId
-InternalIpcSemaphoreCreate(IpcSemaphoreKey semKey,
-						   int numSems, int permission,
-						   int semStartValue, bool removeOnExit)
-{
-	int			semId;
-	int			i;
-	u_short		array[IPC_NMAXSEM];
-	union semun semun;
-
-	Assert(numSems > 0 && numSems <= IPC_NMAXSEM);
-
-	semId = semget(semKey, numSems, IPC_CREAT | IPC_EXCL | permission);
-
-	if (semId < 0)
-	{
-		/*
-		 * Fail quietly if error indicates a collision with existing set.
-		 * 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 set is slated for destruction but
-		 * not gone yet.
-		 */
-		if (errno == EEXIST || errno == EACCES
-#ifdef EIDRM
-			|| errno == EIDRM
-#endif
-			)
-			return -1;
-
-		/*
-		 * Else complain and abort
-		 */
-		fprintf(stderr, "IpcSemaphoreCreate: semget(key=%d, num=%d, 0%o) failed: %s\n",
-			  (int) semKey, numSems, (IPC_CREAT | IPC_EXCL | permission),
-				strerror(errno));
-
-		if (errno == ENOSPC)
-			fprintf(stderr,
-					"\nThis error does *not* mean that you have run out of disk space.\n"
-					"\n"
-					"It occurs when either the system limit for the maximum number of\n"
-					"semaphore sets (SEMMNI), or the system wide maximum number of\n"
-					"semaphores (SEMMNS), would be exceeded.  You need to raise the\n"
-					"respective kernel parameter.  Alternatively, reduce PostgreSQL's\n"
-					"consumption of semaphores by reducing its max_connections parameter\n"
-					"(currently %d).\n"
-					"\n"
-					"The PostgreSQL Administrator's Guide contains more information about\n"
-					"configuring your system for PostgreSQL.\n\n",
-					MaxBackends);
-
-		proc_exit(1);
-	}
-
-	/* Initialize new semas to specified start value */
-	for (i = 0; i < numSems; i++)
-		array[i] = semStartValue;
-	semun.array = array;
-	if (semctl(semId, 0, SETALL, semun) < 0)
-	{
-		fprintf(stderr, "IpcSemaphoreCreate: semctl(id=%d, 0, SETALL, ...) failed: %s\n",
-				semId, strerror(errno));
-
-		if (errno == ERANGE)
-			fprintf(stderr,
-					"You possibly need to raise your kernel's SEMVMX value to be at least\n"
-			"%d.  Look into the PostgreSQL documentation for details.\n",
-					semStartValue);
-
-		IpcSemaphoreKill(semId);
-		proc_exit(1);
-	}
-
-	/* Register on-exit routine to delete the new set */
-	if (removeOnExit)
-		on_shmem_exit(CallbackSemaphoreKill, Int32GetDatum(semId));
-
-	return semId;
-}
-
-/****************************************************************************/
-/*	 IpcSemaphoreKill(semId)	- removes a semaphore set					*/
-/*																			*/
-/****************************************************************************/
-void
-IpcSemaphoreKill(IpcSemaphoreId semId)
-{
-	union semun semun;
-
-	semun.val = 0;				/* unused, but keep compiler quiet */
-
-	if (semctl(semId, 0, IPC_RMID, semun) < 0)
-		fprintf(stderr, "IpcSemaphoreKill: semctl(%d, 0, IPC_RMID, ...) failed: %s\n",
-				semId, strerror(errno));
-
-	/*
-	 * We used to report a failure via elog(WARNING), but that's pretty
-	 * pointless considering any client has long since disconnected ...
-	 */
-}
-
-/****************************************************************************/
-/*	 CallbackSemaphoreKill(status, semId)									*/
-/*	(called as an on_shmem_exit callback, hence funny argument list)		*/
-/****************************************************************************/
-static void
-CallbackSemaphoreKill(int status, Datum semId)
-{
-	IpcSemaphoreKill(DatumGetInt32(semId));
-}
-
-/****************************************************************************/
-/*	 IpcSemaphoreLock(semId, sem) - locks a semaphore						*/
-/****************************************************************************/
-void
-IpcSemaphoreLock(IpcSemaphoreId semId, int sem, bool interruptOK)
-{
-	int			errStatus;
-	struct sembuf sops;
-
-	sops.sem_op = -1;			/* decrement */
-	sops.sem_flg = 0;
-	sops.sem_num = sem;
-
-	/*
-	 * Note: if errStatus is -1 and errno == EINTR then it means we
-	 * returned from the operation prematurely because we were sent a
-	 * signal.	So we try and lock the semaphore again.
-	 *
-	 * Each time around the loop, we check for a cancel/die interrupt. We
-	 * assume that if such an interrupt comes in while we are waiting, it
-	 * will cause the semop() call to exit with errno == EINTR, so that we
-	 * will be able to service the interrupt (if not in a critical section
-	 * already).
-	 *
-	 * Once we acquire the lock, we do NOT check for an interrupt before
-	 * returning.  The caller needs to be able to record ownership of the
-	 * lock before any interrupt can be accepted.
-	 *
-	 * There is a window of a few instructions between CHECK_FOR_INTERRUPTS
-	 * and entering the semop() call.  If a cancel/die interrupt occurs in
-	 * that window, we would fail to notice it until after we acquire the
-	 * lock (or get another interrupt to escape the semop()).  We can
-	 * avoid this problem by temporarily setting ImmediateInterruptOK to
-	 * true before we do CHECK_FOR_INTERRUPTS; then, a die() interrupt in
-	 * this interval will execute directly.  However, there is a huge
-	 * pitfall: there is another window of a few instructions after the
-	 * semop() before we are able to reset ImmediateInterruptOK.  If an
-	 * interrupt occurs then, we'll lose control, which means that the
-	 * lock has been acquired but our caller did not get a chance to
-	 * record the fact. Therefore, we only set ImmediateInterruptOK if the
-	 * caller tells us it's OK to do so, ie, the caller does not need to
-	 * record acquiring the lock.  (This is currently true for lockmanager
-	 * locks, since the process that granted us the lock did all the
-	 * necessary state updates. It's not true for SysV semaphores used to
-	 * implement LW locks or emulate spinlocks --- but the wait time for
-	 * such locks should not be very long, anyway.)
-	 */
-	do
-	{
-		ImmediateInterruptOK = interruptOK;
-		CHECK_FOR_INTERRUPTS();
-		errStatus = semop(semId, &sops, 1);
-		ImmediateInterruptOK = false;
-	} while (errStatus == -1 && errno == EINTR);
-
-	if (errStatus == -1)
-	{
-		fprintf(stderr, "IpcSemaphoreLock: semop(id=%d) failed: %s\n",
-				semId, strerror(errno));
-		proc_exit(255);
-	}
-}
-
-/****************************************************************************/
-/*	 IpcSemaphoreUnlock(semId, sem)		- unlocks a semaphore				*/
-/****************************************************************************/
-void
-IpcSemaphoreUnlock(IpcSemaphoreId semId, int sem)
-{
-	int			errStatus;
-	struct sembuf sops;
-
-	sops.sem_op = 1;			/* increment */
-	sops.sem_flg = 0;
-	sops.sem_num = sem;
-
-
-	/*
-	 * Note: if errStatus is -1 and errno == EINTR then it means we
-	 * returned from the operation prematurely because we were sent a
-	 * signal.	So we try and unlock the semaphore again. Not clear this
-	 * can really happen, but might as well cope.
-	 */
-	do
-	{
-		errStatus = semop(semId, &sops, 1);
-	} while (errStatus == -1 && errno == EINTR);
-
-	if (errStatus == -1)
-	{
-		fprintf(stderr, "IpcSemaphoreUnlock: semop(id=%d) failed: %s\n",
-				semId, strerror(errno));
-		proc_exit(255);
-	}
-}
-
-/****************************************************************************/
-/*	 IpcSemaphoreTryLock(semId, sem)	- conditionally locks a semaphore	*/
-/* Lock the semaphore if it's free, but don't block.						*/
-/****************************************************************************/
-bool
-IpcSemaphoreTryLock(IpcSemaphoreId semId, int sem)
-{
-	int			errStatus;
-	struct sembuf sops;
-
-	sops.sem_op = -1;			/* decrement */
-	sops.sem_flg = IPC_NOWAIT;	/* but don't block */
-	sops.sem_num = sem;
-
-	/*
-	 * Note: if errStatus is -1 and errno == EINTR then it means we
-	 * returned from the operation prematurely because we were sent a
-	 * signal.	So we try and lock the semaphore again.
-	 */
-	do
-	{
-		errStatus = semop(semId, &sops, 1);
-	} while (errStatus == -1 && errno == EINTR);
-
-	if (errStatus == -1)
-	{
-		/* Expect EAGAIN or EWOULDBLOCK (platform-dependent) */
-#ifdef EAGAIN
-		if (errno == EAGAIN)
-			return false;		/* failed to lock it */
-#endif
-#if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
-		if (errno == EWOULDBLOCK)
-			return false;		/* failed to lock it */
-#endif
-		/* Otherwise we got trouble */
-		fprintf(stderr, "IpcSemaphoreTryLock: semop(id=%d) failed: %s\n",
-				semId, strerror(errno));
-		proc_exit(255);
-	}
-
-	return true;
-}
-
-/* Get the current value (semval) of the semaphore */
-int
-IpcSemaphoreGetValue(IpcSemaphoreId semId, int sem)
-{
-	union semun dummy;			/* for Solaris */
-
-	dummy.val = 0;				/* unused */
-
-	return semctl(semId, sem, GETVAL, dummy);
-}
-
-/* Get the PID of the last process to do semop() on the semaphore */
-static pid_t
-IpcSemaphoreGetLastPID(IpcSemaphoreId semId, int sem)
-{
-	union semun dummy;			/* for Solaris */
-
-	dummy.val = 0;				/* unused */
-
-	return semctl(semId, sem, GETPID, dummy);
-}
-
-
-/* ----------------------------------------------------------------
- *						Shared memory support
- *
- * These routines represent a fairly thin layer on top of SysV shared
- * memory functionality.
- * ----------------------------------------------------------------
- */
-
-/* ----------------------------------------------------------------
- *	InternalIpcMemoryCreate(memKey, size, permission)
- *
- * 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, int permission)
-{
-	IpcMemoryId shmid;
-	void	   *memAddress;
-
-	shmid = shmget(memKey, size, IPC_CREAT | IPC_EXCL | permission);
-
-	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 | permission),
-				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(memKey, 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 ...
-	 */
-}
-
-/****************************************************************************/
-/*	SharedMemoryIsInUse(shmKey, shmId)	Is a shared memory segment in use?	*/
-/****************************************************************************/
-bool
-SharedMemoryIsInUse(IpcMemoryKey shmKey, IpcMemoryId shmId)
-{
-	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));
-}
-
-
-/* ------------------
- *				Routines to assign keys for new IPC objects
- *
- * The idea here is to detect and re-use keys that may have been assigned
- * by a crashed postmaster or backend.
- * ------------------
- */
-
-static IpcMemoryKey NextShmemSegID = 0;
-static IpcSemaphoreKey NextSemaID = 0;
-
-/*
- * (Re) initialize key assignment at startup of postmaster or standalone
- * backend, also at postmaster reset.
- */
-void
-IpcInitKeyAssignment(int port)
-{
-	NextShmemSegID = port * 1000;
-	NextSemaID = port * 1000;
-}
-
-/*
- * Create a shared memory segment of the given size and initialize its
- * standard header.  Dead Postgres segments are recycled if found,
- * but we do not fail upon collision with non-Postgres shmem segments.
- */
-PGShmemHeader *
-IpcMemoryCreate(uint32 size, bool makePrivate, int permission)
-{
-	void	   *memAddress;
-	PGShmemHeader *hdr;
-
-	/* Room for a header? */
-	Assert(size > MAXALIGN(sizeof(PGShmemHeader)));
-
-	/* Loop till we find a free IPC key */
-	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, permission);
-		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, permission);
-		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;
-}
-
-/*
- * Create a semaphore set with the given number of useful semaphores
- * (an additional sema is actually allocated to serve as identifier).
- * Dead Postgres sema sets are recycled if found, but we do not fail
- * upon collision with non-Postgres sema sets.
- */
-IpcSemaphoreId
-IpcSemaphoreCreate(int numSems, int permission,
-				   int semStartValue, bool removeOnExit)
-{
-	IpcSemaphoreId semId;
-	union semun semun;
-
-	/* Loop till we find a free IPC key */
-	for (NextSemaID++;; NextSemaID++)
-	{
-		pid_t		creatorPID;
-
-		/* Try to create new semaphore set */
-		semId = InternalIpcSemaphoreCreate(NextSemaID, numSems + 1,
-										   permission, semStartValue,
-										   removeOnExit);
-		if (semId >= 0)
-			break;				/* successful create */
-
-		/* See if it looks to be leftover from a dead Postgres process */
-		semId = semget(NextSemaID, numSems + 1, 0);
-		if (semId < 0)
-			continue;			/* failed: must be some other app's */
-		if (IpcSemaphoreGetValue(semId, numSems) != PGSemaMagic)
-			continue;			/* sema 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.
-		 */
-		creatorPID = IpcSemaphoreGetLastPID(semId, numSems);
-		if (creatorPID <= 0)
-			continue;			/* oops, GETPID failed */
-		if (creatorPID != getpid())
-		{
-			if (kill(creatorPID, 0) == 0 ||
-				errno != ESRCH)
-				continue;		/* sema belongs to a live process */
-		}
-
-		/*
-		 * The sema set 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 sema set belongs to someone else after all, and continue
-		 * quietly.
-		 */
-		semun.val = 0;			/* unused, but keep compiler quiet */
-		if (semctl(semId, 0, IPC_RMID, semun) < 0)
-			continue;
-
-		/*
-		 * Now try again to create the sema set.
-		 */
-		semId = InternalIpcSemaphoreCreate(NextSemaID, numSems + 1,
-										   permission, semStartValue,
-										   removeOnExit);
-		if (semId >= 0)
-			break;				/* successful create */
-
-		/*
-		 * Can only get here if some other process managed to create the
-		 * same sema key before we did.  Let him have that one, loop
-		 * around to try next key.
-		 */
-	}
-
-	/*
-	 * OK, we created a new sema set.  Mark it as created by this process.
-	 * We do this by setting the spare semaphore to PGSemaMagic-1 and then
-	 * incrementing it with semop().  That leaves it with value
-	 * PGSemaMagic and sempid referencing this process.
-	 */
-	semun.val = PGSemaMagic - 1;
-	if (semctl(semId, numSems, SETVAL, semun) < 0)
-	{
-		fprintf(stderr, "IpcSemaphoreCreate: semctl(id=%d, %d, SETVAL, %d) failed: %s\n",
-				semId, numSems, PGSemaMagic - 1, strerror(errno));
-
-		if (errno == ERANGE)
-			fprintf(stderr,
-					"You possibly need to raise your kernel's SEMVMX value to be at least\n"
-			"%d.  Look into the PostgreSQL documentation for details.\n",
-					PGSemaMagic);
-
-		proc_exit(1);
-	}
-	IpcSemaphoreUnlock(semId, numSems);
-
-	return semId;
-}