hide-semaphore-implementation-better.patch

diff --git a/src/backend/port/posix_sema.c b/src/backend/port/posix_sema.c
index 2b4b11c..603dc5a 100644
*** a/src/backend/port/posix_sema.c
--- b/src/backend/port/posix_sema.c
***************
*** 6,11 ****
--- 6,19 ----
   * We prefer the unnamed style of POSIX semaphore (the kind made with
   * sem_init).  We can cope with the kind made with sem_open, however.
   *
+  * In either implementation, typedef PGSemaphore is equivalent to "sem_t *".
+  * With unnamed semaphores, the sem_t structs live in an array in shared
+  * memory.  With named semaphores, that's not true because we cannot persuade
+  * sem_open to do its allocation there.  Therefore, the named-semaphore code
+  * *does not cope with EXEC_BACKEND*.  The sem_t structs will just be in the
+  * postmaster's private memory, where they are successfully inherited by
+  * forked backends, but they could not be accessed by exec'd backends.
+  *
   *
   * Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group
   * Portions Copyright (c) 1994, Regents of the University of California
***************
*** 18,45 ****
  #include "postgres.h"
  
  #include <fcntl.h>
  #include <signal.h>
  #include <unistd.h>
  
  #include "miscadmin.h"
  #include "storage/ipc.h"
  #include "storage/pg_sema.h"
  
  
! #ifdef USE_NAMED_POSIX_SEMAPHORES
! /* PGSemaphore is pointer to pointer to sem_t */
! #define PG_SEM_REF(x)	(*(x))
! #else
! /* PGSemaphore is pointer to sem_t */
! #define PG_SEM_REF(x)	(x)
  #endif
  
  
  #define IPCProtection	(0600)	/* access/modify by user only */
  
  static sem_t **mySemPointers;	/* keep track of created semaphores */
  static int	numSems;			/* number of semas acquired so far */
! static int	maxSems;			/* allocated size of mySemaPointers array */
  static int	nextSemKey;			/* next name to try */
  
  
--- 26,63 ----
  #include "postgres.h"
  
  #include <fcntl.h>
+ #include <semaphore.h>
  #include <signal.h>
  #include <unistd.h>
  
  #include "miscadmin.h"
  #include "storage/ipc.h"
  #include "storage/pg_sema.h"
+ #include "storage/shmem.h"
  
  
! /* see file header comment */
! #if defined(USE_NAMED_POSIX_SEMAPHORES) && defined(EXEC_BACKEND)
! #error cannot use named POSIX semaphores with EXEC_BACKEND
  #endif
  
+ /* typedef PGSemaphore is equivalent to pointer to sem_t */
+ typedef struct PGSemaphoreData
+ {
+ 	sem_t		pgsem;
+ } PGSemaphoreData;
+ 
+ #define PG_SEM_REF(x)	(&(x)->pgsem)
  
  #define IPCProtection	(0600)	/* access/modify by user only */
  
+ #ifdef USE_NAMED_POSIX_SEMAPHORES
  static sem_t **mySemPointers;	/* keep track of created semaphores */
+ #else
+ static PGSemaphore sharedSemas; /* array of PGSemaphoreData in shared memory */
+ #endif
  static int	numSems;			/* number of semas acquired so far */
! static int	maxSems;			/* allocated size of above arrays */
  static int	nextSemKey;			/* next name to try */
  
  
*************** PosixSemaphoreKill(sem_t * sem)
*** 134,139 ****
--- 152,172 ----
  
  
  /*
+  * Report amount of shared memory needed for semaphores
+  */
+ Size
+ PGSemaphoreShmemSize(int maxSemas)
+ {
+ #ifdef USE_NAMED_POSIX_SEMAPHORES
+ 	/* No shared memory needed in this case */
+ 	return 0;
+ #else
+ 	/* Need a PGSemaphoreData per semaphore */
+ 	return mul_size(maxSemas, sizeof(PGSemaphoreData));
+ #endif
+ }
+ 
+ /*
   * PGReserveSemaphores --- initialize semaphore support
   *
   * This is called during postmaster start or shared memory reinitialization.
*************** PosixSemaphoreKill(sem_t * sem)
*** 147,161 ****
   * zero will be passed.
   *
   * In the Posix implementation, we acquire semaphores on-demand; the
!  * maxSemas parameter is just used to size the array that keeps track of
!  * acquired semas for subsequent releasing.
   */
  void
  PGReserveSemaphores(int maxSemas, int port)
  {
  	mySemPointers = (sem_t **) malloc(maxSemas * sizeof(sem_t *));
  	if (mySemPointers == NULL)
  		elog(PANIC, "out of memory");
  	numSems = 0;
  	maxSems = maxSemas;
  	nextSemKey = port * 1000;
--- 180,212 ----
   * zero will be passed.
   *
   * In the Posix implementation, we acquire semaphores on-demand; the
!  * maxSemas parameter is just used to size the arrays.  For unnamed
!  * semaphores, there is an array of PGSemaphoreData structs in shared memory.
!  * For named semaphores, we keep a postmaster-local array of sem_t pointers,
!  * which we use for releasing the semphores when done.
!  * (This design minimizes the dependency of postmaster shutdown on the
!  * contents of shared memory, which a failed backend might have clobbered.
!  * We can't do much about the possibility of sem_destroy() crashing, but
!  * we don't have to expose the counters to other processes.)
   */
  void
  PGReserveSemaphores(int maxSemas, int port)
  {
+ #ifdef USE_NAMED_POSIX_SEMAPHORES
  	mySemPointers = (sem_t **) malloc(maxSemas * sizeof(sem_t *));
  	if (mySemPointers == NULL)
  		elog(PANIC, "out of memory");
+ #else
+ 
+ 	/*
+ 	 * We must use ShmemAllocUnlocked(), since the spinlock protecting
+ 	 * ShmemAlloc() won't be ready yet.  (This ordering is necessary when we
+ 	 * are emulating spinlocks with semaphores.)
+ 	 */
+ 	sharedSemas = (PGSemaphore)
+ 		ShmemAllocUnlocked(PGSemaphoreShmemSize(maxSemas));
+ #endif
+ 
  	numSems = 0;
  	maxSems = maxSemas;
  	nextSemKey = port * 1000;
*************** ReleaseSemaphores(int status, Datum arg)
*** 173,191 ****
  {
  	int			i;
  
  	for (i = 0; i < numSems; i++)
  		PosixSemaphoreKill(mySemPointers[i]);
  	free(mySemPointers);
  }
  
  /*
   * PGSemaphoreCreate
   *
!  * Initialize a PGSemaphore structure to represent a sema with count 1
   */
! void
! PGSemaphoreCreate(PGSemaphore sema)
  {
  	sem_t	   *newsem;
  
  	/* Can't do this in a backend, because static state is postmaster's */
--- 224,250 ----
  {
  	int			i;
  
+ #ifdef USE_NAMED_POSIX_SEMAPHORES
  	for (i = 0; i < numSems; i++)
  		PosixSemaphoreKill(mySemPointers[i]);
  	free(mySemPointers);
+ #endif
+ 
+ #ifdef USE_UNNAMED_POSIX_SEMAPHORES
+ 	for (i = 0; i < numSems; i++)
+ 		PosixSemaphoreKill(PG_SEM_REF(sharedSemas + i));
+ #endif
  }
  
  /*
   * PGSemaphoreCreate
   *
!  * Allocate a PGSemaphore structure with initial count 1
   */
! PGSemaphore
! PGSemaphoreCreate(void)
  {
+ 	PGSemaphore sema;
  	sem_t	   *newsem;
  
  	/* Can't do this in a backend, because static state is postmaster's */
*************** PGSemaphoreCreate(PGSemaphore sema)
*** 195,208 ****
  		elog(PANIC, "too many semaphores created");
  
  #ifdef USE_NAMED_POSIX_SEMAPHORES
! 	*sema = newsem = PosixSemaphoreCreate();
  #else
! 	PosixSemaphoreCreate(sema);
! 	newsem = sema;
  #endif
  
! 	/* Remember new sema for ReleaseSemaphores */
! 	mySemPointers[numSems++] = newsem;
  }
  
  /*
--- 254,272 ----
  		elog(PANIC, "too many semaphores created");
  
  #ifdef USE_NAMED_POSIX_SEMAPHORES
! 	newsem = PosixSemaphoreCreate();
! 	/* Remember new sema for ReleaseSemaphores */
! 	mySemPointers[numSems] = newsem;
! 	sema = (PGSemaphore) newsem;
  #else
! 	sema = &sharedSemas[numSems];
! 	newsem = PG_SEM_REF(sema);
! 	PosixSemaphoreCreate(newsem);
  #endif
  
! 	numSems++;
! 
! 	return sema;
  }
  
  /*
diff --git a/src/backend/port/sysv_sema.c b/src/backend/port/sysv_sema.c
index f6f1516..531d426 100644
*** a/src/backend/port/sysv_sema.c
--- b/src/backend/port/sysv_sema.c
***************
*** 27,33 ****
--- 27,40 ----
  #include "miscadmin.h"
  #include "storage/ipc.h"
  #include "storage/pg_sema.h"
+ #include "storage/shmem.h"
+ 
  
+ typedef struct PGSemaphoreData
+ {
+ 	int			semId;			/* semaphore set identifier */
+ 	int			semNum;			/* semaphore number within set */
+ } PGSemaphoreData;
  
  #ifndef HAVE_UNION_SEMUN
  union semun
*************** typedef int IpcSemaphoreId;		/* semaphor
*** 54,59 ****
--- 61,69 ----
  #define PGSemaMagic		537		/* must be less than SEMVMX */
  
  
+ static PGSemaphore sharedSemas; /* array of PGSemaphoreData in shared memory */
+ static int	numSharedSemas;		/* number of PGSemaphoreDatas used so far */
+ static int	maxSharedSemas;		/* allocated size of PGSemaphoreData array */
  static IpcSemaphoreId *mySemaSets;		/* IDs of sema sets acquired so far */
  static int	numSemaSets;		/* number of sema sets acquired so far */
  static int	maxSemaSets;		/* allocated size of mySemaSets array */
*************** IpcSemaphoreCreate(int numSems)
*** 274,279 ****
--- 284,298 ----
  
  
  /*
+  * Report amount of shared memory needed for semaphores
+  */
+ Size
+ PGSemaphoreShmemSize(int maxSemas)
+ {
+ 	return mul_size(maxSemas, sizeof(PGSemaphoreData));
+ }
+ 
+ /*
   * PGReserveSemaphores --- initialize semaphore support
   *
   * This is called during postmaster start or shared memory reinitialization.
*************** IpcSemaphoreCreate(int numSems)
*** 287,298 ****
   * zero will be passed.
   *
   * In the SysV implementation, we acquire semaphore sets on-demand; the
!  * maxSemas parameter is just used to size the array that keeps track of
!  * acquired sets for subsequent releasing.
   */
  void
  PGReserveSemaphores(int maxSemas, int port)
  {
  	maxSemaSets = (maxSemas + SEMAS_PER_SET - 1) / SEMAS_PER_SET;
  	mySemaSets = (IpcSemaphoreId *)
  		malloc(maxSemaSets * sizeof(IpcSemaphoreId));
--- 306,331 ----
   * zero will be passed.
   *
   * In the SysV implementation, we acquire semaphore sets on-demand; the
!  * maxSemas parameter is just used to size the arrays.  There is an array
!  * of PGSemaphoreData structs in shared memory, and a postmaster-local array
!  * with one entry per SysV semaphore set, which we use for releasing the
!  * semaphore sets when done.  (This design ensures that postmaster shutdown
!  * doesn't rely on the contents of shared memory, which a failed backend might
!  * have clobbered.)
   */
  void
  PGReserveSemaphores(int maxSemas, int port)
  {
+ 	/*
+ 	 * We must use ShmemAllocUnlocked(), since the spinlock protecting
+ 	 * ShmemAlloc() won't be ready yet.  (This ordering is necessary when we
+ 	 * are emulating spinlocks with semaphores.)
+ 	 */
+ 	sharedSemas = (PGSemaphore)
+ 		ShmemAllocUnlocked(PGSemaphoreShmemSize(maxSemas));
+ 	numSharedSemas = 0;
+ 	maxSharedSemas = maxSemas;
+ 
  	maxSemaSets = (maxSemas + SEMAS_PER_SET - 1) / SEMAS_PER_SET;
  	mySemaSets = (IpcSemaphoreId *)
  		malloc(maxSemaSets * sizeof(IpcSemaphoreId));
*************** ReleaseSemaphores(int status, Datum arg)
*** 323,333 ****
  /*
   * PGSemaphoreCreate
   *
!  * Initialize a PGSemaphore structure to represent a sema with count 1
   */
! void
! PGSemaphoreCreate(PGSemaphore sema)
  {
  	/* Can't do this in a backend, because static state is postmaster's */
  	Assert(!IsUnderPostmaster);
  
--- 356,368 ----
  /*
   * PGSemaphoreCreate
   *
!  * Allocate a PGSemaphore structure with initial count 1
   */
! PGSemaphore
! PGSemaphoreCreate(void)
  {
+ 	PGSemaphore sema;
+ 
  	/* Can't do this in a backend, because static state is postmaster's */
  	Assert(!IsUnderPostmaster);
  
*************** PGSemaphoreCreate(PGSemaphore sema)
*** 340,350 ****
--- 375,391 ----
  		numSemaSets++;
  		nextSemaNumber = 0;
  	}
+ 	/* Use the next shared PGSemaphoreData */
+ 	if (numSharedSemas >= maxSharedSemas)
+ 		elog(PANIC, "too many semaphores created");
+ 	sema = &sharedSemas[numSharedSemas++];
  	/* Assign the next free semaphore in the current set */
  	sema->semId = mySemaSets[numSemaSets - 1];
  	sema->semNum = nextSemaNumber++;
  	/* Initialize it to count 1 */
  	IpcSemaphoreInitialize(sema->semId, sema->semNum, 1);
+ 
+ 	return sema;
  }
  
  /*
diff --git a/src/backend/port/win32_sema.c b/src/backend/port/win32_sema.c
index c688210..c8b12be 100644
*** a/src/backend/port/win32_sema.c
--- b/src/backend/port/win32_sema.c
*************** static int	maxSems;			/* allocated size 
*** 23,28 ****
--- 23,39 ----
  
  static void ReleaseSemaphores(int code, Datum arg);
  
+ 
+ /*
+  * Report amount of shared memory needed for semaphores
+  */
+ Size
+ PGSemaphoreShmemSize(int maxSemas)
+ {
+ 	/* No shared memory needed on Windows */
+ 	return 0;
+ }
+ 
  /*
   * PGReserveSemaphores --- initialize semaphore support
   *
*************** ReleaseSemaphores(int code, Datum arg)
*** 62,71 ****
  /*
   * PGSemaphoreCreate
   *
!  * Initialize a PGSemaphore structure to represent a sema with count 1
   */
! void
! PGSemaphoreCreate(PGSemaphore sema)
  {
  	HANDLE		cur_handle;
  	SECURITY_ATTRIBUTES sec_attrs;
--- 73,82 ----
  /*
   * PGSemaphoreCreate
   *
!  * Allocate a PGSemaphore structure with initial count 1
   */
! PGSemaphore
! PGSemaphoreCreate(void)
  {
  	HANDLE		cur_handle;
  	SECURITY_ATTRIBUTES sec_attrs;
*************** PGSemaphoreCreate(PGSemaphore sema)
*** 86,97 ****
  	if (cur_handle)
  	{
  		/* Successfully done */
- 		*sema = cur_handle;
  		mySemSet[numSems++] = cur_handle;
  	}
  	else
  		ereport(PANIC,
! 				(errmsg("could not create semaphore: error code %lu", GetLastError())));
  }
  
  /*
--- 97,110 ----
  	if (cur_handle)
  	{
  		/* Successfully done */
  		mySemSet[numSems++] = cur_handle;
  	}
  	else
  		ereport(PANIC,
! 				(errmsg("could not create semaphore: error code %lu",
! 						GetLastError())));
! 
! 	return (PGSemaphore) cur_handle;
  }
  
  /*
*************** PGSemaphoreReset(PGSemaphore sema)
*** 106,112 ****
  	 * There's no direct API for this in Win32, so we have to ratchet the
  	 * semaphore down to 0 with repeated trylock's.
  	 */
! 	while (PGSemaphoreTryLock(sema));
  }
  
  /*
--- 119,126 ----
  	 * There's no direct API for this in Win32, so we have to ratchet the
  	 * semaphore down to 0 with repeated trylock's.
  	 */
! 	while (PGSemaphoreTryLock(sema))
! 		 /* loop */ ;
  }
  
  /*
*************** PGSemaphoreLock(PGSemaphore sema)
*** 127,133 ****
  	 * pending signals are serviced.
  	 */
  	wh[0] = pgwin32_signal_event;
! 	wh[1] = *sema;
  
  	/*
  	 * As in other implementations of PGSemaphoreLock, we need to check for
--- 141,147 ----
  	 * pending signals are serviced.
  	 */
  	wh[0] = pgwin32_signal_event;
! 	wh[1] = sema;
  
  	/*
  	 * As in other implementations of PGSemaphoreLock, we need to check for
*************** PGSemaphoreLock(PGSemaphore sema)
*** 182,190 ****
  void
  PGSemaphoreUnlock(PGSemaphore sema)
  {
! 	if (!ReleaseSemaphore(*sema, 1, NULL))
  		ereport(FATAL,
! 				(errmsg("could not unlock semaphore: error code %lu", GetLastError())));
  }
  
  /*
--- 196,205 ----
  void
  PGSemaphoreUnlock(PGSemaphore sema)
  {
! 	if (!ReleaseSemaphore(sema, 1, NULL))
  		ereport(FATAL,
! 				(errmsg("could not unlock semaphore: error code %lu",
! 						GetLastError())));
  }
  
  /*
*************** PGSemaphoreTryLock(PGSemaphore sema)
*** 197,203 ****
  {
  	DWORD		ret;
  
! 	ret = WaitForSingleObject(*sema, 0);
  
  	if (ret == WAIT_OBJECT_0)
  	{
--- 212,218 ----
  {
  	DWORD		ret;
  
! 	ret = WaitForSingleObject(sema, 0);
  
  	if (ret == WAIT_OBJECT_0)
  	{
*************** PGSemaphoreTryLock(PGSemaphore sema)
*** 213,219 ****
  
  	/* Otherwise we are in trouble */
  	ereport(FATAL,
! 	(errmsg("could not try-lock semaphore: error code %lu", GetLastError())));
  
  	/* keep compiler quiet */
  	return false;
--- 228,235 ----
  
  	/* Otherwise we are in trouble */
  	ereport(FATAL,
! 			(errmsg("could not try-lock semaphore: error code %lu",
! 					GetLastError())));
  
  	/* keep compiler quiet */
  	return false;
diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c
index 59073e0..827e0d5 100644
*** a/src/backend/postmaster/postmaster.c
--- b/src/backend/postmaster/postmaster.c
*************** typedef struct
*** 484,490 ****
  	VariableCache ShmemVariableCache;
  	Backend    *ShmemBackendArray;
  #ifndef HAVE_SPINLOCKS
! 	PGSemaphore SpinlockSemaArray;
  #endif
  	int			NamedLWLockTrancheRequests;
  	NamedLWLockTranche *NamedLWLockTrancheArray;
--- 484,490 ----
  	VariableCache ShmemVariableCache;
  	Backend    *ShmemBackendArray;
  #ifndef HAVE_SPINLOCKS
! 	PGSemaphore *SpinlockSemaArray;
  #endif
  	int			NamedLWLockTrancheRequests;
  	NamedLWLockTranche *NamedLWLockTrancheArray;
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 01bddce..29febb4 100644
*** a/src/backend/storage/ipc/ipci.c
--- b/src/backend/storage/ipc/ipci.c
*************** CreateSharedMemoryAndSemaphores(bool mak
*** 102,107 ****
--- 102,111 ----
  		Size		size;
  		int			numSemas;
  
+ 		/* Compute number of semaphores we'll need */
+ 		numSemas = ProcGlobalSemas();
+ 		numSemas += SpinlockSemas();
+ 
  		/*
  		 * Size of the Postgres shared-memory block is estimated via
  		 * moderately-accurate estimates for the big hogs, plus 100K for the
*************** CreateSharedMemoryAndSemaphores(bool mak
*** 112,117 ****
--- 116,122 ----
  		 * need to be so careful during the actual allocation phase.
  		 */
  		size = 100000;
+ 		size = add_size(size, PGSemaphoreShmemSize(numSemas));
  		size = add_size(size, SpinlockSemaSize());
  		size = add_size(size, hash_estimate_size(SHMEM_INDEX_SIZE,
  												 sizeof(ShmemIndexEnt)));
*************** CreateSharedMemoryAndSemaphores(bool mak
*** 166,174 ****
  		/*
  		 * Create semaphores
  		 */
- 		numSemas = ProcGlobalSemas();
- 		numSemas += SpinlockSemas();
  		PGReserveSemaphores(numSemas, port);
  	}
  	else
  	{
--- 171,185 ----
  		/*
  		 * Create semaphores
  		 */
  		PGReserveSemaphores(numSemas, port);
+ 
+ 		/*
+ 		 * If spinlocks are disabled, initialize emulation layer (which
+ 		 * depends on semaphores, so the order is important here).
+ 		 */
+ #ifndef HAVE_SPINLOCKS
+ 		SpinlockSemaInit();
+ #endif
  	}
  	else
  	{
diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c
index e5d487d..bf38470 100644
*** a/src/backend/storage/ipc/procarray.c
--- b/src/backend/storage/ipc/procarray.c
*************** ProcArrayGroupClearXid(PGPROC *proc, Tra
*** 522,528 ****
  		for (;;)
  		{
  			/* acts as a read barrier */
! 			PGSemaphoreLock(&proc->sem);
  			if (!proc->procArrayGroupMember)
  				break;
  			extraWaits++;
--- 522,528 ----
  		for (;;)
  		{
  			/* acts as a read barrier */
! 			PGSemaphoreLock(proc->sem);
  			if (!proc->procArrayGroupMember)
  				break;
  			extraWaits++;
*************** ProcArrayGroupClearXid(PGPROC *proc, Tra
*** 532,538 ****
  
  		/* Fix semaphore count for any absorbed wakeups */
  		while (extraWaits-- > 0)
! 			PGSemaphoreUnlock(&proc->sem);
  		return;
  	}
  
--- 532,538 ----
  
  		/* Fix semaphore count for any absorbed wakeups */
  		while (extraWaits-- > 0)
! 			PGSemaphoreUnlock(proc->sem);
  		return;
  	}
  
*************** ProcArrayGroupClearXid(PGPROC *proc, Tra
*** 591,597 ****
  		proc->procArrayGroupMember = false;
  
  		if (proc != MyProc)
! 			PGSemaphoreUnlock(&proc->sem);
  	}
  }
  
--- 591,597 ----
  		proc->procArrayGroupMember = false;
  
  		if (proc != MyProc)
! 			PGSemaphoreUnlock(proc->sem);
  	}
  }
  
diff --git a/src/backend/storage/ipc/shmem.c b/src/backend/storage/ipc/shmem.c
index cc3af2d..a516194 100644
*** a/src/backend/storage/ipc/shmem.c
--- b/src/backend/storage/ipc/shmem.c
*************** InitShmemAllocation(void)
*** 117,152 ****
  	Assert(shmhdr != NULL);
  
  	/*
! 	 * If spinlocks are disabled, initialize emulation layer.  We have to do
! 	 * the space allocation the hard way, since obviously ShmemAlloc can't be
! 	 * called yet.
  	 */
! #ifndef HAVE_SPINLOCKS
! 	{
! 		PGSemaphore spinsemas;
  
! 		spinsemas = (PGSemaphore) (((char *) shmhdr) + shmhdr->freeoffset);
! 		shmhdr->freeoffset += MAXALIGN(SpinlockSemaSize());
! 		SpinlockSemaInit(spinsemas);
! 		Assert(shmhdr->freeoffset <= shmhdr->totalsize);
! 	}
! #endif
  
  	/*
! 	 * Initialize the spinlock used by ShmemAlloc; we have to do this the hard
! 	 * way, too, for the same reasons as above.
  	 */
- 	ShmemLock = (slock_t *) (((char *) shmhdr) + shmhdr->freeoffset);
- 	shmhdr->freeoffset += MAXALIGN(sizeof(slock_t));
- 	Assert(shmhdr->freeoffset <= shmhdr->totalsize);
- 
- 	/* Make sure the first allocation begins on a cache line boundary. */
  	aligned = (char *)
  		(CACHELINEALIGN((((char *) shmhdr) + shmhdr->freeoffset)));
  	shmhdr->freeoffset = aligned - (char *) shmhdr;
  
- 	SpinLockInit(ShmemLock);
- 
  	/* ShmemIndex can't be set up yet (need LWLocks first) */
  	shmhdr->index = NULL;
  	ShmemIndex = (HTAB *) NULL;
--- 117,138 ----
  	Assert(shmhdr != NULL);
  
  	/*
! 	 * Initialize the spinlock used by ShmemAlloc.  We must use
! 	 * ShmemAllocUnlocked, since obviously ShmemAlloc can't be called yet.
  	 */
! 	ShmemLock = (slock_t *) ShmemAllocUnlocked(sizeof(slock_t));
  
! 	SpinLockInit(ShmemLock);
  
  	/*
! 	 * Allocations after this point should go through ShmemAlloc, which
! 	 * expects to allocate everything on cache line boundaries.  Make sure the
! 	 * first allocation begins on a cache line boundary.
  	 */
  	aligned = (char *)
  		(CACHELINEALIGN((((char *) shmhdr) + shmhdr->freeoffset)));
  	shmhdr->freeoffset = aligned - (char *) shmhdr;
  
  	/* ShmemIndex can't be set up yet (need LWLocks first) */
  	shmhdr->index = NULL;
  	ShmemIndex = (HTAB *) NULL;
*************** ShmemAllocNoError(Size size)
*** 230,235 ****
--- 216,260 ----
  }
  
  /*
+  * ShmemAllocUnlocked -- allocate max-aligned chunk from shared memory
+  *
+  * Allocate space without locking ShmemLock.  This should be used for,
+  * and only for, allocations that must happen before ShmemLock is ready.
+  *
+  * We consider maxalign, rather than cachealign, sufficient here.
+  */
+ void *
+ ShmemAllocUnlocked(Size size)
+ {
+ 	Size		newStart;
+ 	Size		newFree;
+ 	void	   *newSpace;
+ 
+ 	/*
+ 	 * Ensure allocated space is adequately aligned.
+ 	 */
+ 	size = MAXALIGN(size);
+ 
+ 	Assert(ShmemSegHdr != NULL);
+ 
+ 	newStart = ShmemSegHdr->freeoffset;
+ 
+ 	newFree = newStart + size;
+ 	if (newFree > ShmemSegHdr->totalsize)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_OUT_OF_MEMORY),
+ 				 errmsg("out of shared memory (%zu bytes requested)",
+ 						size)));
+ 	ShmemSegHdr->freeoffset = newFree;
+ 
+ 	newSpace = (void *) ((char *) ShmemBase + newStart);
+ 
+ 	Assert(newSpace == (void *) MAXALIGN(newSpace));
+ 
+ 	return newSpace;
+ }
+ 
+ /*
   * ShmemAddrIsValid -- test if an address refers to shared memory
   *
   * Returns TRUE if the pointer points within the shared memory segment.
diff --git a/src/backend/storage/lmgr/lwlock.c b/src/backend/storage/lmgr/lwlock.c
index ffb2f72..03c4c78 100644
*** a/src/backend/storage/lmgr/lwlock.c
--- b/src/backend/storage/lmgr/lwlock.c
*************** LWLockWakeup(LWLock *lock)
*** 1012,1018 ****
  		 */
  		pg_write_barrier();
  		waiter->lwWaiting = false;
! 		PGSemaphoreUnlock(&waiter->sem);
  	}
  }
  
--- 1012,1018 ----
  		 */
  		pg_write_barrier();
  		waiter->lwWaiting = false;
! 		PGSemaphoreUnlock(waiter->sem);
  	}
  }
  
*************** LWLockDequeueSelf(LWLock *lock)
*** 1129,1135 ****
  		 */
  		for (;;)
  		{
! 			PGSemaphoreLock(&MyProc->sem);
  			if (!MyProc->lwWaiting)
  				break;
  			extraWaits++;
--- 1129,1135 ----
  		 */
  		for (;;)
  		{
! 			PGSemaphoreLock(MyProc->sem);
  			if (!MyProc->lwWaiting)
  				break;
  			extraWaits++;
*************** LWLockDequeueSelf(LWLock *lock)
*** 1139,1145 ****
  		 * Fix the process wait semaphore's count for any absorbed wakeups.
  		 */
  		while (extraWaits-- > 0)
! 			PGSemaphoreUnlock(&MyProc->sem);
  	}
  
  #ifdef LOCK_DEBUG
--- 1139,1145 ----
  		 * Fix the process wait semaphore's count for any absorbed wakeups.
  		 */
  		while (extraWaits-- > 0)
! 			PGSemaphoreUnlock(MyProc->sem);
  	}
  
  #ifdef LOCK_DEBUG
*************** LWLockAcquire(LWLock *lock, LWLockMode m
*** 1283,1289 ****
  
  		for (;;)
  		{
! 			PGSemaphoreLock(&proc->sem);
  			if (!proc->lwWaiting)
  				break;
  			extraWaits++;
--- 1283,1289 ----
  
  		for (;;)
  		{
! 			PGSemaphoreLock(proc->sem);
  			if (!proc->lwWaiting)
  				break;
  			extraWaits++;
*************** LWLockAcquire(LWLock *lock, LWLockMode m
*** 1320,1326 ****
  	 * Fix the process wait semaphore's count for any absorbed wakeups.
  	 */
  	while (extraWaits-- > 0)
! 		PGSemaphoreUnlock(&proc->sem);
  
  	return result;
  }
--- 1320,1326 ----
  	 * Fix the process wait semaphore's count for any absorbed wakeups.
  	 */
  	while (extraWaits-- > 0)
! 		PGSemaphoreUnlock(proc->sem);
  
  	return result;
  }
*************** LWLockAcquireOrWait(LWLock *lock, LWLock
*** 1444,1450 ****
  
  			for (;;)
  			{
! 				PGSemaphoreLock(&proc->sem);
  				if (!proc->lwWaiting)
  					break;
  				extraWaits++;
--- 1444,1450 ----
  
  			for (;;)
  			{
! 				PGSemaphoreLock(proc->sem);
  				if (!proc->lwWaiting)
  					break;
  				extraWaits++;
*************** LWLockAcquireOrWait(LWLock *lock, LWLock
*** 1481,1487 ****
  	 * Fix the process wait semaphore's count for any absorbed wakeups.
  	 */
  	while (extraWaits-- > 0)
! 		PGSemaphoreUnlock(&proc->sem);
  
  	if (mustwait)
  	{
--- 1481,1487 ----
  	 * Fix the process wait semaphore's count for any absorbed wakeups.
  	 */
  	while (extraWaits-- > 0)
! 		PGSemaphoreUnlock(proc->sem);
  
  	if (mustwait)
  	{
*************** LWLockWaitForVar(LWLock *lock, uint64 *v
*** 1662,1668 ****
  
  		for (;;)
  		{
! 			PGSemaphoreLock(&proc->sem);
  			if (!proc->lwWaiting)
  				break;
  			extraWaits++;
--- 1662,1668 ----
  
  		for (;;)
  		{
! 			PGSemaphoreLock(proc->sem);
  			if (!proc->lwWaiting)
  				break;
  			extraWaits++;
*************** LWLockWaitForVar(LWLock *lock, uint64 *v
*** 1692,1698 ****
  	 * Fix the process wait semaphore's count for any absorbed wakeups.
  	 */
  	while (extraWaits-- > 0)
! 		PGSemaphoreUnlock(&proc->sem);
  
  	/*
  	 * Now okay to allow cancel/die interrupts.
--- 1692,1698 ----
  	 * Fix the process wait semaphore's count for any absorbed wakeups.
  	 */
  	while (extraWaits-- > 0)
! 		PGSemaphoreUnlock(proc->sem);
  
  	/*
  	 * Now okay to allow cancel/die interrupts.
*************** LWLockUpdateVar(LWLock *lock, uint64 *va
*** 1759,1765 ****
  		/* check comment in LWLockWakeup() about this barrier */
  		pg_write_barrier();
  		waiter->lwWaiting = false;
! 		PGSemaphoreUnlock(&waiter->sem);
  	}
  }
  
--- 1759,1765 ----
  		/* check comment in LWLockWakeup() about this barrier */
  		pg_write_barrier();
  		waiter->lwWaiting = false;
! 		PGSemaphoreUnlock(waiter->sem);
  	}
  }
  
diff --git a/src/backend/storage/lmgr/proc.c b/src/backend/storage/lmgr/proc.c
index 83e9ca1..fc199a6 100644
*** a/src/backend/storage/lmgr/proc.c
--- b/src/backend/storage/lmgr/proc.c
*************** InitProcGlobal(void)
*** 224,230 ****
  		 */
  		if (i < MaxBackends + NUM_AUXILIARY_PROCS)
  		{
! 			PGSemaphoreCreate(&(procs[i].sem));
  			InitSharedLatch(&(procs[i].procLatch));
  			LWLockInitialize(&(procs[i].backendLock), LWTRANCHE_PROC);
  		}
--- 224,230 ----
  		 */
  		if (i < MaxBackends + NUM_AUXILIARY_PROCS)
  		{
! 			procs[i].sem = PGSemaphoreCreate();
  			InitSharedLatch(&(procs[i].procLatch));
  			LWLockInitialize(&(procs[i].backendLock), LWTRANCHE_PROC);
  		}
*************** InitProcess(void)
*** 420,426 ****
  	 * be careful and reinitialize its value here.  (This is not strictly
  	 * necessary anymore, but seems like a good idea for cleanliness.)
  	 */
! 	PGSemaphoreReset(&MyProc->sem);
  
  	/*
  	 * Arrange to clean up at backend exit.
--- 420,426 ----
  	 * be careful and reinitialize its value here.  (This is not strictly
  	 * necessary anymore, but seems like a good idea for cleanliness.)
  	 */
! 	PGSemaphoreReset(MyProc->sem);
  
  	/*
  	 * Arrange to clean up at backend exit.
*************** InitAuxiliaryProcess(void)
*** 575,581 ****
  	 * be careful and reinitialize its value here.  (This is not strictly
  	 * necessary anymore, but seems like a good idea for cleanliness.)
  	 */
! 	PGSemaphoreReset(&MyProc->sem);
  
  	/*
  	 * Arrange to clean up at process exit.
--- 575,581 ----
  	 * be careful and reinitialize its value here.  (This is not strictly
  	 * necessary anymore, but seems like a good idea for cleanliness.)
  	 */
! 	PGSemaphoreReset(MyProc->sem);
  
  	/*
  	 * Arrange to clean up at process exit.
diff --git a/src/backend/storage/lmgr/spin.c b/src/backend/storage/lmgr/spin.c
index 5039141..a6510a0 100644
*** a/src/backend/storage/lmgr/spin.c
--- b/src/backend/storage/lmgr/spin.c
***************
*** 23,33 ****
  #include "postgres.h"
  
  #include "storage/pg_sema.h"
  #include "storage/spin.h"
  
  
  #ifndef HAVE_SPINLOCKS
! PGSemaphore SpinlockSemaArray;
  #endif
  
  /*
--- 23,34 ----
  #include "postgres.h"
  
  #include "storage/pg_sema.h"
+ #include "storage/shmem.h"
  #include "storage/spin.h"
  
  
  #ifndef HAVE_SPINLOCKS
! PGSemaphore *SpinlockSemaArray;
  #endif
  
  /*
*************** PGSemaphore SpinlockSemaArray;
*** 37,43 ****
  Size
  SpinlockSemaSize(void)
  {
! 	return SpinlockSemas() * sizeof(PGSemaphoreData);
  }
  
  #ifdef HAVE_SPINLOCKS
--- 38,44 ----
  Size
  SpinlockSemaSize(void)
  {
! 	return SpinlockSemas() * sizeof(PGSemaphore);
  }
  
  #ifdef HAVE_SPINLOCKS
*************** SpinlockSemas(void)
*** 67,82 ****
  }
  
  /*
!  * Initialize semaphores.
   */
! extern void
! SpinlockSemaInit(PGSemaphore spinsemas)
  {
! 	int			i;
  	int			nsemas = SpinlockSemas();
  
  	for (i = 0; i < nsemas; ++i)
! 		PGSemaphoreCreate(&spinsemas[i]);
  	SpinlockSemaArray = spinsemas;
  }
  
--- 68,91 ----
  }
  
  /*
!  * Initialize spinlock emulation.
!  *
!  * This must be called after PGReserveSemaphores().
   */
! void
! SpinlockSemaInit(void)
  {
! 	PGSemaphore *spinsemas;
  	int			nsemas = SpinlockSemas();
+ 	int			i;
  
+ 	/*
+ 	 * We must use ShmemAllocUnlocked(), since the spinlock protecting
+ 	 * ShmemAlloc() obviously can't be ready yet.
+ 	 */
+ 	spinsemas = (PGSemaphore *) ShmemAllocUnlocked(SpinlockSemaSize());
  	for (i = 0; i < nsemas; ++i)
! 		spinsemas[i] = PGSemaphoreCreate();
  	SpinlockSemaArray = spinsemas;
  }
  
*************** s_unlock_sema(volatile slock_t *lock)
*** 109,115 ****
  
  	if (lockndx <= 0 || lockndx > NUM_SPINLOCK_SEMAPHORES)
  		elog(ERROR, "invalid spinlock number: %d", lockndx);
! 	PGSemaphoreUnlock(&SpinlockSemaArray[lockndx - 1]);
  }
  
  bool
--- 118,124 ----
  
  	if (lockndx <= 0 || lockndx > NUM_SPINLOCK_SEMAPHORES)
  		elog(ERROR, "invalid spinlock number: %d", lockndx);
! 	PGSemaphoreUnlock(SpinlockSemaArray[lockndx - 1]);
  }
  
  bool
*************** tas_sema(volatile slock_t *lock)
*** 128,134 ****
  	if (lockndx <= 0 || lockndx > NUM_SPINLOCK_SEMAPHORES)
  		elog(ERROR, "invalid spinlock number: %d", lockndx);
  	/* Note that TAS macros return 0 if *success* */
! 	return !PGSemaphoreTryLock(&SpinlockSemaArray[lockndx - 1]);
  }
  
  #endif   /* !HAVE_SPINLOCKS */
--- 137,143 ----
  	if (lockndx <= 0 || lockndx > NUM_SPINLOCK_SEMAPHORES)
  		elog(ERROR, "invalid spinlock number: %d", lockndx);
  	/* Note that TAS macros return 0 if *success* */
! 	return !PGSemaphoreTryLock(SpinlockSemaArray[lockndx - 1]);
  }
  
  #endif   /* !HAVE_SPINLOCKS */
diff --git a/src/include/storage/pg_sema.h b/src/include/storage/pg_sema.h
index 2c94183..63546eb 100644
*** a/src/include/storage/pg_sema.h
--- b/src/include/storage/pg_sema.h
***************
*** 21,72 ****
  #define PG_SEMA_H
  
  /*
!  * PGSemaphoreData and pointer type PGSemaphore are the data structure
!  * representing an individual semaphore.  The contents of PGSemaphoreData
!  * vary across implementations and must never be touched by platform-
!  * independent code.  PGSemaphoreData structures are always allocated
!  * in shared memory (to support implementations where the data changes during
!  * lock/unlock).
   *
!  * pg_config.h must define exactly one of the USE_xxx_SEMAPHORES symbols.
   */
! 
! #ifdef USE_NAMED_POSIX_SEMAPHORES
! 
! #include <semaphore.h>
! 
! typedef sem_t *PGSemaphoreData;
! #endif
! 
! #ifdef USE_UNNAMED_POSIX_SEMAPHORES
! 
! #include <semaphore.h>
! 
! typedef sem_t PGSemaphoreData;
! #endif
! 
! #ifdef USE_SYSV_SEMAPHORES
! 
! typedef struct PGSemaphoreData
! {
! 	int			semId;			/* semaphore set identifier */
! 	int			semNum;			/* semaphore number within set */
! } PGSemaphoreData;
! #endif
! 
! #ifdef USE_WIN32_SEMAPHORES
! 
! typedef HANDLE PGSemaphoreData;
  #endif
  
- typedef PGSemaphoreData *PGSemaphore;
  
  
  /* Module initialization (called during postmaster start or shmem reinit) */
  extern void PGReserveSemaphores(int maxSemas, int port);
  
! /* Initialize a PGSemaphore structure to represent a sema with count 1 */
! extern void PGSemaphoreCreate(PGSemaphore sema);
  
  /* Reset a previously-initialized PGSemaphore to have count 0 */
  extern void PGSemaphoreReset(PGSemaphore sema);
--- 21,50 ----
  #define PG_SEMA_H
  
  /*
!  * struct PGSemaphoreData and pointer type PGSemaphore are the data structure
!  * representing an individual semaphore.  The contents of PGSemaphoreData vary
!  * across implementations and must never be touched by platform-independent
!  * code; hence, PGSemaphoreData is declared as an opaque struct here.
   *
!  * However, Windows is sufficiently unlike our other ports that it doesn't
!  * seem worth insisting on ABI compatibility for Windows too.  Hence, on
!  * that platform just define PGSemaphore as HANDLE.
   */
! #ifndef USE_WIN32_SEMAPHORES
! typedef struct PGSemaphoreData *PGSemaphore;
! #else
! typedef HANDLE PGSemaphore;
  #endif
  
  
+ /* Report amount of shared memory needed */
+ extern Size PGSemaphoreShmemSize(int maxSemas);
  
  /* Module initialization (called during postmaster start or shmem reinit) */
  extern void PGReserveSemaphores(int maxSemas, int port);
  
! /* Allocate a PGSemaphore structure with initial count 1 */
! extern PGSemaphore PGSemaphoreCreate(void);
  
  /* Reset a previously-initialized PGSemaphore to have count 0 */
  extern void PGSemaphoreReset(PGSemaphore sema);
diff --git a/src/include/storage/proc.h b/src/include/storage/proc.h
index 6fa7125..0344f42 100644
*** a/src/include/storage/proc.h
--- b/src/include/storage/proc.h
*************** struct PGPROC
*** 87,93 ****
  	SHM_QUEUE	links;			/* list link if process is in a list */
  	PGPROC	  **procgloballist; /* procglobal list that owns this PGPROC */
  
! 	PGSemaphoreData sem;		/* ONE semaphore to sleep on */
  	int			waitStatus;		/* STATUS_WAITING, STATUS_OK or STATUS_ERROR */
  
  	Latch		procLatch;		/* generic latch for process */
--- 87,93 ----
  	SHM_QUEUE	links;			/* list link if process is in a list */
  	PGPROC	  **procgloballist; /* procglobal list that owns this PGPROC */
  
! 	PGSemaphore sem;			/* ONE semaphore to sleep on */
  	int			waitStatus;		/* STATUS_WAITING, STATUS_OK or STATUS_ERROR */
  
  	Latch		procLatch;		/* generic latch for process */
*************** struct PGPROC
*** 116,122 ****
  	proclist_node lwWaitLink;	/* position in LW lock wait list */
  
  	/* Support for condition variables. */
! 	proclist_node	cvWaitLink;	/* position in CV wait list */
  
  	/* Info about lock the process is currently waiting for, if any. */
  	/* waitLock and waitProcLock are NULL if not currently waiting. */
--- 116,122 ----
  	proclist_node lwWaitLink;	/* position in LW lock wait list */
  
  	/* Support for condition variables. */
! 	proclist_node cvWaitLink;	/* position in CV wait list */
  
  	/* Info about lock the process is currently waiting for, if any. */
  	/* waitLock and waitProcLock are NULL if not currently waiting. */
diff --git a/src/include/storage/shmem.h b/src/include/storage/shmem.h
index 2560e6c..e4faebf 100644
*** a/src/include/storage/shmem.h
--- b/src/include/storage/shmem.h
*************** extern void InitShmemAccess(void *seghdr
*** 36,41 ****
--- 36,42 ----
  extern void InitShmemAllocation(void);
  extern void *ShmemAlloc(Size size);
  extern void *ShmemAllocNoError(Size size);
+ extern void *ShmemAllocUnlocked(Size size);
  extern bool ShmemAddrIsValid(const void *addr);
  extern void InitShmemIndex(void);
  extern HTAB *ShmemInitHash(const char *name, long init_size, long max_size,
diff --git a/src/include/storage/spin.h b/src/include/storage/spin.h
index 5041225..b95c9bc 100644
*** a/src/include/storage/spin.h
--- b/src/include/storage/spin.h
*************** extern int	SpinlockSemas(void);
*** 70,77 ****
  extern Size SpinlockSemaSize(void);
  
  #ifndef HAVE_SPINLOCKS
! extern void SpinlockSemaInit(PGSemaphore);
! extern PGSemaphore SpinlockSemaArray;
  #endif
  
  #endif   /* SPIN_H */
--- 70,77 ----
  extern Size SpinlockSemaSize(void);
  
  #ifndef HAVE_SPINLOCKS
! extern void SpinlockSemaInit(void);
! extern PGSemaphore *SpinlockSemaArray;
  #endif
  
  #endif   /* SPIN_H */