database/postgres
database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-04-27 22:56:53 +03:00
Code

Consistently test for in-use shared memory.

Browse Source 
postmaster startup scrutinizes any shared memory segment recorded in
postmaster.pid, exiting if that segment matches the current data
directory and has an attached process.  When the postmaster.pid file was
missing, a starting postmaster used weaker checks.  Change to use the
same checks in both scenarios.  This increases the chance of a startup
failure, in lieu of data corruption, if the DBA does "kill -9 `head -n1
postmaster.pid` && rm postmaster.pid && pg_ctl -w start".  A postmaster
will no longer recycle segments pertaining to other data directories.
That's good for production, but it's bad for integration tests that
crash a postmaster and immediately delete its data directory.  Such a
test now leaks a segment indefinitely.  No "make check-world" test does
that.  win32_shmem.c already avoided all these problems.  In 9.6 and
later, enhance PostgresNode to facilitate testing.  Back-patch to 9.4
(all supported versions).

Reviewed by Daniel Gustafsson and Kyotaro HORIGUCHI.

Discussion: https://postgr.es/m/20130911033341.GD225735@tornado.leadboat.com
This commit is contained in:
Noah Misch 2019-04-03 17:03:46 -07:00
parent db4bc99948
commit 7c414cdc39
11 changed files with 469 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/Makefile.global.in
View File

@ -383,12 +383,12 @@ ifeq ($(enable_tap_tests),yes)
define prove_installcheck define prove_installcheck
rm -rf $(CURDIR)/tmp_check/log rm -rf $(CURDIR)/tmp_check/log
cd $(srcdir) && TESTDIR='$(CURDIR)' PATH="$(bindir):$$PATH" PGPORT='6$(DEF_PGPORT)' top_builddir='$(CURDIR)/$(top_builddir)' PG_REGRESS='$(CURDIR)/$(top_builddir)/src/test/regress/pg_regress' $(PROVE) $(PG_PROVE_FLAGS) $(PROVE_FLAGS) $(if $(PROVE_TESTS),$(PROVE_TESTS),t/*.pl) cd $(srcdir) && TESTDIR='$(CURDIR)' PATH="$(bindir):$$PATH" PGPORT='6$(DEF_PGPORT)' top_builddir='$(CURDIR)/$(top_builddir)' PG_REGRESS='$(CURDIR)/$(top_builddir)/src/test/regress/pg_regress' REGRESS_SHLIB='$(abs_top_builddir)/src/test/regress/regress$(DLSUFFIX)' $(PROVE) $(PG_PROVE_FLAGS) $(PROVE_FLAGS) $(if $(PROVE_TESTS),$(PROVE_TESTS),t/*.pl)
endef endef
define prove_check define prove_check
rm -rf $(CURDIR)/tmp_check/log rm -rf $(CURDIR)/tmp_check/log
cd $(srcdir) && TESTDIR='$(CURDIR)' $(with_temp_install) PGPORT='6$(DEF_PGPORT)' PG_REGRESS='$(CURDIR)/$(top_builddir)/src/test/regress/pg_regress' $(PROVE) $(PG_PROVE_FLAGS) $(PROVE_FLAGS) $(if $(PROVE_TESTS),$(PROVE_TESTS),t/*.pl) cd $(srcdir) && TESTDIR='$(CURDIR)' $(with_temp_install) PGPORT='6$(DEF_PGPORT)' PG_REGRESS='$(CURDIR)/$(top_builddir)/src/test/regress/pg_regress' REGRESS_SHLIB='$(abs_top_builddir)/src/test/regress/regress$(DLSUFFIX)' $(PROVE) $(PG_PROVE_FLAGS) $(PROVE_FLAGS) $(if $(PROVE_TESTS),$(PROVE_TESTS),t/*.pl)
endef endef
else else

253
src/backend/port/sysv_shmem.c
View File

@ -71,6 +71,26 @@
typedef key_t IpcMemoryKey; /* shared memory key passed to shmget(2) */ typedef key_t IpcMemoryKey; /* shared memory key passed to shmget(2) */
typedef int IpcMemoryId; /* shared memory ID returned by shmget(2) */ typedef int IpcMemoryId; /* shared memory ID returned by shmget(2) */
/*
* How does a given IpcMemoryId relate to this PostgreSQL process?
*
* One could recycle unattached segments of different data directories if we
* distinguished that case from other SHMSTATE_FOREIGN cases. Doing so would
* cause us to visit less of the key space, making us less likely to detect a
* SHMSTATE_ATTACHED key. It would also complicate the concurrency analysis,
* in that postmasters of different data directories could simultaneously
* attempt to recycle a given key. We'll waste keys longer in some cases, but
* avoiding the problems of the alternative justifies that loss.
*/
typedef enum
{
SHMSTATE_ANALYSIS_FAILURE, /* unexpected failure to analyze the ID */
SHMSTATE_ATTACHED, /* pertinent to DataDir, has attached PIDs */
SHMSTATE_ENOENT, /* no segment of that ID */
SHMSTATE_FOREIGN, /* exists, but not pertinent to DataDir */
SHMSTATE_UNATTACHED /* pertinent to DataDir, no attached PIDs */
} IpcMemoryState;
unsigned long UsedShmemSegID = 0; unsigned long UsedShmemSegID = 0;
void *UsedShmemSegAddr = NULL; void *UsedShmemSegAddr = NULL;
@ -83,8 +103,8 @@ static void *AnonymousShmem = NULL;
static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size); static void *InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size);
static void IpcMemoryDetach(int status, Datum shmaddr); static void IpcMemoryDetach(int status, Datum shmaddr);
static void IpcMemoryDelete(int status, Datum shmId); static void IpcMemoryDelete(int status, Datum shmId);
static PGShmemHeader *PGSharedMemoryAttach(IpcMemoryKey key, static IpcMemoryState PGSharedMemoryAttach(IpcMemoryId shmId,
IpcMemoryId *shmid); PGShmemHeader **addr);
/* /*
@ -288,11 +308,36 @@ IpcMemoryDelete(int status, Datum shmId)
bool bool
PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2) PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2)
{ {
IpcMemoryId shmId = (IpcMemoryId) id2; PGShmemHeader *memAddress;
IpcMemoryState state;
state = PGSharedMemoryAttach((IpcMemoryId) id2, &memAddress);
if (memAddress && shmdt(memAddress) < 0)
elog(LOG, "shmdt(%p) failed: %m", memAddress);
switch (state)
{
case SHMSTATE_ENOENT:
case SHMSTATE_FOREIGN:
case SHMSTATE_UNATTACHED:
return false;
case SHMSTATE_ANALYSIS_FAILURE:
case SHMSTATE_ATTACHED:
return true;
}
return true;
}
/* See comment at IpcMemoryState. */
static IpcMemoryState
PGSharedMemoryAttach(IpcMemoryId shmId,
PGShmemHeader **addr)
{
struct shmid_ds shmStat; struct shmid_ds shmStat;
struct stat statbuf; struct stat statbuf;
PGShmemHeader *hdr; PGShmemHeader *hdr;
*addr = NULL;
/* /*
* We detect whether a shared memory segment is in use by seeing whether * We detect whether a shared memory segment is in use by seeing whether
* it (a) exists and (b) has any processes attached to it. * it (a) exists and (b) has any processes attached to it.
@ -305,7 +350,7 @@ PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2)
* exists. * exists.
*/ */
if (errno == EINVAL) if (errno == EINVAL)
return false; return SHMSTATE_ENOENT;
/* /*
* EACCES implies that the segment belongs to some other userid, which * EACCES implies that the segment belongs to some other userid, which
@ -313,7 +358,7 @@ PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2)
* is relevant to our data directory). * is relevant to our data directory).
*/ */
if (errno == EACCES) if (errno == EACCES)
return false; return SHMSTATE_FOREIGN;
/* /*
* Some Linux kernel versions (in fact, all of them as of July 2007) * Some Linux kernel versions (in fact, all of them as of July 2007)
@ -324,7 +369,7 @@ PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2)
*/ */
#ifdef HAVE_LINUX_EIDRM_BUG #ifdef HAVE_LINUX_EIDRM_BUG
if (errno == EIDRM) if (errno == EIDRM)
return false; return SHMSTATE_ENOENT;
#endif #endif
/* /*
@ -332,25 +377,26 @@ PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2)
* only likely case is EIDRM, which implies that the segment has been * only likely case is EIDRM, which implies that the segment has been
* IPC_RMID'd but there are still processes attached to it. * IPC_RMID'd but there are still processes attached to it.
*/ */
return true; return SHMSTATE_ANALYSIS_FAILURE;
} }
/* If it has no attached processes, it's not in use */
if (shmStat.shm_nattch == 0)
return false;
/* /*
* Try to attach to the segment and see if it matches our data directory. * Try to attach to the segment and see if it matches our data directory.
* This avoids shmid-conflict problems on machines that are running * This avoids shmid-conflict problems on machines that are running
* several postmasters under the same userid. * several postmasters under the same userid.
*/ */
if (stat(DataDir, &statbuf) < 0) if (stat(DataDir, &statbuf) < 0)
return true; /* if can't stat, be conservative */ return SHMSTATE_ANALYSIS_FAILURE; /* can't stat; be conservative */
hdr = (PGShmemHeader *) shmat(shmId, NULL, PG_SHMAT_FLAGS);
/*
* If we can't attach, be conservative. This may fail if postmaster.pid
* furnished the shmId and another user created a world-readable segment
* of the same shmId.
*/
hdr = (PGShmemHeader *) shmat(shmId, UsedShmemSegAddr, PG_SHMAT_FLAGS);
if (hdr == (PGShmemHeader *) -1) if (hdr == (PGShmemHeader *) -1)
return true; /* if can't attach, be conservative */ return SHMSTATE_ANALYSIS_FAILURE;
*addr = hdr;
if (hdr->magic != PGShmemMagic || if (hdr->magic != PGShmemMagic ||
hdr->device != statbuf.st_dev || hdr->device != statbuf.st_dev ||
@ -358,16 +404,12 @@ PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2)
{ {
/* /*
* It's either not a Postgres segment, or not one for my data * It's either not a Postgres segment, or not one for my data
* directory. In either case it poses no threat. * directory.
*/ */
shmdt((void *) hdr); return SHMSTATE_FOREIGN;
return false;
} }
/* Trouble --- looks a lot like there's still live backends */ return shmStat.shm_nattch == 0 ? SHMSTATE_UNATTACHED : SHMSTATE_ATTACHED;
shmdt((void *) hdr);
return true;
} }
#ifdef USE_ANONYMOUS_SHMEM #ifdef USE_ANONYMOUS_SHMEM
@ -543,25 +585,21 @@ AnonymousShmemDetach(int status, Datum arg)
* standard header. Also, register an on_shmem_exit callback to release * standard header. Also, register an on_shmem_exit callback to release
* the storage. * the storage.
* *
* Dead Postgres segments are recycled if found, but we do not fail upon * Dead Postgres segments pertinent to this DataDir are recycled if found, but
* collision with non-Postgres shmem segments. The idea here is to detect and * we do not fail upon collision with foreign shmem segments. The idea here
* re-use keys that may have been assigned by a crashed postmaster or backend. * is to detect and re-use keys that may have been assigned by a crashed
* * postmaster or backend.
* makePrivate means to always create a new segment, rather than attach to
* or recycle any existing segment.
* *
* The port number is passed for possible use as a key (for SysV, we use * 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, * it to generate the starting shmem key).
* zero will be passed.
*/ */
PGShmemHeader * PGShmemHeader *
PGSharedMemoryCreate(Size size, bool makePrivate, int port, PGSharedMemoryCreate(Size size, int port,
PGShmemHeader **shim) PGShmemHeader **shim)
{ {
IpcMemoryKey NextShmemSegID; IpcMemoryKey NextShmemSegID;
void *memAddress; void *memAddress;
PGShmemHeader *hdr; PGShmemHeader *hdr;
IpcMemoryId shmid;
struct stat statbuf; struct stat statbuf;
Size sysvsize; Size sysvsize;
@ -592,11 +630,20 @@ PGSharedMemoryCreate(Size size, bool makePrivate, int port,
/* Make sure PGSharedMemoryAttach doesn't fail without need */ /* Make sure PGSharedMemoryAttach doesn't fail without need */
UsedShmemSegAddr = NULL; UsedShmemSegAddr = NULL;
/* Loop till we find a free IPC key */ /*
NextShmemSegID = port * 1000; * 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 ensure that,
* but prefer fixing it over coping here.)
*/
NextShmemSegID = 1 + port * 1000;
for (NextShmemSegID++;; NextShmemSegID++) for (;;)
{ {
IpcMemoryId shmid;
PGShmemHeader *oldhdr;
IpcMemoryState state;
/* Try to create new segment */ /* Try to create new segment */
memAddress = InternalIpcMemoryCreate(NextShmemSegID, sysvsize); memAddress = InternalIpcMemoryCreate(NextShmemSegID, sysvsize);
if (memAddress) if (memAddress)
@ -604,58 +651,69 @@ PGSharedMemoryCreate(Size size, bool makePrivate, int port,
/* Check shared memory and possibly remove and recreate */ /* Check shared memory and possibly remove and recreate */
if (makePrivate) /* a standalone backend shouldn't do this */ /*
continue; * 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, &oldhdr);
if ((memAddress = PGSharedMemoryAttach(NextShmemSegID, &shmid)) == NULL) switch (state)
continue; /* can't attach, not one of mine */ {
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)));
case SHMSTATE_ENOENT:
/* /*
* If I am not the creator and it belongs to an extant process, * To our surprise, some other process deleted since our last
* continue. * InternalIpcMemoryCreate(). Moments earlier, we would have
* seen SHMSTATE_FOREIGN. Try that same ID again.
*/ */
hdr = (PGShmemHeader *) memAddress; elog(LOG,
if (hdr->creatorPID != getpid()) "shared memory block (key %lu, ID %lu) deleted during startup",
{ (unsigned long) NextShmemSegID,
if (kill(hdr->creatorPID, 0) == 0 || errno != ESRCH) (unsigned long) shmid);
{ break;
shmdt(memAddress); case SHMSTATE_FOREIGN:
continue; /* segment belongs to a live process */ NextShmemSegID++;
} break;
} case SHMSTATE_UNATTACHED:
/* /*
* The segment appears to be from a dead Postgres process, or from a * The segment pertains to DataDir, and every process that had
* previous cycle of life in this same process. Zap it, if possible, * used it has died or detached. Zap it, if possible, and any
* and any associated dynamic shared memory segments, as well. This * associated dynamic shared memory segments, as well. This
* probably shouldn't fail, but if it does, assume the segment belongs * shouldn't fail, but if it does, assume the segment belongs
* to someone else after all, and continue quietly. * 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 (hdr->dsm_control != 0) if (oldhdr->dsm_control != 0)
dsm_cleanup_using_control_segment(hdr->dsm_control); dsm_cleanup_using_control_segment(oldhdr->dsm_control);
shmdt(memAddress);
if (shmctl(shmid, IPC_RMID, NULL) < 0) if (shmctl(shmid, IPC_RMID, NULL) < 0)
continue; NextShmemSegID++;
/*
* Now try again to create the segment.
*/
memAddress = InternalIpcMemoryCreate(NextShmemSegID, sysvsize);
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.
*/
} }
/* if (oldhdr && shmdt(oldhdr) < 0)
* OK, we created a new segment. Mark it as created by this process. The elog(LOG, "shmdt(%p) failed: %m", oldhdr);
* order of assignments here is critical so that another Postgres process }
* can't see the header as valid but belonging to an invalid PID!
*/ /* Initialize new segment. */
hdr = (PGShmemHeader *) memAddress; hdr = (PGShmemHeader *) memAddress;
hdr->creatorPID = getpid(); hdr->creatorPID = getpid();
hdr->magic = PGShmemMagic; hdr->magic = PGShmemMagic;
@ -715,7 +773,8 @@ void
PGSharedMemoryReAttach(void) PGSharedMemoryReAttach(void)
{ {
IpcMemoryId shmid; IpcMemoryId shmid;
void *hdr; PGShmemHeader *hdr;
IpcMemoryState state;
void *origUsedShmemSegAddr = UsedShmemSegAddr; void *origUsedShmemSegAddr = UsedShmemSegAddr;
Assert(UsedShmemSegAddr != NULL); Assert(UsedShmemSegAddr != NULL);
@ -728,14 +787,18 @@ PGSharedMemoryReAttach(void)
#endif #endif
elog(DEBUG3, "attaching to %p", UsedShmemSegAddr); elog(DEBUG3, "attaching to %p", UsedShmemSegAddr);
hdr = (void *) PGSharedMemoryAttach((IpcMemoryKey) UsedShmemSegID, &shmid); shmid = shmget(UsedShmemSegID, sizeof(PGShmemHeader), 0);
if (hdr == NULL) if (shmid < 0)
state = SHMSTATE_FOREIGN;
else
state = PGSharedMemoryAttach(shmid, &hdr);
if (state != SHMSTATE_ATTACHED)
elog(FATAL, "could not reattach to shared memory (key=%d, addr=%p): %m", elog(FATAL, "could not reattach to shared memory (key=%d, addr=%p): %m",
(int) UsedShmemSegID, UsedShmemSegAddr); (int) UsedShmemSegID, UsedShmemSegAddr);
if (hdr != origUsedShmemSegAddr) if (hdr != origUsedShmemSegAddr)
elog(FATAL, "reattaching to shared memory returned unexpected address (got %p, expected %p)", elog(FATAL, "reattaching to shared memory returned unexpected address (got %p, expected %p)",
hdr, origUsedShmemSegAddr); hdr, origUsedShmemSegAddr);
dsm_set_control_handle(((PGShmemHeader *) hdr)->dsm_control); dsm_set_control_handle(hdr->dsm_control);
UsedShmemSegAddr = hdr; /* probably redundant */ UsedShmemSegAddr = hdr; /* probably redundant */
} }
@ -811,31 +874,3 @@ PGSharedMemoryDetach(void)
} }
#endif #endif
} }
/*
* Attach to shared memory and make sure it has a Postgres header
*
* Returns attach address if OK, else NULL
*/
static PGShmemHeader *
PGSharedMemoryAttach(IpcMemoryKey key, IpcMemoryId *shmid)
{
PGShmemHeader *hdr;
if ((*shmid = shmget(key, sizeof(PGShmemHeader), 0)) < 0)
return NULL;
hdr = (PGShmemHeader *) shmat(*shmid, UsedShmemSegAddr, PG_SHMAT_FLAGS);
if (hdr == (PGShmemHeader *) -1)
return NULL; /* failed: must be some other app's */
if (hdr->magic != PGShmemMagic)
{
shmdt((void *) hdr);
return NULL; /* segment belongs to a non-Postgres app */
}
return hdr;
}

7
src/backend/port/win32_shmem.c
View File

@ -109,14 +109,9 @@ PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2)
* *
* Create a shared memory segment of the given size and initialize its * Create a shared memory segment of the given size and initialize its
* standard header. * standard header.
*
* makePrivate means to always create a new segment, rather than attach to
* or recycle any existing segment. On win32, we always create a new segment,
* since there is no need for recycling (segments go away automatically
* when the last backend exits)
*/ */
PGShmemHeader * PGShmemHeader *
PGSharedMemoryCreate(Size size, bool makePrivate, int port, PGSharedMemoryCreate(Size size, int port,
PGShmemHeader **shim) PGShmemHeader **shim)
{ {
void *memAddress; void *memAddress;

12
src/backend/postmaster/postmaster.c
View File

@ -2558,7 +2558,7 @@ reset_shared(int port)
* determine IPC keys. This helps ensure that we will clean up dead IPC * determine IPC keys. This helps ensure that we will clean up dead IPC
* objects if the postmaster crashes and is restarted. * objects if the postmaster crashes and is restarted.
*/ */
CreateSharedMemoryAndSemaphores(false, port); CreateSharedMemoryAndSemaphores(port);
} }
@ -4907,7 +4907,7 @@ SubPostmasterMain(int argc, char *argv[])
InitProcess(); InitProcess();
/* Attach process to shared data structures */ /* Attach process to shared data structures */
CreateSharedMemoryAndSemaphores(false, 0); CreateSharedMemoryAndSemaphores(0);
/* And run the backend */ /* And run the backend */
BackendRun(&port); /* does not return */ BackendRun(&port); /* does not return */
@ -4921,7 +4921,7 @@ SubPostmasterMain(int argc, char *argv[])
InitAuxiliaryProcess(); InitAuxiliaryProcess();
/* Attach process to shared data structures */ /* Attach process to shared data structures */
CreateSharedMemoryAndSemaphores(false, 0); CreateSharedMemoryAndSemaphores(0);
AuxiliaryProcessMain(argc - 2, argv + 2); /* does not return */ AuxiliaryProcessMain(argc - 2, argv + 2); /* does not return */
} }
@ -4934,7 +4934,7 @@ SubPostmasterMain(int argc, char *argv[])
InitProcess(); InitProcess();
/* Attach process to shared data structures */ /* Attach process to shared data structures */
CreateSharedMemoryAndSemaphores(false, 0); CreateSharedMemoryAndSemaphores(0);
AutoVacLauncherMain(argc - 2, argv + 2); /* does not return */ AutoVacLauncherMain(argc - 2, argv + 2); /* does not return */
} }
@ -4947,7 +4947,7 @@ SubPostmasterMain(int argc, char *argv[])
InitProcess(); InitProcess();
/* Attach process to shared data structures */ /* Attach process to shared data structures */
CreateSharedMemoryAndSemaphores(false, 0); CreateSharedMemoryAndSemaphores(0);
AutoVacWorkerMain(argc - 2, argv + 2); /* does not return */ AutoVacWorkerMain(argc - 2, argv + 2); /* does not return */
} }
@ -4965,7 +4965,7 @@ SubPostmasterMain(int argc, char *argv[])
InitProcess(); InitProcess();
/* Attach process to shared data structures */ /* Attach process to shared data structures */
CreateSharedMemoryAndSemaphores(false, 0); CreateSharedMemoryAndSemaphores(0);
/* Fetch MyBgworkerEntry from shared memory */ /* Fetch MyBgworkerEntry from shared memory */
shmem_slot = atoi(argv[1] + 15); shmem_slot = atoi(argv[1] + 15);

14
src/backend/storage/ipc/ipci.c
View File

@ -88,12 +88,9 @@ RequestAddinShmemSpace(Size size)
* through the same code as before. (Note that the called routines mostly * through the same code as before. (Note that the called routines mostly
* check IsUnderPostmaster, rather than EXEC_BACKEND, to detect this case. * check IsUnderPostmaster, rather than EXEC_BACKEND, to detect this case.
* This is a bit code-wasteful and could be cleaned up.) * This is a bit code-wasteful and could be cleaned up.)
*
* If "makePrivate" is true then we only need private memory, not shared
* memory. This is true for a standalone backend, false for a postmaster.
*/ */
void void
CreateSharedMemoryAndSemaphores(bool makePrivate, int port) CreateSharedMemoryAndSemaphores(int port)
{ {
PGShmemHeader *shim = NULL; PGShmemHeader *shim = NULL;
@ -166,7 +163,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
/* /*
* Create the shmem segment * Create the shmem segment
*/ */
seghdr = PGSharedMemoryCreate(size, makePrivate, port, &shim); seghdr = PGSharedMemoryCreate(size, port, &shim);
InitShmemAccess(seghdr); InitShmemAccess(seghdr);
@ -187,12 +184,9 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
{ {
/* /*
* We are reattaching to an existing shared memory segment. This * We are reattaching to an existing shared memory segment. This
* should only be reached in the EXEC_BACKEND case, and even then only * should only be reached in the EXEC_BACKEND case.
* with makePrivate == false.
*/ */
#ifdef EXEC_BACKEND #ifndef EXEC_BACKEND
Assert(!makePrivate);
#else
elog(PANIC, "should be attached to shared memory already"); elog(PANIC, "should be attached to shared memory already");
#endif #endif
} }

6
src/backend/utils/init/postinit.c
View File

@ -415,9 +415,11 @@ InitCommunication(void)
{ {
/* /*
* We're running a postgres bootstrap process or a standalone backend. * We're running a postgres bootstrap process or a standalone backend.
* Create private "shmem" and semaphores. * Though we won't listen on PostPortNumber, use it to select a shmem
* key. This increases the chance of detecting a leftover live
* backend of this DataDir.
*/ */
CreateSharedMemoryAndSemaphores(true, 0); CreateSharedMemoryAndSemaphores(PostPortNumber);
} }
} }

2
src/include/storage/ipc.h
View File

@ -75,6 +75,6 @@ extern void on_exit_reset(void);
/* ipci.c */ /* ipci.c */
extern PGDLLIMPORT shmem_startup_hook_type shmem_startup_hook; extern PGDLLIMPORT shmem_startup_hook_type shmem_startup_hook;
extern void CreateSharedMemoryAndSemaphores(bool makePrivate, int port); extern void CreateSharedMemoryAndSemaphores(int port);
#endif /* IPC_H */ #endif /* IPC_H */

6
src/include/storage/pg_shmem.h
View File

@ -30,7 +30,7 @@ typedef struct PGShmemHeader /* standard header for all Postgres shmem */
{ {
int32 magic; /* magic # to identify Postgres segments */ int32 magic; /* magic # to identify Postgres segments */
#define PGShmemMagic 679834894 #define PGShmemMagic 679834894
pid_t creatorPID; /* PID of creating process */ pid_t creatorPID; /* PID of creating process (set but unread) */
Size totalsize; /* total size of segment */ Size totalsize; /* total size of segment */
Size freeoffset; /* offset to first free space */ Size freeoffset; /* offset to first free space */
dsm_handle dsm_control; /* ID of dynamic shared memory control seg */ dsm_handle dsm_control; /* ID of dynamic shared memory control seg */
@ -64,8 +64,8 @@ extern void PGSharedMemoryReAttach(void);
extern void PGSharedMemoryNoReAttach(void); extern void PGSharedMemoryNoReAttach(void);
#endif #endif
extern PGShmemHeader *PGSharedMemoryCreate(Size size, bool makePrivate, extern PGShmemHeader *PGSharedMemoryCreate(Size size, int port,
int port, PGShmemHeader **shim); PGShmemHeader **shim);
extern bool PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2); extern bool PGSharedMemoryIsInUse(unsigned long id1, unsigned long id2);
extern void PGSharedMemoryDetach(void); extern void PGSharedMemoryDetach(void);

176
src/test/perl/PostgresNode.pm
View File

@ -100,7 +100,8 @@ our @EXPORT = qw(
get_new_node get_new_node
); );
our ($test_localhost, $test_pghost, $last_port_assigned, @all_nodes); our ($use_tcp, $test_localhost, $test_pghost, $last_host_assigned,
$last_port_assigned, @all_nodes);
# Windows path to virtual file system root # Windows path to virtual file system root
@ -114,11 +115,12 @@ if ($Config{osname} eq 'msys')
INIT INIT
{ {
# PGHOST is set once and for all through a single series of tests when # Set PGHOST for backward compatibility. This doesn't work for own_host
# this module is loaded. # nodes, so prefer to not rely on this when writing new tests.
$use_tcp = $TestLib::windows_os;
$test_localhost = "127.0.0.1"; $test_localhost = "127.0.0.1";
$test_pghost = $last_host_assigned = 1;
$TestLib::windows_os ? $test_localhost : TestLib::tempdir_short; $test_pghost = $use_tcp ? $test_localhost : TestLib::tempdir_short;
$ENV{PGHOST} = $test_pghost; $ENV{PGHOST} = $test_pghost;
$ENV{PGDATABASE} = 'postgres'; $ENV{PGDATABASE} = 'postgres';
@ -151,7 +153,10 @@ sub new
_host => $pghost, _host => $pghost,
_basedir => TestLib::tempdir("data_" . $name), _basedir => TestLib::tempdir("data_" . $name),
_name => $name, _name => $name,
_logfile => "$TestLib::log_path/${testname}_${name}.log" }; _logfile_generation => 0,
_logfile_base => "$TestLib::log_path/${testname}_${name}",
_logfile => "$TestLib::log_path/${testname}_${name}.log"
};
bless $self, $class; bless $self, $class;
$self->dump_info; $self->dump_info;
@ -443,8 +448,9 @@ sub init
print $conf "max_wal_senders = 0\n"; print $conf "max_wal_senders = 0\n";
} }
if ($TestLib::windows_os) if ($use_tcp)
{ {
print $conf "unix_socket_directories = ''\n";
print $conf "listen_addresses = '$host'\n"; print $conf "listen_addresses = '$host'\n";
} }
else else
@ -497,12 +503,11 @@ sub backup
{ {
my ($self, $backup_name) = @_; my ($self, $backup_name) = @_;
my $backup_path = $self->backup_dir . '/' . $backup_name; my $backup_path = $self->backup_dir . '/' . $backup_name;
my $port = $self->port;
my $name = $self->name; my $name = $self->name;
print "# Taking pg_basebackup $backup_name from node \"$name\"\n"; print "# Taking pg_basebackup $backup_name from node \"$name\"\n";
TestLib::system_or_bail('pg_basebackup', '-D', $backup_path, '-p', $port, TestLib::system_or_bail('pg_basebackup', '-D', $backup_path, '-h',
'--no-sync'); $self->host, '-p', $self->port, '--no-sync');
print "# Backup finished\n"; print "# Backup finished\n";
} }
@ -610,6 +615,7 @@ sub init_from_backup
{ {
my ($self, $root_node, $backup_name, %params) = @_; my ($self, $root_node, $backup_name, %params) = @_;
my $backup_path = $root_node->backup_dir . '/' . $backup_name; my $backup_path = $root_node->backup_dir . '/' . $backup_name;
my $host = $self->host;
my $port = $self->port; my $port = $self->port;
my $node_name = $self->name; my $node_name = $self->name;
my $root_name = $root_node->name; my $root_name = $root_node->name;
@ -636,23 +642,60 @@ sub init_from_backup
qq( qq(
port = $port port = $port
)); ));
if ($use_tcp)
{
$self->append_conf('postgresql.conf', "listen_addresses = '$host'");
}
else
{
$self->append_conf('postgresql.conf',
"unix_socket_directories = '$host'");
}
$self->enable_streaming($root_node) if $params{has_streaming}; $self->enable_streaming($root_node) if $params{has_streaming};
$self->enable_restoring($root_node) if $params{has_restoring}; $self->enable_restoring($root_node) if $params{has_restoring};
} }
=pod =pod
=item $node->start() =item $node->rotate_logfile()
Switch to a new PostgreSQL log file. This does not alter any running
PostgreSQL process. Subsequent method calls, including pg_ctl invocations,
will use the new name. Return the new name.
=cut
sub rotate_logfile
{
my ($self) = @_;
$self->{_logfile} = sprintf('%s_%d.log',
$self->{_logfile_base},
++$self->{_logfile_generation});
return $self->{_logfile};
}
=pod
=item $node->start(%params) => success_or_failure
Wrapper for pg_ctl start Wrapper for pg_ctl start
Start the node and wait until it is ready to accept connections. Start the node and wait until it is ready to accept connections.
=over
=item fail_ok => 1
By default, failure terminates the entire F<prove> invocation. If given,
instead return a true or false value to indicate success or failure.
=back
=cut =cut
sub start sub start
{ {
my ($self) = @_; my ($self, %params) = @_;
my $port = $self->port; my $port = $self->port;
my $pgdata = $self->data_dir; my $pgdata = $self->data_dir;
my $name = $self->name; my $name = $self->name;
@ -665,10 +708,35 @@ sub start
{ {
print "# pg_ctl start failed; logfile:\n"; print "# pg_ctl start failed; logfile:\n";
print TestLib::slurp_file($self->logfile); print TestLib::slurp_file($self->logfile);
BAIL_OUT("pg_ctl start failed"); BAIL_OUT("pg_ctl start failed") unless $params{fail_ok};
return 0;
} }
$self->_update_pid(1); $self->_update_pid(1);
return 1;
}
=pod
=item $node->kill9()
Send SIGKILL (signal 9) to the postmaster.
Note: if the node is already known stopped, this does nothing.
However, if we think it's running and it's not, it's important for
this to fail. Otherwise, tests might fail to detect server crashes.
=cut
sub kill9
{
my ($self) = @_;
my $name = $self->name;
return unless defined $self->{_pid};
print "### Killing node \"$name\" using signal 9\n";
kill(9, $self->{_pid}) or BAIL_OUT("kill(9, $self->{_pid}) failed");
$self->{_pid} = undef;
return;
} }
=pod =pod
@ -855,7 +923,7 @@ sub _update_pid
=pod =pod
=item PostgresNode->get_new_node(node_name) =item PostgresNode->get_new_node(node_name, %params)
Build a new object of class C<PostgresNode> (or of a subclass, if you have Build a new object of class C<PostgresNode> (or of a subclass, if you have
one), assigning a free port number. Remembers the node, to prevent its port one), assigning a free port number. Remembers the node, to prevent its port
@ -864,6 +932,22 @@ shut down when the test script exits.
You should generally use this instead of C<PostgresNode::new(...)>. You should generally use this instead of C<PostgresNode::new(...)>.
=over
=item port => [1,65535]
By default, this function assigns a port number to each node. Specify this to
force a particular port number. The caller is responsible for evaluating
potential conflicts and privilege requirements.
=item own_host => 1
By default, all nodes use the same PGHOST value. If specified, generate a
PGHOST specific to this node. This allows multiple nodes to use the same
port.
=back
For backwards compatibility, it is also exported as a standalone function, For backwards compatibility, it is also exported as a standalone function,
which can only create objects of class C<PostgresNode>. which can only create objects of class C<PostgresNode>.
@ -872,10 +956,11 @@ which can only create objects of class C<PostgresNode>.
sub get_new_node sub get_new_node
{ {
my $class = 'PostgresNode'; my $class = 'PostgresNode';
$class = shift if 1 < scalar @_; $class = shift if scalar(@_) % 2 != 1;
my $name = shift; my ($name, %params) = @_;
my $found = 0; my $port_is_forced = defined $params{port};
my $port = $last_port_assigned; my $found = $port_is_forced;
my $port = $port_is_forced ? $params{port} : $last_port_assigned;
while ($found == 0) while ($found == 0)
{ {
@ -892,13 +977,15 @@ sub get_new_node
$found = 0 if ($node->port == $port); $found = 0 if ($node->port == $port);
} }
# Check to see if anything else is listening on this TCP port. # Check to see if anything else is listening on this TCP port. Accept
# This is *necessary* on Windows, and seems like a good idea # only ports available for all possible listen_addresses values, so
# on Unixen as well, even though we don't ask the postmaster # the caller can harness this port for the widest range of purposes.
# to open a TCP port on Unix. # This is *necessary* on Windows, and seems like a good idea on Unixen
# as well, even though we don't ask the postmaster to open a TCP port
# on Unix.
if ($found == 1) if ($found == 1)
{ {
my $iaddr = inet_aton($test_localhost); my $iaddr = inet_aton('0.0.0.0');
my $paddr = sockaddr_in($port, $iaddr); my $paddr = sockaddr_in($port, $iaddr);
my $proto = getprotobyname("tcp"); my $proto = getprotobyname("tcp");
@ -914,16 +1001,35 @@ sub get_new_node
} }
} }
print "# Found free port $port\n"; print "# Found port $port\n";
# Select a host.
my $host = $test_pghost;
if ($params{own_host})
{
if ($use_tcp)
{
# This assumes $use_tcp platforms treat every address in
# 127.0.0.1/24, not just 127.0.0.1, as a usable loopback.
$last_host_assigned++;
$last_host_assigned > 254 and BAIL_OUT("too many own_host nodes");
$host = '127.0.0.' . $last_host_assigned;
}
else
{
$host = "$test_pghost/$name"; # Assume $name =~ /^[-_a-zA-Z0-9]+$/
mkdir $host;
}
}
# Lock port number found by creating a new node # Lock port number found by creating a new node
my $node = $class->new($name, $test_pghost, $port); my $node = $class->new($name, $host, $port);
# Add node to list of nodes # Add node to list of nodes
push(@all_nodes, $node); push(@all_nodes, $node);
# And update port for next time # And update port for next time
$last_port_assigned = $port; $port_is_forced or $last_port_assigned = $port;
return $node; return $node;
} }
@ -1276,9 +1382,8 @@ $stderr);
=item $node->command_ok(...) =item $node->command_ok(...)
Runs a shell command like TestLib::command_ok, but with PGPORT Runs a shell command like TestLib::command_ok, but with PGHOST and PGPORT set
set so that the command will default to connecting to this so that the command will default to connecting to this PostgresNode.
PostgresNode.
=cut =cut
@ -1286,6 +1391,7 @@ sub command_ok
{ {
my $self = shift; my $self = shift;
local $ENV{PGHOST} = $self->host;
local $ENV{PGPORT} = $self->port; local $ENV{PGPORT} = $self->port;
TestLib::command_ok(@_); TestLib::command_ok(@_);
@ -1295,7 +1401,7 @@ sub command_ok
=item $node->command_fails(...) - TestLib::command_fails with our PGPORT =item $node->command_fails(...) - TestLib::command_fails with our PGPORT
See command_ok(...) TestLib::command_fails with our connection parameters. See command_ok(...)
=cut =cut
@ -1303,6 +1409,7 @@ sub command_fails
{ {
my $self = shift; my $self = shift;
local $ENV{PGHOST} = $self->host;
local $ENV{PGPORT} = $self->port; local $ENV{PGPORT} = $self->port;
TestLib::command_fails(@_); TestLib::command_fails(@_);
@ -1312,7 +1419,7 @@ sub command_fails
=item $node->command_like(...) =item $node->command_like(...)
TestLib::command_like with our PGPORT. See command_ok(...) TestLib::command_like with our connection parameters. See command_ok(...)
=cut =cut
@ -1320,6 +1427,7 @@ sub command_like
{ {
my $self = shift; my $self = shift;
local $ENV{PGHOST} = $self->host;
local $ENV{PGPORT} = $self->port; local $ENV{PGPORT} = $self->port;
TestLib::command_like(@_); TestLib::command_like(@_);
@ -1341,6 +1449,7 @@ sub issues_sql_like
{ {
my ($self, $cmd, $expected_sql, $test_name) = @_; my ($self, $cmd, $expected_sql, $test_name) = @_;
local $ENV{PGHOST} = $self->host;
local $ENV{PGPORT} = $self->port; local $ENV{PGPORT} = $self->port;
truncate $self->logfile, 0; truncate $self->logfile, 0;
@ -1354,8 +1463,8 @@ sub issues_sql_like
=item $node->run_log(...) =item $node->run_log(...)
Runs a shell command like TestLib::run_log, but with PGPORT set so Runs a shell command like TestLib::run_log, but with connection parameters set
that the command will default to connecting to this PostgresNode. so that the command will default to connecting to this PostgresNode.
=cut =cut
@ -1363,6 +1472,7 @@ sub run_log
{ {
my $self = shift; my $self = shift;
local $ENV{PGHOST} = $self->host;
local $ENV{PGPORT} = $self->port; local $ENV{PGPORT} = $self->port;
TestLib::run_log(@_); TestLib::run_log(@_);

154
src/test/recovery/t/017_shm.pl Normal file
View File

@ -0,0 +1,154 @@
#
# Tests of pg_shmem.h functions
#
use strict;
use warnings;
use IPC::Run 'run';
use PostgresNode;
use Test::More;
use TestLib;
plan tests => 6;
my $tempdir = TestLib::tempdir;
my $port;
# When using Unix sockets, we can dictate the port number. In the absence of
# collisions from other shmget() activity, gnat starts with key 0x7d001
# (512001), and flea starts with key 0x7d002 (512002).
$port = 512 unless $PostgresNode::use_tcp;
# Log "ipcs" diffs on a best-effort basis, swallowing any error.
my $ipcs_before = "$tempdir/ipcs_before";
eval { run_log [ 'ipcs', '-am' ], '>', $ipcs_before; };
sub log_ipcs
{
eval { run_log [ 'ipcs', '-am' ], '|', [ 'diff', $ipcs_before, '-' ] };
return;
}
# Node setup.
sub init_start
{
my $name = shift;
my $ret = PostgresNode->get_new_node($name, port => $port, own_host => 1);
defined($port) or $port = $ret->port; # same port for all nodes
$ret->init;
$ret->start;
log_ipcs();
return $ret;
}
my $gnat = init_start 'gnat';
my $flea = init_start 'flea';
# Upon postmaster death, postmaster children exit automatically.
$gnat->kill9;
log_ipcs();
$flea->restart; # flea ignores the shm key gnat abandoned.
log_ipcs();
poll_start($gnat); # gnat recycles its former shm key.
log_ipcs();
# After clean shutdown, the nodes swap shm keys.
$gnat->stop;
$flea->restart;
log_ipcs();
$gnat->start;
log_ipcs();
# Scenarios involving no postmaster.pid, dead postmaster, and a live backend.
# Use a regress.c function to emulate the responsiveness of a backend working
# through a CPU-intensive task.
$gnat->safe_psql('postgres', <<EOSQL);
CREATE FUNCTION wait_pid(int)
RETURNS void
AS '$ENV{REGRESS_SHLIB}'
LANGUAGE C STRICT;
EOSQL
my $slow_query = 'SELECT wait_pid(pg_backend_pid())';
my ($stdout, $stderr);
my $slow_client = IPC::Run::start(
[
'psql', '-X', '-qAt', '-d', $gnat->connstr('postgres'),
'-c', $slow_query
],
'<',
\undef,
'>',
\$stdout,
'2>',
\$stderr,
IPC::Run::timeout(900)); # five times the poll_query_until timeout
ok( $gnat->poll_query_until(
'postgres',
"SELECT 1 FROM pg_stat_activity WHERE query = '$slow_query'", '1'),
'slow query started');
my $slow_pid = $gnat->safe_psql('postgres',
"SELECT pid FROM pg_stat_activity WHERE query = '$slow_query'");
$gnat->kill9;
unlink($gnat->data_dir . '/postmaster.pid');
$gnat->rotate_logfile; # on Windows, can't open old log for writing
log_ipcs();
# Reject ordinary startup.
ok(!$gnat->start(fail_ok => 1), 'live query blocks restart');
like(
slurp_file($gnat->logfile),
qr/pre-existing shared memory block/,
'detected live backend via shared memory');
# Reject single-user startup.
my $single_stderr;
ok( !run_log(
[ 'postgres', '--single', '-D', $gnat->data_dir, 'template1' ],
'<', \('SELECT 1 + 1'), '2>', \$single_stderr),
'live query blocks --single');
print STDERR $single_stderr;
like(
$single_stderr,
qr/pre-existing shared memory block/,
'single-user mode detected live backend via shared memory');
log_ipcs();
# Fail to reject startup if shm key N has become available and we crash while
# using key N+1. This is unwanted, but expected. Windows is immune, because
# its GetSharedMemName() use DataDir strings, not numeric keys.
$flea->stop; # release first key
is( $gnat->start(fail_ok => 1),
$TestLib::windows_os ? 0 : 1,
'key turnover fools only sysv_shmem.c');
$gnat->stop; # release first key (no-op on $TestLib::windows_os)
$flea->start; # grab first key
# cleanup
TestLib::system_log('pg_ctl', 'kill', 'QUIT', $slow_pid);
$slow_client->finish; # client has detected backend termination
log_ipcs();
poll_start($gnat); # recycle second key
$gnat->stop;
$flea->stop;
log_ipcs();
# When postmaster children are slow to exit after postmaster death, we may
# need retries to start a new postmaster.
sub poll_start
{
my ($node) = @_;
my $max_attempts = 180 * 10;
my $attempts = 0;
while ($attempts < $max_attempts)
{
$node->start(fail_ok => 1) && return 1;
# Wait 0.1 second before retrying.
usleep(100_000);
$attempts++;
}
# No success within 180 seconds. Try one last time without fail_ok, which
# will BAIL_OUT unless it succeeds.
$node->start && return 1;
return 0;
}

1
src/tools/msvc/vcregress.pl
View File

@ -198,6 +198,7 @@ sub tap_check
local %ENV = %ENV; local %ENV = %ENV;
$ENV{PERL5LIB} = "$topdir/src/test/perl;$ENV{PERL5LIB}"; $ENV{PERL5LIB} = "$topdir/src/test/perl;$ENV{PERL5LIB}";
$ENV{PG_REGRESS} = "$topdir/$Config/pg_regress/pg_regress"; $ENV{PG_REGRESS} = "$topdir/$Config/pg_regress/pg_regress";
$ENV{REGRESS_SHLIB} = "$topdir/src/test/regress/regress.dll";
$ENV{TESTDIR} = "$dir"; $ENV{TESTDIR} = "$dir";