New package.

1 files changed, 751 insertions, 0 deletions

diff --git a/0003-Disable-shm.patch b/0003-Disable-shm.patch
new file mode 100644
index 000000000000..a5bcb44368d3
--- /dev/null
+++ b/0003-Disable-shm.patch
@@ -0,0 +1,751 @@
+--- a/src/backend/port/sysv_shmem.c
++++ b/src/backend/port/sysv_shmem.c
+@@ -119,161 +119,7 @@
+ static void *
+ InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size)
+ {
+-	IpcMemoryId shmid;
+-	void	   *requestedAddress = NULL;
+-	void	   *memAddress;
+-
+-	/*
+-	 * Normally we just pass requestedAddress = NULL to shmat(), allowing the
+-	 * system to choose where the segment gets mapped.  But in an EXEC_BACKEND
+-	 * build, it's possible for whatever is chosen in the postmaster to not
+-	 * work for backends, due to variations in address space layout.  As a
+-	 * rather klugy workaround, allow the user to specify the address to use
+-	 * via setting the environment variable PG_SHMEM_ADDR.  (If this were of
+-	 * interest for anything except debugging, we'd probably create a cleaner
+-	 * and better-documented way to set it, such as a GUC.)
+-	 */
+-#ifdef EXEC_BACKEND
+-	{
+-		char	   *pg_shmem_addr = getenv("PG_SHMEM_ADDR");
+-
+-		if (pg_shmem_addr)
+-			requestedAddress = (void *) strtoul(pg_shmem_addr, NULL, 0);
+-		else
+-		{
+-#if defined(__darwin__) && SIZEOF_VOID_P == 8
+-			/*
+-			 * Provide a default value that is believed to avoid problems with
+-			 * ASLR on the current macOS release.
+-			 */
+-			requestedAddress = (void *) 0x80000000000;
+-#endif
+-		}
+-	}
+-#endif
+-
+-	shmid = shmget(memKey, size, IPC_CREAT | IPC_EXCL | IPCProtection);
+-
+-	if (shmid < 0)
+-	{
+-		int			shmget_errno = errno;
+-
+-		/*
+-		 * 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 (shmget_errno == EEXIST || shmget_errno == EACCES
+-#ifdef EIDRM
+-			|| shmget_errno == EIDRM
+-#endif
+-			)
+-			return NULL;
+-
+-		/*
+-		 * Some BSD-derived kernels are known to return EINVAL, not EEXIST, if
+-		 * there is an existing segment but it's smaller than "size" (this is
+-		 * a result of poorly-thought-out ordering of error tests). To
+-		 * distinguish between collision and invalid size in such cases, we
+-		 * make a second try with size = 0.  These kernels do not test size
+-		 * against SHMMIN in the preexisting-segment case, so we will not get
+-		 * EINVAL a second time if there is such a segment.
+-		 */
+-		if (shmget_errno == EINVAL)
+-		{
+-			shmid = shmget(memKey, 0, IPC_CREAT | IPC_EXCL | IPCProtection);
+-
+-			if (shmid < 0)
+-			{
+-				/* As above, fail quietly if we verify a collision */
+-				if (errno == EEXIST || errno == EACCES
+-#ifdef EIDRM
+-					|| errno == EIDRM
+-#endif
+-					)
+ 					return NULL;
+-				/* Otherwise, fall through to report the original error */
+-			}
+-			else
+-			{
+-				/*
+-				 * On most platforms we cannot get here because SHMMIN is
+-				 * greater than zero.  However, if we do succeed in creating a
+-				 * zero-size segment, free it and then fall through to report
+-				 * the original error.
+-				 */
+-				if (shmctl(shmid, IPC_RMID, NULL) < 0)
+-					elog(LOG, "shmctl(%d, %d, 0) failed: %m",
+-						 (int) shmid, IPC_RMID);
+-			}
+-		}
+-
+-		/*
+-		 * Else complain and abort.
+-		 *
+-		 * Note: at this point EINVAL should mean that either SHMMIN or SHMMAX
+-		 * is violated.  SHMALL violation might be reported as either ENOMEM
+-		 * (BSDen) or ENOSPC (Linux); the Single Unix Spec fails to say which
+-		 * it should be.  SHMMNI violation is ENOSPC, per spec.  Just plain
+-		 * not-enough-RAM is ENOMEM.
+-		 */
+-		errno = shmget_errno;
+-		ereport(FATAL,
+-				(errmsg("could not create shared memory segment: %m"),
+-				 errdetail("Failed system call was shmget(key=%lu, size=%zu, 0%o).",
+-						   (unsigned long) memKey, size,
+-						   IPC_CREAT | IPC_EXCL | IPCProtection),
+-				 (shmget_errno == EINVAL) ?
+-				 errhint("This error usually means that PostgreSQL's request for a shared memory "
+-						 "segment exceeded your kernel's SHMMAX parameter, or possibly that "
+-						 "it is less than "
+-						 "your kernel's SHMMIN parameter.\n"
+-						 "The PostgreSQL documentation contains more information about shared "
+-						 "memory configuration.") : 0,
+-				 (shmget_errno == ENOMEM) ?
+-				 errhint("This error usually means that PostgreSQL's request for a shared "
+-						 "memory segment exceeded your kernel's SHMALL parameter.  You might need "
+-						 "to reconfigure the kernel with larger SHMALL.\n"
+-						 "The PostgreSQL documentation contains more information about shared "
+-						 "memory configuration.") : 0,
+-				 (shmget_errno == ENOSPC) ?
+-				 errhint("This error does *not* mean that you have run out of disk space.  "
+-						 "It occurs either if all available shared memory IDs have been taken, "
+-						 "in which case you need to raise the SHMMNI parameter in your kernel, "
+-						 "or because the system's overall limit for shared memory has been "
+-						 "reached.\n"
+-						 "The PostgreSQL documentation contains more information about shared "
+-						 "memory configuration.") : 0));
+-	}
+-
+-	/* Register on-exit routine to delete the new segment */
+-	on_shmem_exit(IpcMemoryDelete, Int32GetDatum(shmid));
+-
+-	/* OK, should be able to attach to the segment */
+-	memAddress = shmat(shmid, requestedAddress, PG_SHMAT_FLAGS);
+-
+-	if (memAddress == (void *) -1)
+-		elog(FATAL, "shmat(id=%d, addr=%p, flags=0x%x) failed: %m",
+-			 shmid, requestedAddress, PG_SHMAT_FLAGS);
+-
+-	/* Register on-exit routine to detach new segment before deleting */
+-	on_shmem_exit(IpcMemoryDetach, PointerGetDatum(memAddress));
+-
+-	/*
+-	 * Store shmem key and ID in data directory lockfile.  Format to try to
+-	 * keep it the same length always (trailing junk in the lockfile won't
+-	 * hurt, but might confuse humans).
+-	 */
+-	{
+-		char		line[64];
+-
+-		sprintf(line, "%9lu %9lu",
+-				(unsigned long) memKey, (unsigned long) shmid);
+-		AddToDataDirLockFile(LOCK_FILE_LINE_SHMEM_KEY, line);
+-	}
+-
+-	return memAddress;
+ }
+ 
+ /****************************************************************************/
+@@ -285,7 +131,6 @@
+ IpcMemoryDetach(int status, Datum shmaddr)
+ {
+ 	/* Detach System V shared memory block. */
+-	if (shmdt((void *) DatumGetPointer(shmaddr)) < 0)
+ 		elog(LOG, "shmdt(%p) failed: %m", DatumGetPointer(shmaddr));
+ }
+ 
+@@ -296,7 +141,6 @@
+ static void
+ IpcMemoryDelete(int status, Datum shmId)
+ {
+-	if (shmctl(DatumGetInt32(shmId), IPC_RMID, NULL) < 0)
+ 		elog(LOG, "shmctl(%d, %d, 0) failed: %m",
+ 			 DatumGetInt32(shmId), IPC_RMID);
+ }
+@@ -315,23 +159,8 @@
+ bool
+ PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2)
+ {
+-	PGShmemHeader *memAddress;
+-	IpcMemoryState state;
+-
+-	state = PGSharedMemoryAttach((IpcMemoryId) id2, NULL, &memAddress);
+-	if (memAddress && shmdt((void *) memAddress) < 0)
+-		elog(LOG, "shmdt(%p) failed: %m", memAddress);
+-	switch (state)
+-	{
+-		case SHMSTATE_ENOENT:
+-		case SHMSTATE_FOREIGN:
+-		case SHMSTATE_UNATTACHED:
++	elog(LOG, "shmdt(%p) failed: %m", NULL);
+ 			return false;
+-		case SHMSTATE_ANALYSIS_FAILURE:
+-		case SHMSTATE_ATTACHED:
+-			return true;
+-	}
+-	return true;
+ }
+ 
+ /*
+@@ -347,109 +176,9 @@
+ 					 void *attachAt,
+ 					 PGShmemHeader **addr)
+ {
+-	struct shmid_ds shmStat;
+-	struct stat statbuf;
+-	PGShmemHeader *hdr;
+-
+ 	*addr = NULL;
+ 
+-	/*
+-	 * First, try to stat the shm segment ID, to see if it exists at all.
+-	 */
+-	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 SHMSTATE_ENOENT;
+-
+-		/*
+-		 * EACCES implies we have no read permission, which means it is not a
+-		 * Postgres shmem segment (or at least, not one that is relevant to
+-		 * our data directory).
+-		 */
+-		if (errno == EACCES)
+ 			return SHMSTATE_FOREIGN;
+-
+-		/*
+-		 * Some Linux kernel versions (in fact, all of them as of July 2007)
+-		 * sometimes return EIDRM when EINVAL is correct.  The Linux kernel
+-		 * actually does not have any internal state that would justify
+-		 * returning EIDRM, so we can get away with assuming that EIDRM is
+-		 * equivalent to EINVAL on that platform.
+-		 */
+-#ifdef HAVE_LINUX_EIDRM_BUG
+-		if (errno == EIDRM)
+-			return SHMSTATE_ENOENT;
+-#endif
+-
+-		/*
+-		 * Otherwise, we had better assume that the segment is in use.  The
+-		 * only likely case is (non-Linux, assumed spec-compliant) EIDRM,
+-		 * which implies that the segment has been IPC_RMID'd but there are
+-		 * still processes attached to it.
+-		 */
+-		return SHMSTATE_ANALYSIS_FAILURE;
+-	}
+-
+-	/*
+-	 * Try to attach to the segment and see if it matches our data directory.
+-	 * This avoids any risk of duplicate-shmem-key conflicts on machines that
+-	 * are running several postmasters under the same userid.
+-	 *
+-	 * (When we're called from PGSharedMemoryCreate, this stat call is
+-	 * duplicative; but since this isn't a high-traffic case it's not worth
+-	 * trying to optimize.)
+-	 */
+-	if (stat(DataDir, &statbuf) < 0)
+-		return SHMSTATE_ANALYSIS_FAILURE;	/* can't stat; be conservative */
+-
+-	hdr = (PGShmemHeader *) shmat(shmId, attachAt, PG_SHMAT_FLAGS);
+-	if (hdr == (PGShmemHeader *) -1)
+-	{
+-		/*
+-		 * Attachment failed.  The cases we're interested in are the same as
+-		 * for the shmctl() call above.  In particular, note that the owning
+-		 * postmaster could have terminated and removed the segment between
+-		 * shmctl() and shmat().
+-		 *
+-		 * If attachAt isn't NULL, it's possible that EINVAL reflects a
+-		 * problem with that address not a vanished segment, so it's best to
+-		 * pass NULL when probing for conflicting segments.
+-		 */
+-		if (errno == EINVAL)
+-			return SHMSTATE_ENOENT; /* segment disappeared */
+-		if (errno == EACCES)
+-			return SHMSTATE_FOREIGN;	/* must be non-Postgres */
+-#ifdef HAVE_LINUX_EIDRM_BUG
+-		if (errno == EIDRM)
+-			return SHMSTATE_ENOENT; /* segment disappeared */
+-#endif
+-		/* Otherwise, be conservative. */
+-		return SHMSTATE_ANALYSIS_FAILURE;
+-	}
+-	*addr = hdr;
+-
+-	if (hdr->magic != PGShmemMagic ||
+-		hdr->device != statbuf.st_dev ||
+-		hdr->inode != statbuf.st_ino)
+-	{
+-		/*
+-		 * It's either not a Postgres segment, or not one for my data
+-		 * directory.
+-		 */
+-		return SHMSTATE_FOREIGN;
+-	}
+-
+-	/*
+-	 * It does match our data directory, so now test whether any processes are
+-	 * still attached to it.  (We are, now, but the shm_nattch result is from
+-	 * before we attached to it.)
+-	 */
+-	return shmStat.shm_nattch == 0 ? SHMSTATE_UNATTACHED : SHMSTATE_ATTACHED;
+ }
+ 
+ /*
+@@ -691,170 +420,8 @@
+ PGSharedMemoryCreate(Size size,
+ 					 PGShmemHeader **shim)
+ {
+-	IpcMemoryKey NextShmemSegID;
+-	void	   *memAddress;
+-	PGShmemHeader *hdr;
+-	struct stat statbuf;
+-	Size		sysvsize;
+-
+-	/*
+-	 * We use the data directory's ID info (inode and device numbers) to
+-	 * positively identify shmem segments associated with this data dir, and
+-	 * also as seeds for searching for a free shmem key.
+-	 */
+-	if (stat(DataDir, &statbuf) < 0)
+-		ereport(FATAL,
+-				(errcode_for_file_access(),
+-				 errmsg("could not stat data directory \"%s\": %m",
+-						DataDir)));
+-
+-	/* Complain if hugepages demanded but we can't possibly support them */
+-#if !defined(MAP_HUGETLB)
+-	if (huge_pages == HUGE_PAGES_ON)
+-		ereport(ERROR,
+-				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+-				 errmsg("huge pages not supported on this platform")));
+-#endif
+-
+-	/* For now, we don't support huge pages in SysV memory */
+-	if (huge_pages == HUGE_PAGES_ON && shared_memory_type != SHMEM_TYPE_MMAP)
+-		ereport(ERROR,
+-				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+-				 errmsg("huge pages not supported with the current shared_memory_type setting")));
+-
+-	/* Room for a header? */
+-	Assert(size > MAXALIGN(sizeof(PGShmemHeader)));
+-
+-	if (shared_memory_type == SHMEM_TYPE_MMAP)
+-	{
+-		AnonymousShmem = CreateAnonymousSegment(&size);
+-		AnonymousShmemSize = size;
+-
+-		/* Register on-exit routine to unmap the anonymous segment */
+-		on_shmem_exit(AnonymousShmemDetach, (Datum) 0);
+-
+-		/* Now we need only allocate a minimal-sized SysV shmem block. */
+-		sysvsize = sizeof(PGShmemHeader);
+-	}
+-	else
+-		sysvsize = size;
+-
+-	/*
+-	 * Loop till we find a free IPC key.  Trust CreateDataDirLockFile() to
+-	 * ensure no more than one postmaster per data directory can enter this
+-	 * loop simultaneously.  (CreateDataDirLockFile() does not entirely ensure
+-	 * that, but prefer fixing it over coping here.)
+-	 */
+-	NextShmemSegID = statbuf.st_ino;
+-
+-	for (;;)
+-	{
+-		IpcMemoryId shmid;
+-		PGShmemHeader *oldhdr;
+-		IpcMemoryState state;
+-
+-		/* Try to create new segment */
+-		memAddress = InternalIpcMemoryCreate(NextShmemSegID, sysvsize);
+-		if (memAddress)
+-			break;				/* successful create and attach */
+-
+-		/* Check shared memory and possibly remove and recreate */
+-
+-		/*
+-		 * shmget() failure is typically EACCES, hence SHMSTATE_FOREIGN.
+-		 * ENOENT, a narrow possibility, implies SHMSTATE_ENOENT, but one can
+-		 * safely treat SHMSTATE_ENOENT like SHMSTATE_FOREIGN.
+-		 */
+-		shmid = shmget(NextShmemSegID, sizeof(PGShmemHeader), 0);
+-		if (shmid < 0)
+-		{
+-			oldhdr = NULL;
+-			state = SHMSTATE_FOREIGN;
+-		}
+-		else
+-			state = PGSharedMemoryAttach(shmid, NULL, &oldhdr);
+-
+-		switch (state)
+-		{
+-			case SHMSTATE_ANALYSIS_FAILURE:
+-			case SHMSTATE_ATTACHED:
+-				ereport(FATAL,
+-						(errcode(ERRCODE_LOCK_FILE_EXISTS),
+-						 errmsg("pre-existing shared memory block (key %lu, ID %lu) is still in use",
+-								(unsigned long) NextShmemSegID,
+-								(unsigned long) shmid),
+-						 errhint("Terminate any old server processes associated with data directory \"%s\".",
+-								 DataDir)));
+-				break;
+-			case SHMSTATE_ENOENT:
+-
+-				/*
+-				 * To our surprise, some other process deleted since our last
+-				 * InternalIpcMemoryCreate().  Moments earlier, we would have
+-				 * seen SHMSTATE_FOREIGN.  Try that same ID again.
+-				 */
+-				elog(LOG,
+-					 "shared memory block (key %lu, ID %lu) deleted during startup",
+-					 (unsigned long) NextShmemSegID,
+-					 (unsigned long) shmid);
+-				break;
+-			case SHMSTATE_FOREIGN:
+-				NextShmemSegID++;
+-				break;
+-			case SHMSTATE_UNATTACHED:
+-
+-				/*
+-				 * The segment pertains to DataDir, and every process that had
+-				 * used it has died or detached.  Zap it, if possible, and any
+-				 * associated dynamic shared memory segments, as well.  This
+-				 * shouldn't fail, but if it does, assume the segment belongs
+-				 * to someone else after all, and try the next candidate.
+-				 * Otherwise, try again to create the segment.  That may fail
+-				 * if some other process creates the same shmem key before we
+-				 * do, in which case we'll try the next key.
+-				 */
+-				if (oldhdr->dsm_control != 0)
+-					dsm_cleanup_using_control_segment(oldhdr->dsm_control);
+-				if (shmctl(shmid, IPC_RMID, NULL) < 0)
+-					NextShmemSegID++;
+-				break;
+-		}
+-
+-		if (oldhdr && shmdt((void *) oldhdr) < 0)
+-			elog(LOG, "shmdt(%p) failed: %m", oldhdr);
+-	}
+-
+-	/* Initialize new segment. */
+-	hdr = (PGShmemHeader *) memAddress;
+-	hdr->creatorPID = getpid();
+-	hdr->magic = PGShmemMagic;
+-	hdr->dsm_control = 0;
+-
+-	/* Fill in the data directory ID info, too */
+-	hdr->device = statbuf.st_dev;
+-	hdr->inode = statbuf.st_ino;
+-
+-	/*
+-	 * Initialize space allocation status for segment.
+-	 */
+-	hdr->totalsize = size;
+-	hdr->freeoffset = MAXALIGN(sizeof(PGShmemHeader));
+-	*shim = hdr;
+-
+-	/* Save info for possible future use */
+-	UsedShmemSegAddr = memAddress;
+-	UsedShmemSegID = (unsigned long) NextShmemSegID;
+-
+-	/*
+-	 * If AnonymousShmem is NULL here, then we're not using anonymous shared
+-	 * memory, and should return a pointer to the System V shared memory
+-	 * block. Otherwise, the System V shared memory block is only a shim, and
+-	 * we must return a pointer to the real block.
+-	 */
+-	if (AnonymousShmem == NULL)
+-		return hdr;
+-	memcpy(AnonymousShmem, hdr, sizeof(PGShmemHeader));
+-	return (PGShmemHeader *) AnonymousShmem;
++	*shim = NULL;
++	return NULL;
+ }
+ 
+ #ifdef EXEC_BACKEND
+@@ -874,27 +441,13 @@
+ void
+ PGSharedMemoryReAttach(void)
+ {
+-	IpcMemoryId shmid;
+-	PGShmemHeader *hdr;
+-	IpcMemoryState state;
++	PGShmemHeader *hdr = NULL;
+ 	void	   *origUsedShmemSegAddr = UsedShmemSegAddr;
+ 
+ 	Assert(UsedShmemSegAddr != NULL);
+ 	Assert(IsUnderPostmaster);
+ 
+-#ifdef __CYGWIN__
+-	/* cygipc (currently) appears to not detach on exec. */
+-	PGSharedMemoryDetach();
+-	UsedShmemSegAddr = origUsedShmemSegAddr;
+-#endif
+-
+ 	elog(DEBUG3, "attaching to %p", UsedShmemSegAddr);
+-	shmid = shmget(UsedShmemSegID, sizeof(PGShmemHeader), 0);
+-	if (shmid < 0)
+-		state = SHMSTATE_FOREIGN;
+-	else
+-		state = PGSharedMemoryAttach(shmid, UsedShmemSegAddr, &hdr);
+-	if (state != SHMSTATE_ATTACHED)
+ 		elog(FATAL, "could not reattach to shared memory (key=%d, addr=%p): %m",
+ 			 (int) UsedShmemSegID, UsedShmemSegAddr);
+ 	if (hdr != origUsedShmemSegAddr)
+@@ -956,12 +509,6 @@
+ {
+ 	if (UsedShmemSegAddr != NULL)
+ 	{
+-		if ((shmdt(UsedShmemSegAddr) < 0)
+-#if defined(EXEC_BACKEND) && defined(__CYGWIN__)
+-		/* Work-around for cygipc exec bug */
+-			&& shmdt(NULL) < 0
+-#endif
+-			)
+ 			elog(LOG, "shmdt(%p) failed: %m", UsedShmemSegAddr);
+ 		UsedShmemSegAddr = NULL;
+ 	}
+--- a/src/backend/storage/ipc/dsm_impl.c
++++ b/src/backend/storage/ipc/dsm_impl.c
+@@ -234,7 +234,7 @@
+ 		}
+ 		*mapped_address = NULL;
+ 		*mapped_size = 0;
+-		if (op == DSM_OP_DESTROY && shm_unlink(name) != 0)
++		if (op == DSM_OP_DESTROY)
+ 		{
+ 			ereport(elevel,
+ 					(errcode_for_dynamic_shared_memory(),
+@@ -255,9 +255,6 @@
+ 	 */
+ 	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,
+@@ -265,79 +262,6 @@
+ 					 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;
+ }
+ 
+ /*
+@@ -506,8 +430,6 @@
+ 			segsize = request_size;
+ 		}
+ 
+-		if ((ident = shmget(key, segsize, flags)) == -1)
+-		{
+ 			if (op == DSM_OP_ATTACH || errno != EEXIST)
+ 			{
+ 				int			save_errno = errno;
+@@ -521,16 +443,12 @@
+ 			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)
++		if (*mapped_address != NULL)
+ 		{
+ 			ereport(elevel,
+ 					(errcode_for_dynamic_shared_memory(),
+@@ -540,7 +458,7 @@
+ 		}
+ 		*mapped_address = NULL;
+ 		*mapped_size = 0;
+-		if (op == DSM_OP_DESTROY && shmctl(ident, IPC_RMID, NULL) < 0)
++		if (op == DSM_OP_DESTROY)
+ 		{
+ 			ereport(elevel,
+ 					(errcode_for_dynamic_shared_memory(),
+@@ -554,41 +472,22 @@
+ 	/* 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;
++	int save_errno = 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;
+ }
+ #endif
+ 
+--- a/src/bin/initdb/initdb.c
++++ b/src/bin/initdb/initdb.c
+@@ -1006,38 +1006,7 @@
+ static const char *
+ choose_dsm_implementation(void)
+ {
+-#if defined(HAVE_SHM_OPEN) && !defined(__sun__)
+-	int			ntries = 10;
+-	pg_prng_state prng_state;
+-
+-	/* Initialize prng; this function is its only user in this program. */
+-	pg_prng_seed(&prng_state, (uint64) (getpid() ^ time(NULL)));
+-
+-	while (ntries > 0)
+-	{
+-		uint32		handle;
+-		char		name[64];
+-		int			fd;
+-
+-		handle = pg_prng_uint32(&prng_state);
+-		snprintf(name, 64, "/PostgreSQL.%u", handle);
+-		if ((fd = shm_open(name, O_CREAT | O_RDWR | O_EXCL, 0600)) != -1)
+-		{
+-			close(fd);
+-			shm_unlink(name);
+-			return "posix";
+-		}
+-		if (errno != EEXIST)
+-			break;
+-		--ntries;
+-	}
+-#endif
+-
+-#ifdef WIN32
+-	return "windows";
+-#else
+ 	return "sysv";
+-#endif
+ }
+ 
+ /*