On-demand running query plans using auto_explain and signals

diff --git a/src/backend/storage/ipc/procsignal.c b/src/backend/storage/ipc/procsignal.c
index 0abde43..40db40d 100644
--- a/src/backend/storage/ipc/procsignal.c
+++ b/src/backend/storage/ipc/procsignal.c
@@ -26,6 +26,7 @@
 #include "storage/shmem.h"
 #include "storage/sinval.h"
 #include "tcop/tcopprot.h"
+#include "utils/cmdstatus.h"
 
 
 /*
@@ -296,6 +297,9 @@ procsignal_sigusr1_handler(SIGNAL_ARGS)
 	if (CheckProcSignal(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN))
 		RecoveryConflictInterrupt(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN);
 
+	if (CheckProcSignal(PROCSIG_CMDSTATUS_INFO))
+		HandleCmdStatusInfoInterrupt();
+
 	if (set_latch_on_sigusr1)
 		SetLatch(MyLatch);
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index ce4bdaf..5d5df58 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -67,6 +67,7 @@
 #include "tcop/pquery.h"
 #include "tcop/tcopprot.h"
 #include "tcop/utility.h"
+#include "utils/cmdstatus.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/ps_status.h"
@@ -2991,6 +2992,9 @@ ProcessInterrupts(void)
 
 	if (ParallelMessagePending)
 		HandleParallelMessages();
+
+	if (CmdStatusInfoRequested)
+		ProcessCmdStatusInfoRequest();
 }
 
 
diff --git a/src/backend/utils/adt/Makefile b/src/backend/utils/adt/Makefile
index 3ed0b44..2c8687c 100644
--- a/src/backend/utils/adt/Makefile
+++ b/src/backend/utils/adt/Makefile
@@ -18,7 +18,7 @@ endif
 # keep this list arranged alphabetically or it gets to be a mess
 OBJS = acl.o arrayfuncs.o array_expanded.o array_selfuncs.o \
 	array_typanalyze.o array_userfuncs.o arrayutils.o ascii.o \
-	bool.o cash.o char.o date.o datetime.o datum.o dbsize.o domains.o \
+	bool.o cash.o char.o cmdstatus.o date.o datetime.o datum.o dbsize.o domains.o \
 	encode.o enum.o expandeddatum.o \
 	float.o format_type.o formatting.o genfile.o \
 	geo_ops.o geo_selfuncs.o inet_cidr_ntop.o inet_net_pton.o int.o \
diff --git a/src/backend/utils/adt/cmdstatus.c b/src/backend/utils/adt/cmdstatus.c
new file mode 100644
index 0000000..38c1947
--- /dev/null
+++ b/src/backend/utils/adt/cmdstatus.c
@@ -0,0 +1,508 @@
+/*-------------------------------------------------------------------------
+ *
+ * cmdstatus.c
+ *	  Definitions for pg_cmdstatus function.
+ *
+ * Copyright (c) 1996-2015, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/backend/utils/adt/cmdstatus.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "funcapi.h"
+#include "miscadmin.h"
+
+#include "access/htup_details.h"
+#include "commands/explain.h"
+#include "lib/stringinfo.h"
+#include "storage/latch.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "storage/shmem.h"
+#include "tcop/dest.h"
+#include "tcop/pquery.h"
+#include "utils/builtins.h"
+#include "utils/cmdstatus.h"
+
+
+#define CMDINFO_SLOTS		100
+#define BUFFER_SIZE			(8 * 1024)
+
+bool CmdStatusInfoRequested = false;
+
+typedef struct {
+	bool	is_valid;
+	bool	is_done;
+	int		target_pid;
+	int		sender_pid;
+	int		request_type;
+	int		result_code;
+} CmdStatusInfoEntry;
+
+typedef struct {
+	LWLock	   *lock;				/* protect slots - search/modification */
+	CmdStatusInfoEntry	*slots;
+	LWLock	   *buffer_lock;		/* protect buffer handling */
+	void	   *buffer;				/* result data */
+	Size		buffer_size;
+	int			target_pid;
+	int			sender_pid;
+	bool		buffer_is_free;		/* buffer is generally available */
+	bool		buffer_holds_data;	/* buffer holds a valid data */
+} CmdStatusInfo;
+
+static CmdStatusInfo *cmd_status_info = NULL;
+
+/*
+ * Prepare explain of query
+ *
+ */
+static StringInfo
+explain_query(QueryDesc *queryDesc)
+{
+	ExplainState	*es;
+
+	es = NewExplainState();
+	es->analyze = false;
+	es->verbose = false;
+	es->buffers = false;
+	es->format = EXPLAIN_FORMAT_TEXT;
+
+	ExplainBeginOutput(es);
+	ExplainQueryText(es, queryDesc);
+	ExplainPrintPlan(es, queryDesc);
+	ExplainEndOutput(es);
+
+	/* Remove last line break */
+	if (es->str->len > 0 && es->str->data[es->str->len - 1] == '\n')
+		es->str->data[--es->str->len] = '\0';
+
+	return es->str;
+}
+
+static CmdStatusInfo *
+attach_shmem(CmdStatusInfo *cmd_status_info)
+{
+	bool	found;
+
+	if (cmd_status_info == NULL)
+	{
+		LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE);
+
+		cmd_status_info = (CmdStatusInfo *) ShmemInitStruct("cmdstatusinfo",
+									sizeof(CmdStatusInfo),
+									&found);
+		if (!found)
+		{
+			int	i;
+
+			cmd_status_info->lock = LWLockAssign();
+			cmd_status_info->slots = ShmemAlloc(CMDINFO_SLOTS * sizeof(CmdStatusInfo));
+
+			for (i = 0; i < CMDINFO_SLOTS; i++)
+			{
+				cmd_status_info->slots[i].is_valid = false;
+			}
+
+			cmd_status_info->buffer_lock = LWLockAssign();
+			cmd_status_info->buffer = ShmemAlloc(BUFFER_SIZE);
+			cmd_status_info->buffer_is_free = true;
+			cmd_status_info->buffer_holds_data = true;
+		}
+
+		LWLockRelease(AddinShmemInitLock);
+	}
+
+	return cmd_status_info;
+}
+
+/*
+ * write data to shm buffer - wait for free buffer
+ *
+ */
+static void
+write_to_shm_buffer(int target_pid, int sender_pid, void *data, Size bytes)
+{
+	int	loop = 0;
+
+	cmd_status_info = attach_shmem(cmd_status_info);
+
+	while (1)
+	{
+		LWLockAcquire(cmd_status_info->buffer_lock, LW_EXCLUSIVE);
+
+		if (cmd_status_info->buffer_is_free)
+		{
+			cmd_status_info->target_pid = target_pid;
+			cmd_status_info->sender_pid = sender_pid;
+			cmd_status_info->buffer_is_free = false;
+			cmd_status_info->buffer_holds_data = true;
+
+			cmd_status_info->buffer_size = bytes;
+			memcpy(cmd_status_info->buffer, data, bytes);
+
+			LWLockRelease(cmd_status_info->buffer_lock);
+			break;
+		}
+		else
+		{
+			LWLockRelease(cmd_status_info->buffer_lock);
+
+			if (loop++ % 100 == 0);
+				CHECK_FOR_INTERRUPTS();
+
+			if (loop > 100000)
+				elog(ERROR, "cannot to take buffer to send data");
+
+			pg_usleep(1000L);
+		}
+	}
+}
+
+/*
+ * It read data from shm buffer, waits for data
+ *
+ */
+static void *
+read_from_shm_buffer(int target_pid, int sender_pid, Size *bytes)
+{
+	void *result = NULL;
+	int	loop = 0;
+
+	cmd_status_info = attach_shmem(cmd_status_info);
+
+	while (1)
+	{
+		LWLockAcquire(cmd_status_info->buffer_lock, LW_EXCLUSIVE);
+
+		if (cmd_status_info->buffer_holds_data &&
+				cmd_status_info->target_pid == target_pid &&
+				cmd_status_info->sender_pid == sender_pid)
+		{
+			result = palloc(cmd_status_info->buffer_size);
+			memcpy(result, cmd_status_info->buffer, cmd_status_info->buffer_size);
+			*bytes = cmd_status_info->buffer_size;
+
+			cmd_status_info->buffer_is_free = true;
+			cmd_status_info->buffer_holds_data = false;
+
+			LWLockRelease(cmd_status_info->buffer_lock);
+
+			break;
+		}
+		else
+		{
+			LWLockRelease(cmd_status_info->buffer_lock);
+
+			if (loop++ % 100 == 0);
+				CHECK_FOR_INTERRUPTS();
+
+			pg_usleep(1000L);
+		}
+	}
+
+	return result;
+}
+
+/* signal handler for PROCSIG_CMDSTATUS_INFO */
+void
+HandleCmdStatusInfoInterrupt(void)
+{
+	InterruptPending = true;
+	CmdStatusInfoRequested = true;
+
+	SetLatch(MyLatch);
+}
+
+void
+ProcessCmdStatusInfoRequest(void)
+{
+	bool	found = true;
+
+	cmd_status_info = attach_shmem(cmd_status_info);
+
+	/* search any request for current process */
+	while (found)
+	{
+		int		i;
+		CmdStatusInfoEntry *csie;
+
+		found = false;
+		csie = NULL;
+
+		/* take lock for slots */
+		LWLockAcquire(cmd_status_info->lock, LW_EXCLUSIVE);
+
+		/* try to find any request in valid slots */
+		for (i = 0; i < CMDINFO_SLOTS; i++)
+		{
+			csie = &(cmd_status_info->slots[i]);
+
+			if (csie->is_valid && !csie->is_done && csie->target_pid == MyProcPid)
+			{
+				found = true;
+				break;
+			}
+		}
+
+		LWLockRelease(cmd_status_info->lock);
+
+		if (found)
+		{
+			/* process request */
+			Assert(csie != NULL);
+
+			csie->is_done = true;
+			csie->result_code = -1;
+
+			if (ActivePortal)
+			{
+				if (csie->request_type == 1)
+				{
+					if (ActivePortal->queryDesc != NULL)
+					{
+						StringInfo str;
+
+						str = explain_query(ActivePortal->queryDesc);
+						write_to_shm_buffer(csie->sender_pid, MyProcPid, (void *) str->data, str->len);
+
+						pfree(str->data);
+
+						csie->result_code = 0;
+					}
+					else
+					{
+#define NO_QUERY_DESC_MSG "(the running query description could not be found)"
+						write_to_shm_buffer(csie->sender_pid, MyProcPid,
+											NO_QUERY_DESC_MSG,
+											sizeof(NO_QUERY_DESC_MSG) - 1);
+#undef NO_QUERY_DESC_MSG
+					}
+				}
+				else if (csie->request_type == 2)
+				{
+					write_to_shm_buffer(csie->sender_pid, MyProcPid,
+											 (void *) ActivePortal->sourceText,
+											 strlen(ActivePortal->sourceText));
+					csie->result_code = 0;
+				}
+				else if (csie->request_type == 3)
+				{
+					if (ActivePortal->commandTag != NULL)
+					{
+						if (ActivePortal->queryDesc != NULL &&
+							ActivePortal->queryDesc->estate != NULL)
+						{
+							char completionTag[COMPLETION_TAG_BUFSIZE];
+
+							snprintf(completionTag, COMPLETION_TAG_BUFSIZE, "%s %u",
+									 ActivePortal->commandTag,
+									 ActivePortal->queryDesc->estate->es_processed);
+
+							write_to_shm_buffer(csie->sender_pid, MyProcPid,
+											 (void *) completionTag,
+											 strlen(completionTag));
+						}
+						else
+						{
+							write_to_shm_buffer(csie->sender_pid, MyProcPid,
+											 (void *) ActivePortal->commandTag,
+											 strlen(ActivePortal->commandTag));
+						}
+
+						csie->result_code = 0;
+					}
+					else
+					{
+#define NO_COMMAND_TAG_MSG "(a command tag is not set for the running query)"
+						write_to_shm_buffer(csie->sender_pid, MyProcPid,
+											NO_COMMAND_TAG_MSG,
+											sizeof(NO_COMMAND_TAG_MSG) - 1);
+#undef NO_COMMAND_TAG_MSG
+					}
+				}
+				else
+				{
+#define UNKNOWN_REQUEST_TYPE_MSG "(unknown request_type)"
+					write_to_shm_buffer(csie->sender_pid, MyProcPid,
+										UNKNOWN_REQUEST_TYPE_MSG,
+										sizeof(UNKNOWN_REQUEST_TYPE_MSG) - 1);
+#undef UNKNOWN_REQUEST_TYPE_MSG
+				}
+			}
+			else
+			{
+#define NO_QUERY_RUNNING_MSG "(no query is currently running)"
+					write_to_shm_buffer(csie->sender_pid, MyProcPid,
+										NO_QUERY_RUNNING_MSG,
+										sizeof(NO_QUERY_RUNNING_MSG) - 1);
+#undef NO_QUERY_RUNNING_MSG
+
+			}
+		}
+	}
+}
+
+
+static CmdStatusInfoEntry *
+NewCmdStatusInfoEntry(int target_pid, int request_type)
+{
+	bool	found = false;
+	CmdStatusInfoEntry *csie = NULL;
+	int			i;
+
+	cmd_status_info = attach_shmem(cmd_status_info);
+
+	/* find unused slot */
+	LWLockAcquire(cmd_status_info->lock, LW_EXCLUSIVE);
+
+	for (i = 0; i < CMDINFO_SLOTS; i++)
+	{
+		csie = &(cmd_status_info->slots[i]);
+
+		if (!csie->is_valid)
+		{
+			found = true;
+			break;
+		}
+	}
+
+	LWLockRelease(cmd_status_info->lock);
+
+	if (!found)
+		elog(ERROR, "there are not free slots for cmdstatusinfo now");
+
+	csie->is_valid = true;
+	csie->is_done = false;
+	csie->target_pid = target_pid;
+	csie->sender_pid = MyProcPid;
+	csie->request_type = request_type;
+	csie->result_code = 0;
+
+	return csie;
+}
+
+/*
+ * try to get status of command in another process
+ *
+ * FUNCTION get_cmdstatus(pid, request_type)
+ * RETURNS SETOF text
+ */
+Datum
+pg_cmdstatus(PG_FUNCTION_ARGS)
+{
+	ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
+	Tuplestorestate *tupstore;
+	TupleDesc	tupdesc;
+	MemoryContext per_query_ctx;
+	MemoryContext oldcontext;
+	int target_pid				= PG_GETARG_INT32(0);
+	int request_type 			= PG_GETARG_INT32(1);
+	PGPROC	   *proc;
+	CmdStatusInfoEntry *csie;
+
+	Size			len;
+	void			*data = NULL;
+
+	/* check to see if caller supports us returning a tuplestore */
+	if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("set-valued function called in context that cannot accept a set")));
+
+	if (!(rsinfo->allowedModes & SFRM_Materialize))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("materialize mode required, but it is not allowed in this context")));
+
+	/* need to build tuplestore in query context */
+	per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+	oldcontext = MemoryContextSwitchTo(per_query_ctx);
+
+	tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc);
+	tupstore = tuplestore_begin_heap(false, false, work_mem);
+	MemoryContextSwitchTo(oldcontext);
+
+	csie = NewCmdStatusInfoEntry(target_pid, request_type);
+
+	PG_TRY();
+	{
+		/* verify access to target_pid */
+		proc = BackendPidGetProc(target_pid);
+
+		if (proc == NULL)
+			ereport(ERROR,
+					(errmsg("PID %d is not a PostgreSQL server process", target_pid)));
+
+		if (!(superuser() || proc->roleId == GetUserId()))
+			ereport(ERROR,
+					(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+					 (errmsg("must be superuser or have the same role to cancel queries running in other server processes"))));
+
+		if (SendProcSignal((pid_t) target_pid, PROCSIG_CMDSTATUS_INFO, InvalidBackendId) < 0)
+			elog(ERROR, "could not signal backend with PID %d", target_pid);
+
+		while (1)
+		{
+			data = read_from_shm_buffer(MyProcPid, target_pid, &len);
+			if (len > 0)
+			{
+				Datum		value;
+				HeapTuple	tuple;
+				bool		isnull = false;
+				Size			processed = 0;
+				char			*cursor = data;
+
+				/* parse to rows */
+				while (processed < len)
+				{
+					char *eol = strchr(cursor, '\n');
+
+					if (eol != NULL)
+					{
+						int	line_size = eol - cursor;
+
+						value = PointerGetDatum(cstring_to_text_with_len(cursor, line_size));
+						cursor += line_size + 1;
+						processed += line_size + 1;
+					}
+					else
+					{
+						/* last line */
+						value = PointerGetDatum(cstring_to_text_with_len(cursor, len - processed));
+						processed = len;
+					}
+
+					tuple = heap_form_tuple(tupdesc, &value, &isnull);
+					tuplestore_puttuple(tupstore, tuple);
+				}
+
+				pfree(data);
+			}
+
+			if (csie->is_done)
+				break;
+		}
+
+		csie->is_valid = false;
+
+		/* clean up and return the tuplestore */
+		tuplestore_donestoring(tupstore);
+	}
+	PG_CATCH();
+	{
+		csie->is_valid = false;
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+
+	rsinfo->returnMode = SFRM_Materialize;
+	rsinfo->setResult = tupstore;
+	rsinfo->setDesc = tupdesc;
+
+	return (Datum) 0;
+}
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index ddf7c67..d083aaf 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -3130,6 +3130,8 @@ DESCR("get OID of current session's temp schema, if any");
 DATA(insert OID = 2855 (  pg_is_other_temp_schema	PGNSP PGUID 12 1 0 0 0 f f f f t f s 1 0 16 "26" _null_ _null_ _null_ _null_ _null_ pg_is_other_temp_schema _null_ _null_ _null_ ));
 DESCR("is schema another session's temp schema?");
 
+DATA(insert OID = 4099 ( pg_cmdstatus		PGNSP PGUID 12 1 100 0 0 f f f f f t s 2 0 25 "23 23" _null_ _null_  _null_  _null_ _null_ pg_cmdstatus _null_ _null_ _null_ ));
+DESCR("returns information about another process");
 DATA(insert OID = 2171 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_cancel_backend _null_ _null_ _null_ ));
 DESCR("cancel a server process' current query");
 DATA(insert OID = 2096 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
diff --git a/src/include/storage/procsignal.h b/src/include/storage/procsignal.h
index af1a0cd..ab1698c 100644
--- a/src/include/storage/procsignal.h
+++ b/src/include/storage/procsignal.h
@@ -41,6 +41,9 @@ typedef enum
 	PROCSIG_RECOVERY_CONFLICT_BUFFERPIN,
 	PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK,
 
+	/* cmd status info */
+	PROCSIG_CMDSTATUS_INFO,
+
 	NUM_PROCSIGNALS				/* Must be last! */
 } ProcSignalReason;
 
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
index fc1679e..605612e 100644
--- a/src/include/utils/builtins.h
+++ b/src/include/utils/builtins.h
@@ -1243,6 +1243,9 @@ extern Datum pg_identify_object_as_address(PG_FUNCTION_ARGS);
 /* catalog/objectaddress.c */
 extern Datum pg_get_object_address(PG_FUNCTION_ARGS);
 
+/* utils/adt/cmdstatus.c */
+extern Datum pg_cmdstatus(PG_FUNCTION_ARGS);
+
 /* commands/constraint.c */
 extern Datum unique_key_recheck(PG_FUNCTION_ARGS);
 
diff --git a/src/include/utils/cmdstatus.h b/src/include/utils/cmdstatus.h
new file mode 100644
index 0000000..ff88ead
--- /dev/null
+++ b/src/include/utils/cmdstatus.h
@@ -0,0 +1,21 @@
+/*-------------------------------------------------------------------------
+ *
+ * cmdstatus.h
+ *	  Declarations for command status interrupt handling.
+ *
+ *
+ * Portions Copyright (c) 1996-2015, PostgreSQL Global Development Group
+ *
+ * src/include/utils/cmdstatus.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CMDSTATUS_H
+#define CMDSTATUS_H
+
+extern bool CmdStatusInfoRequested;
+
+extern void HandleCmdStatusInfoInterrupt(void);
+extern void ProcessCmdStatusInfoRequest(void);
+
+#endif   /* CMDSTATUS_H */

diff --git a/src/backend/storage/ipc/procsignal.c b/src/backend/storage/ipc/procsignal.c
index 0abde43..40db40d 100644
--- a/src/backend/storage/ipc/procsignal.c
+++ b/src/backend/storage/ipc/procsignal.c
@@ -26,6 +26,7 @@
 #include "storage/shmem.h"
 #include "storage/sinval.h"
 #include "tcop/tcopprot.h"
+#include "utils/cmdstatus.h"
 
 
 /*
@@ -296,6 +297,9 @@ procsignal_sigusr1_handler(SIGNAL_ARGS)
 	if (CheckProcSignal(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN))
 		RecoveryConflictInterrupt(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN);
 
+	if (CheckProcSignal(PROCSIG_CMDSTATUS_INFO))
+		HandleCmdStatusInfoInterrupt();
+
 	if (set_latch_on_sigusr1)
 		SetLatch(MyLatch);
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index ce4bdaf..5d5df58 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -67,6 +67,7 @@
 #include "tcop/pquery.h"
 #include "tcop/tcopprot.h"
 #include "tcop/utility.h"
+#include "utils/cmdstatus.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/ps_status.h"
@@ -2991,6 +2992,9 @@ ProcessInterrupts(void)
 
 	if (ParallelMessagePending)
 		HandleParallelMessages();
+
+	if (CmdStatusInfoRequested)
+		ProcessCmdStatusInfoRequest();
 }
 
 
diff --git a/src/backend/utils/adt/Makefile b/src/backend/utils/adt/Makefile
index 3ed0b44..2c8687c 100644
--- a/src/backend/utils/adt/Makefile
+++ b/src/backend/utils/adt/Makefile
@@ -18,7 +18,7 @@ endif
 # keep this list arranged alphabetically or it gets to be a mess
 OBJS = acl.o arrayfuncs.o array_expanded.o array_selfuncs.o \
 	array_typanalyze.o array_userfuncs.o arrayutils.o ascii.o \
-	bool.o cash.o char.o date.o datetime.o datum.o dbsize.o domains.o \
+	bool.o cash.o char.o cmdstatus.o date.o datetime.o datum.o dbsize.o domains.o \
 	encode.o enum.o expandeddatum.o \
 	float.o format_type.o formatting.o genfile.o \
 	geo_ops.o geo_selfuncs.o inet_cidr_ntop.o inet_net_pton.o int.o \
diff --git a/src/backend/utils/adt/cmdstatus.c b/src/backend/utils/adt/cmdstatus.c
new file mode 100644
index 0000000..5f31a2d
--- /dev/null
+++ b/src/backend/utils/adt/cmdstatus.c
@@ -0,0 +1,567 @@
+/*-------------------------------------------------------------------------
+ *
+ * cmdstatus.c
+ *	  Definitions for pg_cmdstatus function.
+ *
+ * Copyright (c) 1996-2015, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/backend/utils/adt/cmdstatus.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "funcapi.h"
+#include "miscadmin.h"
+
+#include "access/htup_details.h"
+#include "commands/explain.h"
+#include "lib/stringinfo.h"
+#include "storage/latch.h"
+#include "storage/ipc.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "storage/shm_mq.h"
+#include "tcop/dest.h"
+#include "tcop/pquery.h"
+#include "utils/builtins.h"
+#include "utils/cmdstatus.h"
+
+
+typedef enum {
+	CMD_STATUS_REQUEST_EXPLAIN = 1,
+	CMD_STATUS_REQUEST_QUERY_TEXT = 2,
+	CMD_STATUS_REQUEST_PROGRESS_TAG = 3,
+	CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE = 4
+} CmdStatusInfoRequestType;
+
+#define CMD_STATUS_MAX_REQUEST CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE
+
+typedef enum {
+	CMD_STATUS_RESULT_FAILURE = -1,
+	CMD_STATUS_RESULT_SUCCESS = 0,
+	CMD_STATUS_RESULT_BACKEND_IDLE,
+	CMD_STATUS_RESULT_NO_COMMAND_TAG
+} CmdStatusInfoResultCode;
+
+typedef struct {
+	LWLock	   *lock;
+	pid_t		target_pid;
+	pid_t		sender_pid;
+	CmdStatusInfoRequestType	request_type;
+	CmdStatusInfoResultCode		result_code;
+	char		buffer[FLEXIBLE_ARRAY_MEMBER];
+} CmdStatusInfo;
+
+#define BUFFER_SIZE			8192
+
+/*
+ * These structs are allocated on the program stack as local variables in the
+ * ExecutorRun hook.  The top of stack is current_query_stack, see below.
+ */
+typedef struct CmdInfoStack {
+	QueryDesc			   *query_desc;
+	struct CmdInfoStack	   *parent;
+} CmdInfoStack;
+
+
+bool CmdStatusInfoEnabled = true;
+bool CmdStatusInfoRequested = false;
+
+static CmdStatusInfo   *cmd_status_info = NULL;
+static CmdInfoStack	   *current_query_stack = NULL;
+static int				query_stack_size = 0;
+
+static ExecutorRun_hook_type	prev_ExecutorRun = NULL;
+
+static void attach_shmem(void);
+static void cmdstatus_ExecutorRun(QueryDesc *queryDesc,
+								  ScanDirection direction, long count);
+
+
+void
+InstallCmdStatusInfoHooks(void)
+{
+	/*elog(LOG, "InstallCmdStatusInfoHooks");*/
+
+	prev_ExecutorRun = ExecutorRun_hook;
+	ExecutorRun_hook = cmdstatus_ExecutorRun;
+}
+
+
+static void
+attach_shmem(void)
+{
+	bool	found;
+
+	Assert(sizeof(CmdStatusInfo) < BUFFER_SIZE);
+
+	if (cmd_status_info == NULL)
+	{
+		LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE);
+
+		cmd_status_info = (CmdStatusInfo *) ShmemInitStruct("cmdstatusinfo",
+															BUFFER_SIZE, &found);
+		if (!found)
+		{
+			cmd_status_info->lock = LWLockAssign();
+
+			cmd_status_info->target_pid = 0;
+			cmd_status_info->sender_pid = 0;
+			cmd_status_info->request_type = 0;
+			cmd_status_info->result_code = 0;
+		}
+
+		LWLockRelease(AddinShmemInitLock);
+	}
+}
+
+
+static void
+cmdstatus_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, long count)
+{
+	CmdInfoStack	current;
+
+	/*ereport(LOG,
+			(errmsg("ExecutorRun   : %p\t%d", queryDesc, query_stack_size),
+			 errhidecontext(true),
+			 errhidestmt(true)));*/
+
+	current.query_desc = queryDesc;
+	current.parent = current_query_stack;
+
+	current_query_stack = &current;
+	query_stack_size++;
+
+	PG_TRY();
+	{
+		if (prev_ExecutorRun)
+			prev_ExecutorRun(queryDesc, direction, count);
+		else
+			standard_ExecutorRun(queryDesc, direction, count);
+
+		Assert(current_query_stack == &current);
+		Assert(query_stack_size > 0);
+
+		query_stack_size--;
+		current_query_stack = current.parent;
+	}
+	PG_CATCH();
+	{
+		Assert(current_query_stack == &current);
+		Assert(query_stack_size > 0);
+
+		query_stack_size--;
+		current_query_stack = current.parent;
+
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+}
+
+
+static StringInfo
+explain_query(QueryDesc *queryDesc)
+{
+	ExplainState	*es;
+
+	es = NewExplainState();
+	es->analyze = false;
+	es->verbose = false;
+	es->buffers = false;
+	es->format = EXPLAIN_FORMAT_TEXT;
+
+	ExplainBeginOutput(es);
+	/* XXX: appendStringInfo(es->str, "#%d ", depth); ? */
+	ExplainQueryText(es, queryDesc);
+	ExplainPrintPlan(es, queryDesc);
+	ExplainEndOutput(es);
+
+	/* Remove last line break. */
+	if (es->str->len > 0 && es->str->data[es->str->len - 1] == '\n')
+		es->str->data[--es->str->len] = '\0';
+
+	return es->str;
+}
+
+static void
+send_explain_plan(shm_mq_handle *shmq, const char *str)
+{
+	/* Break plan into lines and send each as a separate message. */
+	while (*str)
+	{
+		const char	   *q   = strchr(str, '\n');
+		Size			len = q ? q - str : strlen(str);
+
+		shm_mq_send(shmq, len, str, false);
+
+		if (!q)
+			break;
+
+		str += len + 1;
+	}
+}
+
+static void
+explain_one_query_desc(shm_mq_handle *shmq, QueryDesc *query_desc)
+{
+	StringInfo		str;
+
+	str = explain_query(query_desc);
+
+	send_explain_plan(shmq, str->data);
+
+	pfree(str->data);
+	pfree(str);
+}
+
+
+/* signal handler for PROCSIG_CMDSTATUS_INFO */
+void
+HandleCmdStatusInfoInterrupt(void)
+{
+	if (CmdStatusInfoEnabled && !CmdStatusInfoRequested)
+	{
+		InterruptPending = true;
+		CmdStatusInfoRequested = true;
+
+		SetLatch(MyLatch);
+	}
+}
+
+void
+ProcessCmdStatusInfoRequest(void)
+{
+	shm_mq		   *buffer = NULL;
+	shm_mq_handle  *buffer_handle = NULL;
+
+	if (!(CmdStatusInfoEnabled && CmdStatusInfoRequested))
+	  return;
+
+	CmdStatusInfoEnabled = false;
+	CmdStatusInfoRequested = false;
+
+	PG_TRY();
+	{
+		attach_shmem();
+
+		LWLockAcquire(cmd_status_info->lock, LW_EXCLUSIVE);
+
+		if (cmd_status_info->target_pid == 0)
+		{
+			LWLockRelease(cmd_status_info->lock);
+
+			elog(LOG, "target backend PID is not set");
+			return;
+		}
+		else if (cmd_status_info->target_pid != MyProcPid)
+		{
+			pid_t	target_pid = cmd_status_info->target_pid;
+
+			LWLockRelease(cmd_status_info->lock);
+
+			elog(LOG, "target backend PID doesn't match: expected %d, but seen %d",
+				 MyProcPid, target_pid);
+			return;
+		}
+
+		buffer = (shm_mq *) &cmd_status_info->buffer;
+		shm_mq_set_sender(buffer, MyProc);
+
+		buffer_handle = shm_mq_attach(buffer, NULL, NULL);
+
+		/* Show some optimism. */
+		cmd_status_info->result_code = CMD_STATUS_RESULT_SUCCESS;
+
+		/*
+		 * It should be safe to release the lock now, since the IO
+		 * synchronization is performed on the shared memory queue itself.
+		 */
+		LWLockRelease(cmd_status_info->lock);
+
+		if (ActivePortal)
+		{
+			switch (cmd_status_info->request_type)
+			{
+				case CMD_STATUS_REQUEST_EXPLAIN:
+					explain_one_query_desc(buffer_handle, ActivePortal->queryDesc);
+					break;
+
+				case CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE:
+				{
+					CmdInfoStack	   *query;
+
+					if (current_query_stack != NULL)
+					{
+						for (query = current_query_stack;
+							 query != NULL;
+							 query = query->parent)
+						{
+							explain_one_query_desc(buffer_handle, query->query_desc);
+						}
+					}
+					else
+					{
+						/* XXX */
+						cmd_status_info->result_code = CMD_STATUS_RESULT_BACKEND_IDLE;
+					}
+					break;
+				}
+
+				case CMD_STATUS_REQUEST_QUERY_TEXT:
+					/* XXX: how useful is this one?  we already have pg_stat_activity */
+					shm_mq_send(buffer_handle, strlen(ActivePortal->sourceText),
+								ActivePortal->sourceText, false);
+					break;
+
+				case CMD_STATUS_REQUEST_PROGRESS_TAG:
+					if (ActivePortal->commandTag != NULL)
+					{
+						if (ActivePortal->queryDesc != NULL &&
+							ActivePortal->queryDesc->estate != NULL)
+						{
+							char completionTag[COMPLETION_TAG_BUFSIZE];
+
+							snprintf(completionTag, COMPLETION_TAG_BUFSIZE, "%s %u",
+									 ActivePortal->commandTag,
+									 ActivePortal->queryDesc->estate->es_processed);
+
+							shm_mq_send(buffer_handle, strlen(completionTag),
+										completionTag, false);
+						}
+						else
+						{
+							/* no progress available, at least show the command tag */
+							shm_mq_send(buffer_handle, strlen(ActivePortal->commandTag),
+										ActivePortal->commandTag, false);
+						}
+					}
+					else
+					{
+						cmd_status_info->result_code = CMD_STATUS_RESULT_NO_COMMAND_TAG;
+					}
+					break;
+			}
+		}
+		else
+		{
+			cmd_status_info->result_code = CMD_STATUS_RESULT_BACKEND_IDLE;
+		}
+
+		shm_mq_detach(buffer);
+
+		CmdStatusInfoEnabled = true;
+	}
+	PG_CATCH();
+	{
+		if (buffer_handle)
+			shm_mq_detach(buffer);
+
+		CmdStatusInfoEnabled = true;
+
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+}
+
+static void
+report_result_code(CmdStatusInfoResultCode result, pid_t target_pid)
+{
+	switch (result)
+	{
+		case CMD_STATUS_RESULT_BACKEND_IDLE:
+			elog(INFO, "no command is currently running in backend with PID %d",
+				 target_pid);
+			break;
+
+		case CMD_STATUS_RESULT_NO_COMMAND_TAG:
+			elog(WARNING, "no command tag found for the query in backend with PID %d",
+				 target_pid);
+			break;
+
+		default:
+			elog(ERROR, "general command status request failure");
+			break;
+	}
+}
+
+/*
+ * try to get status of command in another process
+ *
+ * FUNCTION get_cmdstatus(pid, request_type)
+ * RETURNS SETOF text
+ */
+Datum
+pg_cmdstatus(PG_FUNCTION_ARGS)
+{
+	ReturnSetInfo *rsinfo	= (ReturnSetInfo *) fcinfo->resultinfo;
+	Tuplestorestate *tupstore;
+	TupleDesc	tupdesc;
+	MemoryContext per_query_ctx;
+	MemoryContext oldcontext;
+	pid_t target_pid		= (pid_t) PG_GETARG_INT32(0);
+	int request_type		= PG_GETARG_INT32(1);
+	PGPROC	   *proc;
+
+	shm_mq		   *buffer = NULL;
+	shm_mq_handle  *buffer_handle = NULL;
+
+	/* check to see if caller supports us returning a tuplestore */
+	if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("set-valued function called in context that cannot accept a set")));
+
+	if (!(rsinfo->allowedModes & SFRM_Materialize))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("materialize mode required, but it is not allowed in this context")));
+
+	if (request_type < 1 || request_type > CMD_STATUS_MAX_REQUEST)
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("unknown command status request")));
+
+	/* need to build tuplestore in query context */
+	per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+	oldcontext = MemoryContextSwitchTo(per_query_ctx);
+
+	tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc);
+	tupstore = tuplestore_begin_heap(false, false, work_mem);
+	MemoryContextSwitchTo(oldcontext);
+
+	PG_TRY();
+	{
+		bool			done;
+
+		if (target_pid == MyProcPid)
+			ereport(ERROR,
+					(errmsg("backend cannot query command status of itself")));
+
+		/* verify access to target_pid */
+		proc = BackendPidGetProc(target_pid);
+
+		if (proc == NULL)
+			ereport(ERROR,
+					(errmsg("PID %d is not a PostgreSQL server process", target_pid)));
+
+		if (!(superuser() || proc->roleId == GetUserId()))
+			ereport(ERROR,
+					(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+					 (errmsg("must be superuser or have the same role to cancel queries running in other server processes"))));
+
+		attach_shmem();
+
+		/* wait before the shared status struct is free to be used */
+		for (;;)
+		{
+			LWLockAcquire(cmd_status_info->lock, LW_EXCLUSIVE);
+
+			if (cmd_status_info->target_pid == 0)
+			{
+				cmd_status_info->target_pid = target_pid;
+				cmd_status_info->sender_pid = MyProcPid;
+				cmd_status_info->request_type = request_type;
+				cmd_status_info->result_code = CMD_STATUS_RESULT_FAILURE;
+
+				buffer = shm_mq_create(&cmd_status_info->buffer,
+									   BUFFER_SIZE - offsetof(CmdStatusInfo, buffer));
+
+				shm_mq_set_receiver(buffer, MyProc);
+
+				buffer_handle = shm_mq_attach(buffer, NULL, NULL);
+
+				LWLockRelease(cmd_status_info->lock);
+				break;
+			}
+			else
+			{
+				LWLockRelease(cmd_status_info->lock);
+				pg_usleep(1000L);
+			}	
+		}
+
+		if (SendProcSignal(target_pid, PROCSIG_CMDSTATUS_INFO, InvalidBackendId) < 0)
+			elog(ERROR, "could not signal backend with PID %d", target_pid);
+
+		done = false;
+		while (!done)
+		{
+			char   *data;
+			Size	len;
+			shm_mq_result	res;
+
+			res = shm_mq_receive(buffer_handle, &len, (void **) &data,
+								 /* nowait = */ false);
+			switch (res)
+			{
+				case SHM_MQ_SUCCESS:
+				{
+					Datum		value;
+					HeapTuple	tuple;
+					bool		isnull = false;
+
+					value = PointerGetDatum(cstring_to_text_with_len(data, len));
+
+					tuple = heap_form_tuple(tupdesc, &value, &isnull);
+					tuplestore_puttuple(tupstore, tuple);
+					break;
+				}
+
+				case SHM_MQ_DETACHED:
+					if (cmd_status_info->result_code != CMD_STATUS_RESULT_SUCCESS)
+					{
+						report_result_code(cmd_status_info->result_code, target_pid);
+					}
+					done = true;
+					break;
+
+				default:
+					Assert(!"unknown shm_mq_result code");
+			}
+		}
+
+		/* clean up and return the tuplestore */
+		tuplestore_donestoring(tupstore);
+
+		shm_mq_detach(buffer);
+
+		/* clean the status struct for the next user */
+		LWLockAcquire(cmd_status_info->lock, LW_EXCLUSIVE);
+
+		cmd_status_info->target_pid = 0;
+		cmd_status_info->sender_pid = 0;
+		cmd_status_info->request_type = 0;
+		cmd_status_info->result_code = 0;
+
+		LWLockRelease(cmd_status_info->lock);
+	}
+	PG_CATCH();
+	{
+		if (buffer_handle)
+			shm_mq_detach(buffer);
+
+		if (cmd_status_info)
+		{
+			LWLockAcquire(cmd_status_info->lock, LW_EXCLUSIVE);
+
+			cmd_status_info->target_pid = 0;
+			cmd_status_info->sender_pid = 0;
+			cmd_status_info->request_type = 0;
+			cmd_status_info->result_code = 0;
+
+			LWLockRelease(cmd_status_info->lock);
+		}
+
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+
+	rsinfo->returnMode = SFRM_Materialize;
+	rsinfo->setResult = tupstore;
+	rsinfo->setDesc = tupdesc;
+
+	return (Datum) 0;
+}
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 7b19714..19e7009 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -50,6 +50,7 @@
 #include "storage/smgr.h"
 #include "tcop/tcopprot.h"
 #include "utils/acl.h"
+#include "utils/cmdstatus.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
 #include "utils/memutils.h"
@@ -1017,6 +1018,8 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 	/* initialize client encoding */
 	InitializeClientEncoding();
 
+	InstallCmdStatusInfoHooks();
+
 	/* report this backend in the PgBackendStatus array */
 	if (!bootstrap)
 		pgstat_bestart();
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index ddf7c67..d083aaf 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -3130,6 +3130,8 @@ DESCR("get OID of current session's temp schema, if any");
 DATA(insert OID = 2855 (  pg_is_other_temp_schema	PGNSP PGUID 12 1 0 0 0 f f f f t f s 1 0 16 "26" _null_ _null_ _null_ _null_ _null_ pg_is_other_temp_schema _null_ _null_ _null_ ));
 DESCR("is schema another session's temp schema?");
 
+DATA(insert OID = 4099 ( pg_cmdstatus		PGNSP PGUID 12 1 100 0 0 f f f f f t s 2 0 25 "23 23" _null_ _null_  _null_  _null_ _null_ pg_cmdstatus _null_ _null_ _null_ ));
+DESCR("returns information about another process");
 DATA(insert OID = 2171 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_cancel_backend _null_ _null_ _null_ ));
 DESCR("cancel a server process' current query");
 DATA(insert OID = 2096 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
diff --git a/src/include/storage/procsignal.h b/src/include/storage/procsignal.h
index af1a0cd..ab1698c 100644
--- a/src/include/storage/procsignal.h
+++ b/src/include/storage/procsignal.h
@@ -41,6 +41,9 @@ typedef enum
 	PROCSIG_RECOVERY_CONFLICT_BUFFERPIN,
 	PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK,
 
+	/* cmd status info */
+	PROCSIG_CMDSTATUS_INFO,
+
 	NUM_PROCSIGNALS				/* Must be last! */
 } ProcSignalReason;
 
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
index fc1679e..605612e 100644
--- a/src/include/utils/builtins.h
+++ b/src/include/utils/builtins.h
@@ -1243,6 +1243,9 @@ extern Datum pg_identify_object_as_address(PG_FUNCTION_ARGS);
 /* catalog/objectaddress.c */
 extern Datum pg_get_object_address(PG_FUNCTION_ARGS);
 
+/* utils/adt/cmdstatus.c */
+extern Datum pg_cmdstatus(PG_FUNCTION_ARGS);
+
 /* commands/constraint.c */
 extern Datum unique_key_recheck(PG_FUNCTION_ARGS);
 
diff --git a/src/include/utils/cmdstatus.h b/src/include/utils/cmdstatus.h
new file mode 100644
index 0000000..52ddf6a
--- /dev/null
+++ b/src/include/utils/cmdstatus.h
@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * cmdstatus.h
+ *	  Declarations for command status interrupt handling.
+ *
+ *
+ * Portions Copyright (c) 1996-2015, PostgreSQL Global Development Group
+ *
+ * src/include/utils/cmdstatus.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CMDSTATUS_H
+#define CMDSTATUS_H
+
+extern bool CmdStatusInfoRequested;
+
+extern void InstallCmdStatusInfoHooks(void);
+
+extern void HandleCmdStatusInfoInterrupt(void);
+extern void ProcessCmdStatusInfoRequest(void);
+
+#endif   /* CMDSTATUS_H */

diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
new file mode 100644
index 32ac58f..f5db55a
*** a/src/backend/storage/ipc/ipci.c
--- b/src/backend/storage/ipc/ipci.c
***************
*** 43,48 ****
--- 43,49 ----
  #include "storage/procsignal.h"
  #include "storage/sinvaladt.h"
  #include "storage/spin.h"
+ #include "utils/signal_demo.h"
  
  
  shmem_startup_hook_type shmem_startup_hook = NULL;
*************** CreateSharedMemoryAndSemaphores(bool mak
*** 139,144 ****
--- 140,146 ----
  		size = add_size(size, BTreeShmemSize());
  		size = add_size(size, SyncScanShmemSize());
  		size = add_size(size, AsyncShmemSize());
+ 		size = add_size(size, ProcPipeShmemSize());
  #ifdef EXEC_BACKEND
  		size = add_size(size, ShmemBackendArraySize());
  #endif
*************** CreateSharedMemoryAndSemaphores(bool mak
*** 243,248 ****
--- 245,251 ----
  	ReplicationOriginShmemInit();
  	WalSndShmemInit();
  	WalRcvShmemInit();
+ 	ProcPipeShmemInit();
  
  	/*
  	 * Set up other modules that need some shared memory space
diff --git a/src/backend/storage/ipc/procsignal.c b/src/backend/storage/ipc/procsignal.c
new file mode 100644
index 0abde43..c28b44f
*** a/src/backend/storage/ipc/procsignal.c
--- b/src/backend/storage/ipc/procsignal.c
***************
*** 27,32 ****
--- 27,33 ----
  #include "storage/sinval.h"
  #include "tcop/tcopprot.h"
  
+ #include "utils/signal_demo.h"
  
  /*
   * The SIGUSR1 signal is multiplexed to support signalling multiple event
*************** bool		set_latch_on_sigusr1;
*** 69,75 ****
  
  static ProcSignalSlot *ProcSignalSlots = NULL;
  static volatile ProcSignalSlot *MyProcSignalSlot = NULL;
! 
  static bool CheckProcSignal(ProcSignalReason reason);
  static void CleanupProcSignalState(int status, Datum arg);
  
--- 70,76 ----
  
  static ProcSignalSlot *ProcSignalSlots = NULL;
  static volatile ProcSignalSlot *MyProcSignalSlot = NULL;
!  
  static bool CheckProcSignal(ProcSignalReason reason);
  static void CleanupProcSignalState(int status, Datum arg);
  
*************** procsignal_sigusr1_handler(SIGNAL_ARGS)
*** 296,301 ****
--- 297,305 ----
  	if (CheckProcSignal(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN))
  		RecoveryConflictInterrupt(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN);
  
+ 	if (CheckProcSignal(PROCSIG_SEND_INFO))
+ 		SendProcessInfoInterrupt();
+ 
  	if (set_latch_on_sigusr1)
  		SetLatch(MyLatch);
  
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
new file mode 100644
index d917af3..51701b8
*** a/src/backend/tcop/postgres.c
--- b/src/backend/tcop/postgres.c
*************** ProcessInterrupts(void)
*** 2991,2996 ****
--- 2991,2999 ----
  
  	if (ParallelMessagePending)
  		HandleParallelMessages();
+ 
+ 	if (SendProcessInfoPending)
+ 		HandleSendProcessInfo();
  }
  
  
diff --git a/src/backend/utils/adt/Makefile b/src/backend/utils/adt/Makefile
new file mode 100644
index 3ed0b44..864970c
*** a/src/backend/utils/adt/Makefile
--- b/src/backend/utils/adt/Makefile
*************** OBJS = acl.o arrayfuncs.o array_expanded
*** 36,42 ****
  	tsquery_op.o tsquery_rewrite.o tsquery_util.o tsrank.o \
  	tsvector.o tsvector_op.o tsvector_parser.o \
  	txid.o uuid.o varbit.o varchar.o varlena.o version.o \
! 	windowfuncs.o xid.o xml.o
  
  like.o: like.c like_match.c
  
--- 36,42 ----
  	tsquery_op.o tsquery_rewrite.o tsquery_util.o tsrank.o \
  	tsvector.o tsvector_op.o tsvector_parser.o \
  	txid.o uuid.o varbit.o varchar.o varlena.o version.o \
! 	windowfuncs.o xid.o xml.o signal_demo.o
  
  like.o: like.c like_match.c
  
diff --git a/src/backend/utils/adt/signal_demo.c b/src/backend/utils/adt/signal_demo.c
new file mode 100644
index ...5de50b5
*** a/src/backend/utils/adt/signal_demo.c
--- b/src/backend/utils/adt/signal_demo.c
***************
*** 0 ****
--- 1,411 ----
+ #include "postgres.h"
+ 
+ #include "miscadmin.h"
+ 
+ #include "storage/backendid.h"
+ #include "storage/ipc.h"
+ #include "storage/procarray.h"
+ #include "storage/shm_mq.h"
+ #include "storage/shm_toc.h"
+ #include "utils/builtins.h"
+ #include "utils/resowner.h"
+ #include "utils/signal_demo.h"
+ 
+ #include "storage/dsm.h"
+ 
+ 
+ typedef struct
+ {
+ 	pid_t			pss_pid;
+ 	pid_t			sender_pss_pid;
+ 	BackendId		sender_backendId;
+ 	dsm_handle		dsm_seg_handle;
+ 	int			data_tag;
+ 	bool		is_valid;
+ 	bool		is_in_process;
+ 	bool		is_processed;
+ } ProcPipeSlot;
+ 
+ 
+ #define NumProcPipeSlots	(MaxBackends + NUM_AUXPROCTYPES)
+ 
+ #define PG_SEND_PROCESS_INFO_MAGIC 0x79fb2449
+ #define SEND_INFO_DEMO_TAG		1
+ 
+ static ProcPipeSlot *ProcPipeSlots = NULL;
+ static volatile ProcPipeSlot *MyProcPipeSlot = NULL;
+ 
+ volatile bool	SendProcessInfoPending = false;
+ 
+ static char *prepare_demo_data(int length, bool is_active_stmt);
+ 
+ 
+ Size
+ ProcPipeShmemSize(void)
+ {
+ 	return NumProcPipeSlots * sizeof(ProcPipeSlot);
+ }
+ 
+ void
+ ProcPipeShmemInit(void)
+ {
+ 	Size		size = ProcPipeShmemSize();
+ 	bool		found;
+ 
+ 	ProcPipeSlots = (ProcPipeSlot *)
+ 		ShmemInitStruct("ProcPipeSlots", size, &found);
+ 
+ 	if (!found)
+ 		MemSet(ProcPipeSlots, 0, size);
+ }
+ 
+ static void
+ CleanupProcPipeSlot(int status, Datum arg)
+ {
+ 	int		pss_idx = DatumGetInt32(arg);
+ 	volatile ProcPipeSlot *slot;
+ 
+ 	slot = &ProcPipeSlots[pss_idx - 1];
+ 	Assert(slot == MyProcPipeSlot);
+ 
+ 	MyProcPipeSlot = NULL;
+ 
+ 	if (slot->pss_pid != MyProcPid)
+ 	{
+ 		elog(LOG, "process %d releasing ProcSignal slot %d, but it contains %d",
+ 			 MyProcPid, pss_idx, (int) slot->pss_pid);
+ 		return;					/* XXX better to zero the slot anyway? */
+ 	}
+ 
+ 	slot->pss_pid = 0;
+ 	slot->is_valid = false;
+ }
+ 
+ void
+ ProcPipeInit(int pss_idx)
+ {
+ 	volatile ProcPipeSlot *slot;
+ 
+ 	slot = &ProcPipeSlots[pss_idx - 1];
+ 
+ 	if (slot->pss_pid != 0)
+ 		elog(LOG, "process %d taking over ProcPipe slot %d, but it's not empty",
+ 				 MyProcPid, pss_idx);
+ 
+ 	slot->pss_pid = MyProcPid;
+ 	slot->is_valid = false;
+ 
+ 	MyProcPipeSlot = slot;
+ 
+ 	on_shmem_exit(CleanupProcPipeSlot, Int32GetDatum(pss_idx));
+ }
+ 
+ /*
+  * Send request to data to targetted process. Result is taken from SendProcSignal
+  */
+ int
+ SendProcessInfoSignal(pid_t data_sender_pid, BackendId data_sender_backendId,
+ 		    dsm_handle dsm_seg_handle, int data_tag)
+ {
+ 	MyProcPipeSlot->sender_pss_pid = data_sender_pid;
+ 	MyProcPipeSlot->sender_backendId = data_sender_backendId;
+ 	MyProcPipeSlot->dsm_seg_handle = dsm_seg_handle;
+ 	MyProcPipeSlot->data_tag = data_tag;
+ 	MyProcPipeSlot->is_valid = true;
+ 	MyProcPipeSlot->is_in_process = false;
+ 	MyProcPipeSlot->is_processed = false;
+ 
+ 	return SendProcSignal(data_sender_pid, PROCSIG_SEND_INFO, data_sender_backendId);
+ }
+ 
+ void
+ InvalidateProcPipeSlot(void)
+ {
+ 	MyProcPipeSlot->is_valid = false;
+ }
+ 
+ bool
+ is_valid_result(void)
+ {
+ 	return MyProcPipeSlot->is_valid;
+ }
+ 
+ 
+ /*
+  * signal is handled quickly - don't do heavy work here
+  */
+ void
+ SendProcessInfoInterrupt(void)
+ {
+ 	volatile ProcPipeSlot *slot;
+ 	int		i;
+ 
+ 	for (i = NumProcPipeSlots - 1; i >= 0; i--)
+ 	{
+ 		slot = &ProcPipeSlots[i];
+ 		if (slot->sender_pss_pid == MyProcPid && slot->is_valid
+ 				 && !(slot->is_processed || slot->is_in_process))
+ 		{
+ 			SendProcessInfoPending = true;
+ 			InterruptPending = true;
+ 
+ 			SetLatch(MyLatch);
+ 
+ 			return;
+ 		}
+ 	}
+ }
+ 
+ static void
+ RestoreResourceOwner(ResourceOwner prevResourceOwner)
+ {
+ 	if (prevResourceOwner != CurrentResourceOwner)
+ 	{
+ 		ResourceOwner deleted_ro = CurrentResourceOwner;
+ 
+ 		CurrentResourceOwner = prevResourceOwner;
+ 		ResourceOwnerDelete(deleted_ro);
+ 	}
+ }
+ 
+ void
+ HandleSendProcessInfo(void)
+ {
+ 	volatile ProcPipeSlot *slot;
+ 
+ 	while (SendProcessInfoPending)
+ 	{
+ 		int		i;
+ 
+ 		SendProcessInfoPending = false;
+ 
+ 		for (i = NumProcPipeSlots - 1; i >= 0; i--)
+ 		{
+ 			slot = &ProcPipeSlots[i];
+ 
+ 			if (slot->sender_pss_pid == MyProcPid && slot->is_valid && !slot->is_processed)
+ 			{
+ 				ResourceOwner prevRO = CurrentResourceOwner;
+ 
+ 				dsm_segment	*seg = NULL;
+ 				shm_toc		*toc = NULL;
+ 				shm_mq_handle		*output;
+ 				shm_mq			*mq;
+ 				int		length, *length_ptr;
+ 
+ 				/* fast leave when tag is unsupported */
+ 				if (slot->data_tag != SEND_INFO_DEMO_TAG)
+ 				{
+ 					slot->is_processed = true;
+ 					slot->is_valid = false;
+ 					continue;
+ 				}
+ 
+ 				/* Ensure valid resource owner for access to dsm */
+ 				if (CurrentResourceOwner == NULL)
+ 					CurrentResourceOwner = ResourceOwnerCreate(NULL, "HandlerSendProcessInfo");
+ 
+ 				seg = dsm_attach(slot->dsm_seg_handle);
+ 				if (seg == NULL)
+ 				{
+ 					elog(LOG, "unable map dynamic memory segment");
+ 					slot->is_processed = true;
+ 					slot->is_valid = false;
+ 
+ 					RestoreResourceOwner(prevRO);
+ 
+ 					continue;
+ 				}
+ 
+ 				toc = shm_toc_attach(PG_SEND_PROCESS_INFO_MAGIC, dsm_segment_address(seg));
+ 				if (toc == NULL)
+ 				{
+ 					elog(LOG, "bad magic number in passed dynamic memory segment");
+ 
+ 					dsm_detach(seg);
+ 					slot->is_processed = true;
+ 					slot->is_valid = false;
+ 
+ 					RestoreResourceOwner(prevRO);
+ 
+ 					continue;
+ 				}
+ 
+ 				mq = shm_toc_lookup(toc, 0);
+ 				output = shm_mq_attach(mq, seg, NULL);
+ 
+ 				length_ptr = shm_toc_lookup(toc, 1);
+ 				length = *length_ptr;
+ 
+ 				/* do potentialy heavy and slow work */
+ 				PG_TRY();
+ 				{
+ 					char *data;
+ 					shm_mq_result		res;
+ 
+ 					data = prepare_demo_data(length, prevRO == CurrentResourceOwner);
+ 					res = shm_mq_send(output, length + 1, data, false);
+ 					if (res != SHM_MQ_SUCCESS)
+ 					{
+ 						elog(LOG, "unable to send data to recipient");
+ 
+ 						dsm_detach(seg);
+ 						slot->is_processed = true;
+ 						slot->is_valid = false;
+ 					}
+ 
+ 					slot->is_processed = true;
+ 					shm_mq_detach(mq);
+ 					dsm_detach(seg);
+ 
+ 					RestoreResourceOwner(prevRO);
+ 				}
+ 				PG_CATCH();
+ 				{
+ 					slot->is_processed = true;
+ 					slot->is_valid = false;
+ 
+ 					if (seg != NULL)
+ 						dsm_detach(seg);
+ 
+ 					RestoreResourceOwner(prevRO);
+ 
+ 					PG_RE_THROW();
+ 				}
+ 				PG_END_TRY();
+ 
+ 			}
+ 		}
+ 	}
+ }
+ 
+ /*
+  * generate some content that will be sended to recipient
+  */
+ static char *
+ prepare_demo_data(int length, bool is_active_stmt)
+ {
+ 	char *buffer, *ptr;
+ 	char *chars = "0123456789";
+ 	int padding = 0;
+ 
+ 	length = length < 100 ? 100 : length;
+ 
+ 	buffer = palloc(length + 1);
+ 
+ 	if (!is_active_stmt)
+ 	{
+ 		sprintf(buffer, "idle sender pid: %d", MyProcPid);
+ 		return buffer;
+ 	}
+ 
+ 	sprintf(buffer, "sender pid: %d\n", MyProcPid);
+ 
+ 	ptr = buffer + strlen(buffer);
+ 	length -= strlen(buffer);
+ 
+ 	while (length > 1)
+ 	{
+ 		*ptr++ = chars[padding++ % 10];
+ 
+ 		length--;
+ 		if (padding % 30 == 0)
+ 		{
+ 			*ptr++ = '\n';
+ 			length--;
+ 		}
+ 	}
+ 
+ 	*ptr++ = '#';
+ 	*ptr = '\0';
+ 
+ 	return buffer;
+ }
+ 
+ /*
+  * Send custom signal and returns string generated by signaled process.
+  */
+ Datum
+ signal_process(PG_FUNCTION_ARGS)
+ {
+ 	int		pid = PG_GETARG_INT32(0);
+ 	int		length = PG_GETARG_INT32(1);
+ 	dsm_segment		*seg;
+ 	shm_toc_estimator	e;
+ 	shm_toc			*toc;
+ 	shm_mq			*mq;
+ 	shm_mq_handle		*input;
+ 	shm_mq_result		res;
+ 	Size		segsize;
+ 	int		*param_ptr;
+ 	text		*result;
+ 	PGPROC	*proc;
+ 	Size		received_data_length;
+ 	char		*data;
+ 
+ 	if (pid == MyProcPid)
+ 		elog(ERROR, "cannot to send signal to self");
+ 
+ 	proc = BackendPidGetProc(pid);
+ 	if (proc == NULL)
+ 		elog(ERROR, "invalid pid");
+ 
+ 	if (length < 30)
+ 		elog(ERROR, "second parameter (length: %d) should be >= 30", length);
+ 
+ 
+ 	/* prepare shared dsm segment */
+ 	shm_toc_initialize_estimator(&e);
+ 	shm_toc_estimate_chunk(&e, 1024);
+ 	shm_toc_estimate_chunk(&e, sizeof(int));
+ 	shm_toc_estimate_keys(&e, 2);
+ 	segsize = shm_toc_estimate(&e);
+ 
+ 	seg = dsm_create(segsize, DSM_CREATE_NULL_IF_MAXSEGMENTS);
+ 	if (seg == NULL)
+ 		elog(ERROR, "cannot to create dsm segment");
+ 
+ 	PG_TRY();
+ 	{
+ 		toc = shm_toc_create(PG_SEND_PROCESS_INFO_MAGIC, dsm_segment_address(seg), segsize);
+ 		if (toc == NULL)
+ 			elog(ERROR, "cannot to create toc");
+ 
+ 		/* prepare basic structures */
+ 		mq = shm_mq_create(shm_toc_allocate(toc, 1024), 1024);
+ 		shm_mq_set_receiver(mq, MyProc);
+ 		shm_mq_set_sender(mq, proc);
+ 		shm_toc_insert(toc, 0, mq);
+ 
+ 		param_ptr = (int *) shm_toc_allocate(toc, sizeof(int));
+ 		*param_ptr = length;
+ 		shm_toc_insert(toc, 1, param_ptr);
+ 
+ 		if (SendProcessInfoSignal(pid, proc->backendId , dsm_segment_handle(seg), SEND_INFO_DEMO_TAG))
+ 			elog(ERROR, "could not send signal to process");
+ 
+ 		/* try to read from queue */
+ 		input = shm_mq_attach(mq, seg, NULL);
+ 		res = shm_mq_receive(input, &received_data_length, (void **) &data, false);
+ 		if (res != SHM_MQ_SUCCESS)
+ 			elog(ERROR, "could not receive message");
+ 
+ 		if (!is_valid_result())
+ 			elog(ERROR, "sender doesn't send valid data");
+ 
+ 		result = cstring_to_text_with_len(data, received_data_length - 1);
+ 
+ 		InvalidateProcPipeSlot();
+ 		shm_mq_detach(mq);
+ 		dsm_detach(seg);
+ 	}
+ 	PG_CATCH();
+ 	{
+ 		InvalidateProcPipeSlot();
+ 		dsm_detach(seg);
+ 		PG_RE_THROW();
+ 	}
+ 	PG_END_TRY();
+ 
+ 	PG_RETURN_TEXT_P(result);
+ }
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
new file mode 100644
index 7b19714..5a36936
*** a/src/backend/utils/init/postinit.c
--- b/src/backend/utils/init/postinit.c
***************
*** 60,66 ****
  #include "utils/syscache.h"
  #include "utils/timeout.h"
  #include "utils/tqual.h"
! 
  
  static HeapTuple GetDatabaseTuple(const char *dbname);
  static HeapTuple GetDatabaseTupleByOid(Oid dboid);
--- 60,66 ----
  #include "utils/syscache.h"
  #include "utils/timeout.h"
  #include "utils/tqual.h"
! #include "utils/signal_demo.h"
  
  static HeapTuple GetDatabaseTuple(const char *dbname);
  static HeapTuple GetDatabaseTupleByOid(Oid dboid);
*************** InitPostgres(const char *in_dbname, Oid
*** 588,593 ****
--- 588,596 ----
  	/* Now that we have a BackendId, we can participate in ProcSignal */
  	ProcSignalInit(MyBackendId);
  
+ 	/* And same for ProcPipe */
+ 	ProcPipeInit(MyBackendId);
+ 
  	/*
  	 * Also set up timeout handlers needed for backend operation.  We need
  	 * these in every case except bootstrap.
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
new file mode 100644
index ddf7c67..ae25559
*** a/src/include/catalog/pg_proc.h
--- b/src/include/catalog/pg_proc.h
*************** DATA(insert OID = 2171 ( pg_cancel_backe
*** 3134,3139 ****
--- 3134,3141 ----
  DESCR("cancel a server process' current query");
  DATA(insert OID = 2096 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
  DESCR("terminate a server process");
+ DATA(insert OID = 4066 ( signal_process		PGNSP PGUID 12 1 0 0 0 f f f f t f v 2 0 25 "23 23" _null_ _null_ _null_ _null_ _null_ signal_process _null_ _null_ _null_ ));
+ DESCR("cancel a server process' current query");
  DATA(insert OID = 2172 ( pg_start_backup		PGNSP PGUID 12 1 0 0 0 f f f f t f v 2 0 3220 "25 16" _null_ _null_ _null_ _null_ _null_ pg_start_backup _null_ _null_ _null_ ));
  DESCR("prepare for taking an online backup");
  DATA(insert OID = 2173 ( pg_stop_backup			PGNSP PGUID 12 1 0 0 0 f f f f t f v 0 0 3220 "" _null_ _null_ _null_ _null_ _null_ pg_stop_backup _null_ _null_ _null_ ));
diff --git a/src/include/miscadmin.h b/src/include/miscadmin.h
new file mode 100644
index e0cc69f..3b9a7bf
*** a/src/include/miscadmin.h
--- b/src/include/miscadmin.h
***************
*** 80,85 ****
--- 80,86 ----
  extern PGDLLIMPORT volatile bool InterruptPending;
  extern PGDLLIMPORT volatile bool QueryCancelPending;
  extern PGDLLIMPORT volatile bool ProcDiePending;
+ extern PGDLLIMPORT volatile bool SendProcessInfoPending;
  
  extern volatile bool ClientConnectionLost;
  
*************** extern void SwitchBackToLocalLatch(void)
*** 324,329 ****
--- 325,333 ----
  extern bool superuser(void);	/* current user is superuser */
  extern bool superuser_arg(Oid roleid);	/* given user is superuser */
  
+ /* utils/misc/signal_demo.c */
+ extern void HandleSendProcessInfo(void);
+ 
  
  /*****************************************************************************
   *	  pmod.h --																 *
diff --git a/src/include/storage/procsignal.h b/src/include/storage/procsignal.h
new file mode 100644
index af1a0cd..0d692a7
*** a/src/include/storage/procsignal.h
--- b/src/include/storage/procsignal.h
*************** typedef enum
*** 32,37 ****
--- 32,38 ----
  	PROCSIG_CATCHUP_INTERRUPT,	/* sinval catchup interrupt */
  	PROCSIG_NOTIFY_INTERRUPT,	/* listen/notify interrupt */
  	PROCSIG_PARALLEL_MESSAGE,	/* message from cooperating parallel backend */
+ 	PROCSIG_SEND_INFO,		/* internal info request */
  
  	/* Recovery conflict reasons */
  	PROCSIG_RECOVERY_CONFLICT_DATABASE,
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
new file mode 100644
index fc1679e..7310dc0
*** a/src/include/utils/builtins.h
--- b/src/include/utils/builtins.h
*************** extern Datum pg_prepared_statement(PG_FU
*** 1264,1267 ****
--- 1264,1270 ----
  /* utils/mmgr/portalmem.c */
  extern Datum pg_cursor(PG_FUNCTION_ARGS);
  
+ /* utils/signal_demo.c */
+ extern Datum signal_process(PG_FUNCTION_ARGS);
+ 
  #endif   /* BUILTINS_H */
diff --git a/src/include/utils/signal_demo.h b/src/include/utils/signal_demo.h
new file mode 100644
index ...0c951c4
*** a/src/include/utils/signal_demo.h
--- b/src/include/utils/signal_demo.h
***************
*** 0 ****
--- 1,14 ----
+ #include "storage/dsm.h"
+ 
+ extern Size ProcPipeShmemSize(void);
+ extern void ProcPipeShmemInit(void);
+ extern void ProcPipeInit(int pss_idx);
+ 
+ extern int SendProcessInfoSignal(pid_t data_sender_pid, BackendId data_sender_backendId,
+ 		    dsm_handle dsm_seg_handle, int data_tag);
+ 
+ extern void SendProcessInfoInterrupt(void);
+ extern void HandleSendProcessInfo(void);
+ 
+ extern void InvalidateProcPipeSlot(void);
+ extern bool is_valid_result(void);

diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 32ac58f..a2b757c 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -139,6 +139,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, BTreeShmemSize());
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
+		size = add_size(size, CmdStatusShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -243,6 +244,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	ReplicationOriginShmemInit();
 	WalSndShmemInit();
 	WalRcvShmemInit();
+	CmdStatusShmemInit();
 
 	/*
 	 * Set up other modules that need some shared memory space
diff --git a/src/backend/storage/ipc/procsignal.c b/src/backend/storage/ipc/procsignal.c
index 0abde43..e637be1 100644
--- a/src/backend/storage/ipc/procsignal.c
+++ b/src/backend/storage/ipc/procsignal.c
@@ -26,6 +26,7 @@
 #include "storage/shmem.h"
 #include "storage/sinval.h"
 #include "tcop/tcopprot.h"
+#include "utils/cmdstatus.h"
 
 
 /*
@@ -296,6 +297,9 @@ procsignal_sigusr1_handler(SIGNAL_ARGS)
 	if (CheckProcSignal(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN))
 		RecoveryConflictInterrupt(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN);
 
+	if (CheckProcSignal(PROCSIG_CMD_STATUS_INFO))
+		HandleCmdStatusInfoInterrupt();
+
 	if (set_latch_on_sigusr1)
 		SetLatch(MyLatch);
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index d917af3..1a5b03c 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -67,6 +67,7 @@
 #include "tcop/pquery.h"
 #include "tcop/tcopprot.h"
 #include "tcop/utility.h"
+#include "utils/cmdstatus.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/ps_status.h"
@@ -2991,6 +2992,9 @@ ProcessInterrupts(void)
 
 	if (ParallelMessagePending)
 		HandleParallelMessages();
+
+	if (CmdStatusInfoPending)
+		ProcessCmdStatusInfoRequest();
 }
 
 
diff --git a/src/backend/utils/adt/Makefile b/src/backend/utils/adt/Makefile
index 3ed0b44..2c8687c 100644
--- a/src/backend/utils/adt/Makefile
+++ b/src/backend/utils/adt/Makefile
@@ -18,7 +18,7 @@ endif
 # keep this list arranged alphabetically or it gets to be a mess
 OBJS = acl.o arrayfuncs.o array_expanded.o array_selfuncs.o \
 	array_typanalyze.o array_userfuncs.o arrayutils.o ascii.o \
-	bool.o cash.o char.o date.o datetime.o datum.o dbsize.o domains.o \
+	bool.o cash.o char.o cmdstatus.o date.o datetime.o datum.o dbsize.o domains.o \
 	encode.o enum.o expandeddatum.o \
 	float.o format_type.o formatting.o genfile.o \
 	geo_ops.o geo_selfuncs.o inet_cidr_ntop.o inet_net_pton.o int.o \
diff --git a/src/backend/utils/adt/cmdstatus.c b/src/backend/utils/adt/cmdstatus.c
new file mode 100644
index 0000000..c17de9d
--- /dev/null
+++ b/src/backend/utils/adt/cmdstatus.c
@@ -0,0 +1,647 @@
+/*-------------------------------------------------------------------------
+ *
+ * cmdstatus.c
+ *	  Definitions for pg_cmdstatus function.
+ *
+ * Copyright (c) 1996-2015, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/backend/utils/adt/cmdstatus.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "funcapi.h"
+#include "miscadmin.h"
+
+#include "access/htup_details.h"
+#include "commands/explain.h"
+#include "lib/stringinfo.h"
+#include "storage/dsm.h"
+#include "storage/ipc.h"
+#include "storage/latch.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "storage/shm_mq.h"
+#include "storage/shm_toc.h"
+#include "tcop/dest.h"
+#include "tcop/pquery.h"
+#include "utils/builtins.h"
+#include "utils/cmdstatus.h"
+
+
+typedef enum {
+	CMD_STATUS_REQUEST_EXPLAIN = 1,
+	CMD_STATUS_REQUEST_QUERY_TEXT = 2,
+	CMD_STATUS_REQUEST_PROGRESS_TAG = 3,
+	CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE = 4
+} CmdStatusInfoRequestType;
+
+#define CMD_STATUS_MAX_REQUEST CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE
+
+typedef enum {
+	CMD_STATUS_RESULT_FAILURE = -1,
+	CMD_STATUS_RESULT_SUCCESS = 0,
+	CMD_STATUS_RESULT_BACKEND_IDLE,
+	CMD_STATUS_RESULT_NO_COMMAND_TAG
+} CmdStatusInfoResultCode;
+
+typedef struct
+{
+	pid_t			css_pid;
+	pid_t			sender_css_pid;
+	/*BackendId		sender_backend_id;*/
+	dsm_handle		dsm_seg_handle;
+	CmdStatusInfoRequestType	request_type;
+	CmdStatusInfoResultCode		result_code;
+	bool			is_valid;
+	bool			is_processed;
+} CmdStatusSlot;
+
+#define NumCmdStatusSlots	(MaxBackends + NUM_AUXPROCTYPES)
+
+#define PG_CMD_STATUS_INFO_MAGIC	0x79fb2449
+#define CMD_STATUS_BUFFER_SIZE		1024
+
+/*
+ * These structs are allocated on the program stack as local variables in the
+ * ExecutorRun hook.  The top of stack is current_query_stack, see below.
+ */
+typedef struct CmdInfoStack {
+	QueryDesc			   *query_desc;
+	struct CmdInfoStack	   *parent;
+} CmdInfoStack;
+
+
+static CmdStatusSlot *CmdStatusSlots = NULL;
+static volatile CmdStatusSlot *MyCmdStatusSlot = NULL;
+
+static CmdInfoStack	   *current_query_stack = NULL;
+static int				query_stack_size = 0;
+
+static ExecutorRun_hook_type	prev_ExecutorRun = NULL;
+
+static void cmdstatus_ExecutorRun(QueryDesc *queryDesc,
+								  ScanDirection direction, long count);
+
+
+Size
+CmdStatusShmemSize(void)
+{
+	return NumCmdStatusSlots * sizeof(CmdStatusSlot);
+}
+
+void
+CmdStatusShmemInit(void)
+{
+	Size		size = CmdStatusShmemSize();
+	bool		found;
+
+	CmdStatusSlots = (CmdStatusSlot *)
+		ShmemInitStruct("CmdStatusSlots", size, &found);
+
+	if (!found)
+		MemSet(CmdStatusSlots, 0, size);
+}
+
+static void
+CleanupCmdStatusSlot(int status, Datum arg)
+{
+	int		css_idx = DatumGetInt32(arg);
+	volatile CmdStatusSlot *slot;
+
+	slot = &CmdStatusSlots[css_idx - 1];
+	Assert(slot == MyCmdStatusSlot);
+
+	MyCmdStatusSlot = NULL;
+
+	if (slot->css_pid != MyProcPid)
+	{
+		elog(LOG, "process %d releasing ProcSignal slot %d, but it contains %d",
+			 MyProcPid, css_idx, (int) slot->css_pid);
+		return;					/* XXX better to zero the slot anyway? */
+	}
+
+	slot->css_pid = 0;
+	slot->is_valid = false;
+}
+
+void
+CmdStatusInit(int css_idx)
+{
+	volatile CmdStatusSlot *slot;
+
+	slot = &CmdStatusSlots[css_idx - 1];
+
+	if (slot->css_pid != 0)
+		elog(LOG, "process %d taking over CmdStatus slot %d, but it's not empty",
+			 MyProcPid, css_idx);
+
+	slot->css_pid = MyProcPid;
+	slot->is_valid = false;
+
+	MyCmdStatusSlot = slot;
+
+	on_shmem_exit(CleanupCmdStatusSlot, Int32GetDatum(css_idx));
+
+	/* also install executor hooks */
+	prev_ExecutorRun = ExecutorRun_hook;
+	ExecutorRun_hook = cmdstatus_ExecutorRun;
+}
+
+static int
+SendCmdStatusInfoSignal(pid_t target_pid, BackendId target_backend_id,
+						dsm_handle dsm_seg_handle,
+						CmdStatusInfoRequestType request_type)
+{
+	MyCmdStatusSlot->sender_css_pid = target_pid;
+	/*MyCmdStatusSlot->sender_backend_id = target_backend_id;*/
+	MyCmdStatusSlot->dsm_seg_handle = dsm_seg_handle;
+	MyCmdStatusSlot->request_type = request_type;
+	MyCmdStatusSlot->is_processed = false;
+	MyCmdStatusSlot->is_valid = true;		/* this should be set the latest */
+
+	return SendProcSignal(target_pid, PROCSIG_CMD_STATUS_INFO, target_backend_id);
+}
+
+static void
+InvalidateCmdStatusSlot(void)
+{
+	MyCmdStatusSlot->is_valid = false;
+	MyCmdStatusSlot->is_processed = false;
+	MyCmdStatusSlot->sender_css_pid = 0;
+	/*MyCmdStatusSlot->sender_backend_id = 0; */
+	MyCmdStatusSlot->dsm_seg_handle = NULL;
+	MyCmdStatusSlot->request_type = 0;
+}
+
+
+
+static void
+cmdstatus_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, long count)
+{
+	CmdInfoStack	current;
+
+	current.query_desc = queryDesc;
+	current.parent = current_query_stack;
+
+	current_query_stack = &current;
+	query_stack_size++;
+
+	PG_TRY();
+	{
+		if (prev_ExecutorRun)
+			prev_ExecutorRun(queryDesc, direction, count);
+		else
+			standard_ExecutorRun(queryDesc, direction, count);
+
+		Assert(current_query_stack == &current);
+		Assert(query_stack_size > 0);
+
+		query_stack_size--;
+		current_query_stack = current.parent;
+	}
+	PG_CATCH();
+	{
+		Assert(current_query_stack == &current);
+		Assert(query_stack_size > 0);
+
+		query_stack_size--;
+		current_query_stack = current.parent;
+
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+}
+
+
+static StringInfo
+explain_query(QueryDesc *queryDesc)
+{
+	StringInfo		str;
+	ExplainState   *es;
+
+	es = NewExplainState();
+	es->analyze = false;
+	es->verbose = false;
+	es->buffers = false;
+	es->format = EXPLAIN_FORMAT_TEXT;
+
+	ExplainBeginOutput(es);
+	/* XXX: appendStringInfo(es->str, "#%d ", depth); ? */
+	ExplainQueryText(es, queryDesc);
+	ExplainPrintPlan(es, queryDesc);
+	ExplainEndOutput(es);
+
+	str = es->str;
+
+	pfree(es);
+	return str;
+}
+
+
+/* signal handler for PROCSIG_CMD_STATUS_INFO */
+void
+HandleCmdStatusInfoInterrupt(void)
+{
+	CmdStatusInfoPending = true;
+	InterruptPending = true;
+
+	SetLatch(MyLatch);
+}
+
+
+static StringInfo
+ProcessCmdStatusSlot(volatile CmdStatusSlot *slot)
+{
+	StringInfo		result = NULL;
+
+	/* Show some optimism. */
+	slot->result_code = CMD_STATUS_RESULT_SUCCESS;
+
+	if (ActivePortal)
+	{
+		switch (slot->request_type)
+		{
+			case CMD_STATUS_REQUEST_EXPLAIN:
+				result = explain_query(ActivePortal->queryDesc);
+				break;
+
+			case CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE:
+				{
+					StringInfo		str;
+					CmdInfoStack   *query;
+
+					result = makeStringInfo();
+
+					if (current_query_stack != NULL)
+					{
+						for (query = current_query_stack;
+							 query != NULL;
+							 query = query->parent)
+						{
+							str = explain_query(query->query_desc);
+							appendBinaryStringInfo(result, str->data, str->len);
+
+							pfree(str->data);
+							pfree(str);
+						}
+					}
+					else
+					{
+						/* XXX */
+						slot->result_code = CMD_STATUS_RESULT_BACKEND_IDLE;
+					}
+					break;
+				}
+
+			case CMD_STATUS_REQUEST_QUERY_TEXT:
+				{
+					result = makeStringInfo();
+					appendStringInfoString(result, ActivePortal->sourceText);
+				}
+				break;
+
+			case CMD_STATUS_REQUEST_PROGRESS_TAG:
+				if (ActivePortal->commandTag != NULL)
+				{
+					result = makeStringInfo();
+
+					if (ActivePortal->queryDesc != NULL &&
+						ActivePortal->queryDesc->estate != NULL)
+					{
+						appendStringInfo(result, "%s %u",
+										 ActivePortal->commandTag,
+										 ActivePortal->queryDesc->estate->es_processed);
+					}
+					else
+					{
+						/* no progress available, at least show the command tag */
+						appendStringInfoString(result, ActivePortal->commandTag);
+					}
+				}
+				else
+				{
+					slot->result_code = CMD_STATUS_RESULT_NO_COMMAND_TAG;
+				}
+				break;
+		}
+	}
+	else
+	{
+		slot->result_code = CMD_STATUS_RESULT_BACKEND_IDLE;
+	}
+
+	return result;
+}
+
+static void
+RestoreResourceOwner(ResourceOwner prevResourceOwner)
+{
+	if (prevResourceOwner != CurrentResourceOwner)
+	{
+		ResourceOwner	res_owner = CurrentResourceOwner;
+
+		CurrentResourceOwner = prevResourceOwner;
+		ResourceOwnerDelete(res_owner);
+	}
+}
+
+void
+ProcessCmdStatusInfoRequest(void)
+{
+	elog(LOG, "+ProcessCmdStatusInfoRequest: %d", CmdStatusInfoPending);
+
+	while (CmdStatusInfoPending)
+	{
+		int		i;
+
+		CmdStatusInfoPending = false;
+
+		for (i = 0; i < NumCmdStatusSlots; i++)
+		{
+			volatile CmdStatusSlot *slot = &CmdStatusSlots[i];
+
+			if (slot->sender_css_pid == MyProcPid)
+			{
+				elog(LOG, "found receiver slot: PID %d, valid: %d, processed: %d",
+					 slot->css_pid, slot->is_valid, slot->is_processed);
+
+			if (slot->is_valid && !slot->is_processed)
+			{
+				ResourceOwner	prevResourceOwner = CurrentResourceOwner;
+				dsm_segment	   *seg = NULL;
+				shm_toc		   *toc = NULL;
+				shm_mq_handle  *output;
+				shm_mq		   *mq;
+
+				/* Ensure valid resource owner for access to dsm. */
+				if (CurrentResourceOwner == NULL)
+					CurrentResourceOwner = ResourceOwnerCreate(NULL, "ProcessCmdStatusInfoRequest");
+
+				seg = dsm_attach(slot->dsm_seg_handle);
+				if (seg == NULL)
+				{
+					elog(LOG, "unable to map dynamic memory segment for command status");
+
+					slot->is_processed = true;
+					slot->is_valid = false;
+
+					RestoreResourceOwner(prevResourceOwner);
+					continue;
+				}
+
+				toc = shm_toc_attach(PG_CMD_STATUS_INFO_MAGIC, dsm_segment_address(seg));
+				if (toc == NULL)
+				{
+					elog(LOG, "bad magic in dynamic memory segment for command status");
+
+					slot->is_processed = true;
+					slot->is_valid = false;
+
+					dsm_detach(seg);
+
+					RestoreResourceOwner(prevResourceOwner);
+					continue;
+				}
+
+				mq = shm_toc_lookup(toc, 0);
+
+				elog(LOG, "sender: attaching mq");
+				output = shm_mq_attach(mq, seg, NULL);
+
+				PG_TRY();
+				{
+					StringInfo		payload;
+					int				res;
+
+					payload = ProcessCmdStatusSlot(slot);
+					if (payload != NULL)
+					{
+						elog(LOG, "sender: sending payload");
+
+						slot->is_processed = true;
+
+						res = shm_mq_send(output, payload->len, payload->data, false);
+						if (res != SHM_MQ_SUCCESS)
+						{
+							elog(LOG, "cannot send command status to backend with PID %d",
+								 slot->css_pid);
+							slot->is_valid = false;
+						}
+						pfree(payload->data);
+						pfree(payload);
+					}
+					else
+					{
+						slot->is_valid = false;
+					}
+
+					elog(LOG, "sender: detaching mq");
+					shm_mq_detach(mq);
+					dsm_detach(seg);
+
+					RestoreResourceOwner(prevResourceOwner);
+				}
+				PG_CATCH();
+				{
+					slot->is_processed = true;
+					slot->is_valid = false;
+
+					elog(LOG, "sender: detaching mq (ON ERROR)");
+					shm_mq_detach(mq);
+					dsm_detach(seg);
+
+					RestoreResourceOwner(prevResourceOwner);
+
+					PG_RE_THROW();
+				}
+				PG_END_TRY();
+			}
+			}
+		}
+	}
+
+	elog(LOG, "-ProcessCmdStatusInfoRequest");
+}
+
+static void
+report_result_code(CmdStatusInfoResultCode result, pid_t target_pid)
+{
+	switch (result)
+	{
+		case CMD_STATUS_RESULT_BACKEND_IDLE:
+			elog(INFO, "no command is currently running in backend with PID %d",
+				 target_pid);
+			break;
+
+		case CMD_STATUS_RESULT_NO_COMMAND_TAG:
+			elog(WARNING, "no command tag found for the query in backend with PID %d",
+				 target_pid);
+			break;
+
+		default:
+			elog(ERROR, "general command status request failure");
+			break;
+	}
+}
+
+/*
+ * try to get status of command in another process
+ *
+ * FUNCTION get_cmdstatus(pid, request_type)
+ * RETURNS SETOF text
+ */
+Datum
+pg_cmdstatus(PG_FUNCTION_ARGS)
+{
+	ReturnSetInfo	   *rsinfo	= (ReturnSetInfo *) fcinfo->resultinfo;
+	Tuplestorestate	   *tupstore;
+	TupleDesc			tupdesc;
+	MemoryContext		per_query_ctx;
+	MemoryContext		oldcontext;
+	pid_t				target_pid = (pid_t) PG_GETARG_INT32(0);
+	int					request_type = PG_GETARG_INT32(1);
+	PGPROC			   *proc;
+	shm_toc_estimator	estimator;
+	Size				segsize;
+	dsm_segment		   *seg = NULL;
+	shm_toc			   *toc = NULL;
+	shm_mq			   *mq = NULL;
+	shm_mq_handle	   *input = NULL;
+
+	/* check to see if caller supports us returning a tuplestore */
+	if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("set-valued function called in context that cannot accept a set")));
+
+	if (!(rsinfo->allowedModes & SFRM_Materialize))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("materialize mode required, but it is not allowed in this context")));
+
+	if (request_type < 1 || request_type > CMD_STATUS_MAX_REQUEST)
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("unknown command status request")));
+
+	/* need to build tuplestore in query context */
+	per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+	oldcontext = MemoryContextSwitchTo(per_query_ctx);
+
+	tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc);
+	tupstore = tuplestore_begin_heap(false, false, work_mem);
+	MemoryContextSwitchTo(oldcontext);
+
+	if (target_pid == MyProcPid)
+		ereport(ERROR,
+				(errmsg("backend cannot query command status of itself")));
+
+	/* verify access to target_pid */
+	proc = BackendPidGetProc(target_pid);
+
+	if (proc == NULL)
+		ereport(ERROR,
+				(errmsg("PID %d is not a PostgreSQL server process", target_pid)));
+
+	if (!(superuser() || proc->roleId == GetUserId()))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be superuser or have the same role to cancel queries running in other server processes"))));
+
+	/* prepare shared dsm segment */
+	shm_toc_initialize_estimator(&estimator);
+	shm_toc_estimate_keys(&estimator, 1);
+	shm_toc_estimate_chunk(&estimator, CMD_STATUS_BUFFER_SIZE);
+	segsize = shm_toc_estimate(&estimator);
+
+	seg = dsm_create(segsize, 0);
+
+	toc = shm_toc_create(PG_CMD_STATUS_INFO_MAGIC, dsm_segment_address(seg),
+						 segsize);
+
+	/* prepare basic structures */
+	mq = shm_mq_create(shm_toc_allocate(toc, CMD_STATUS_BUFFER_SIZE),
+					   CMD_STATUS_BUFFER_SIZE);
+
+	shm_mq_set_receiver(mq, MyProc);
+	shm_mq_set_sender(mq, proc);
+	shm_toc_insert(toc, 0, mq);
+
+	PG_TRY();
+	{
+		shm_mq_result	res;
+		char		   *data = NULL;
+		Size			length;
+
+		elog(LOG, "receiver: attaching mq");
+		input = shm_mq_attach(mq, seg, NULL);
+
+		elog(LOG, "receiver: signalling PID %d", target_pid);
+		if (SendCmdStatusInfoSignal(target_pid, proc->backendId,
+									dsm_segment_handle(seg), request_type))
+		{
+			elog(ERROR, "could not signal backend with PID %d", target_pid);
+		}
+
+		/* try to read from queue */
+		res = shm_mq_receive(input, &length, (void **) &data, false);
+		if (res == SHM_MQ_SUCCESS)
+		{
+			const char	   *p = data;
+
+			/* break into tuples on newline */
+			while (*p)
+			{
+				const char *q = strchr(p, '\n');
+				Size		len = q ? q - p : strlen(p);
+				Datum		value;
+				HeapTuple	tuple;
+				bool		isnull = false;
+
+				value = PointerGetDatum(cstring_to_text_with_len(p, len));
+
+				tuple = heap_form_tuple(tupdesc, &value, &isnull);
+				tuplestore_puttuple(tupstore, tuple);
+
+				if (!q)
+					break;
+
+				p += len + 1;
+			}
+		}
+		else
+		{
+			report_result_code(MyCmdStatusSlot->result_code, target_pid);
+		}
+
+		/* clean up and return the tuplestore */
+		tuplestore_donestoring(tupstore);
+
+		InvalidateCmdStatusSlot();
+
+		elog(LOG, "receiver: detaching mq");
+		shm_mq_detach(mq);
+		dsm_detach(seg);
+	}
+	PG_CATCH();
+	{
+		InvalidateCmdStatusSlot();
+
+		elog(LOG, "receiver: detaching mq (ON ERROR)");
+		shm_mq_detach(mq);
+		dsm_detach(seg);
+
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+
+	rsinfo->returnMode = SFRM_Materialize;
+	rsinfo->setResult = tupstore;
+	rsinfo->setDesc = tupdesc;
+
+	return (Datum) 0;
+}
diff --git a/src/backend/utils/init/globals.c b/src/backend/utils/init/globals.c
index 23e594e..2269853 100644
--- a/src/backend/utils/init/globals.c
+++ b/src/backend/utils/init/globals.c
@@ -29,6 +29,7 @@ ProtocolVersion FrontendProtocol;
 volatile bool InterruptPending = false;
 volatile bool QueryCancelPending = false;
 volatile bool ProcDiePending = false;
+volatile bool CmdStatusInfoPending = false;
 volatile bool ClientConnectionLost = false;
 volatile uint32 InterruptHoldoffCount = 0;
 volatile uint32 QueryCancelHoldoffCount = 0;
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 7b19714..7e7ba77 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -50,6 +50,7 @@
 #include "storage/smgr.h"
 #include "tcop/tcopprot.h"
 #include "utils/acl.h"
+#include "utils/cmdstatus.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
 #include "utils/memutils.h"
@@ -588,6 +589,9 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 	/* Now that we have a BackendId, we can participate in ProcSignal */
 	ProcSignalInit(MyBackendId);
 
+	/* Init CmdStatus slot */
+	CmdStatusInit(MyBackendId);
+
 	/*
 	 * Also set up timeout handlers needed for backend operation.  We need
 	 * these in every case except bootstrap.
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index ddf7c67..d083aaf 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -3130,6 +3130,8 @@ DESCR("get OID of current session's temp schema, if any");
 DATA(insert OID = 2855 (  pg_is_other_temp_schema	PGNSP PGUID 12 1 0 0 0 f f f f t f s 1 0 16 "26" _null_ _null_ _null_ _null_ _null_ pg_is_other_temp_schema _null_ _null_ _null_ ));
 DESCR("is schema another session's temp schema?");
 
+DATA(insert OID = 4099 ( pg_cmdstatus		PGNSP PGUID 12 1 100 0 0 f f f f f t s 2 0 25 "23 23" _null_ _null_  _null_  _null_ _null_ pg_cmdstatus _null_ _null_ _null_ ));
+DESCR("returns information about another process");
 DATA(insert OID = 2171 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_cancel_backend _null_ _null_ _null_ ));
 DESCR("cancel a server process' current query");
 DATA(insert OID = 2096 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
diff --git a/src/include/miscadmin.h b/src/include/miscadmin.h
index e0cc69f..5f03f63 100644
--- a/src/include/miscadmin.h
+++ b/src/include/miscadmin.h
@@ -80,6 +80,7 @@
 extern PGDLLIMPORT volatile bool InterruptPending;
 extern PGDLLIMPORT volatile bool QueryCancelPending;
 extern PGDLLIMPORT volatile bool ProcDiePending;
+extern PGDLLIMPORT volatile bool CmdStatusInfoPending;
 
 extern volatile bool ClientConnectionLost;
 
diff --git a/src/include/storage/procsignal.h b/src/include/storage/procsignal.h
index af1a0cd..cd856e5 100644
--- a/src/include/storage/procsignal.h
+++ b/src/include/storage/procsignal.h
@@ -41,6 +41,8 @@ typedef enum
 	PROCSIG_RECOVERY_CONFLICT_BUFFERPIN,
 	PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK,
 
+	PROCSIG_CMD_STATUS_INFO,
+
 	NUM_PROCSIGNALS				/* Must be last! */
 } ProcSignalReason;
 
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
index fc1679e..605612e 100644
--- a/src/include/utils/builtins.h
+++ b/src/include/utils/builtins.h
@@ -1243,6 +1243,9 @@ extern Datum pg_identify_object_as_address(PG_FUNCTION_ARGS);
 /* catalog/objectaddress.c */
 extern Datum pg_get_object_address(PG_FUNCTION_ARGS);
 
+/* utils/adt/cmdstatus.c */
+extern Datum pg_cmdstatus(PG_FUNCTION_ARGS);
+
 /* commands/constraint.c */
 extern Datum unique_key_recheck(PG_FUNCTION_ARGS);
 
diff --git a/src/include/utils/cmdstatus.h b/src/include/utils/cmdstatus.h
new file mode 100644
index 0000000..85627a57
--- /dev/null
+++ b/src/include/utils/cmdstatus.h
@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * cmdstatus.h
+ *	  Declarations for command status interrupt handling.
+ *
+ *
+ * Portions Copyright (c) 1996-2015, PostgreSQL Global Development Group
+ *
+ * src/include/utils/cmdstatus.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CMDSTATUS_H
+#define CMDSTATUS_H
+
+extern Size CmdStatusShmemSize(void);
+extern void CmdStatusShmemInit(void);
+extern void CmdStatusInit(int css_idx);
+
+extern void HandleCmdStatusInfoInterrupt(void);
+extern void ProcessCmdStatusInfoRequest(void);
+
+#endif   /* CMDSTATUS_H */

diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 32ac58f..a2b757c 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -139,6 +139,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, BTreeShmemSize());
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
+		size = add_size(size, CmdStatusShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -243,6 +244,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	ReplicationOriginShmemInit();
 	WalSndShmemInit();
 	WalRcvShmemInit();
+	CmdStatusShmemInit();
 
 	/*
 	 * Set up other modules that need some shared memory space
diff --git a/src/backend/storage/ipc/procsignal.c b/src/backend/storage/ipc/procsignal.c
index 0abde43..e637be1 100644
--- a/src/backend/storage/ipc/procsignal.c
+++ b/src/backend/storage/ipc/procsignal.c
@@ -26,6 +26,7 @@
 #include "storage/shmem.h"
 #include "storage/sinval.h"
 #include "tcop/tcopprot.h"
+#include "utils/cmdstatus.h"
 
 
 /*
@@ -296,6 +297,9 @@ procsignal_sigusr1_handler(SIGNAL_ARGS)
 	if (CheckProcSignal(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN))
 		RecoveryConflictInterrupt(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN);
 
+	if (CheckProcSignal(PROCSIG_CMD_STATUS_INFO))
+		HandleCmdStatusInfoInterrupt();
+
 	if (set_latch_on_sigusr1)
 		SetLatch(MyLatch);
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index d917af3..1a5b03c 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -67,6 +67,7 @@
 #include "tcop/pquery.h"
 #include "tcop/tcopprot.h"
 #include "tcop/utility.h"
+#include "utils/cmdstatus.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/ps_status.h"
@@ -2991,6 +2992,9 @@ ProcessInterrupts(void)
 
 	if (ParallelMessagePending)
 		HandleParallelMessages();
+
+	if (CmdStatusInfoPending)
+		ProcessCmdStatusInfoRequest();
 }
 
 
diff --git a/src/backend/utils/adt/Makefile b/src/backend/utils/adt/Makefile
index 3ed0b44..2c8687c 100644
--- a/src/backend/utils/adt/Makefile
+++ b/src/backend/utils/adt/Makefile
@@ -18,7 +18,7 @@ endif
 # keep this list arranged alphabetically or it gets to be a mess
 OBJS = acl.o arrayfuncs.o array_expanded.o array_selfuncs.o \
 	array_typanalyze.o array_userfuncs.o arrayutils.o ascii.o \
-	bool.o cash.o char.o date.o datetime.o datum.o dbsize.o domains.o \
+	bool.o cash.o char.o cmdstatus.o date.o datetime.o datum.o dbsize.o domains.o \
 	encode.o enum.o expandeddatum.o \
 	float.o format_type.o formatting.o genfile.o \
 	geo_ops.o geo_selfuncs.o inet_cidr_ntop.o inet_net_pton.o int.o \
diff --git a/src/backend/utils/adt/cmdstatus.c b/src/backend/utils/adt/cmdstatus.c
new file mode 100644
index 0000000..40df6e1
--- /dev/null
+++ b/src/backend/utils/adt/cmdstatus.c
@@ -0,0 +1,640 @@
+/*-------------------------------------------------------------------------
+ *
+ * cmdstatus.c
+ *	  Definitions for pg_cmdstatus function.
+ *
+ * Copyright (c) 1996-2015, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/backend/utils/adt/cmdstatus.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "funcapi.h"
+#include "miscadmin.h"
+
+#include "access/htup_details.h"
+#include "commands/explain.h"
+#include "lib/stringinfo.h"
+#include "storage/dsm.h"
+#include "storage/ipc.h"
+#include "storage/latch.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "storage/shm_mq.h"
+#include "storage/shm_toc.h"
+#include "tcop/dest.h"
+#include "tcop/pquery.h"
+#include "utils/builtins.h"
+#include "utils/cmdstatus.h"
+
+
+typedef enum {
+	CMD_STATUS_REQUEST_EXPLAIN = 1,
+	CMD_STATUS_REQUEST_QUERY_TEXT = 2,
+	CMD_STATUS_REQUEST_PROGRESS_TAG = 3,
+	CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE = 4
+} CmdStatusInfoRequestType;
+
+#define CMD_STATUS_MAX_REQUEST CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE
+
+typedef enum {
+	CMD_STATUS_RESULT_FAILURE = -1,
+	CMD_STATUS_RESULT_SUCCESS = 0,
+	CMD_STATUS_RESULT_BACKEND_IDLE,
+	CMD_STATUS_RESULT_NO_COMMAND_TAG
+} CmdStatusInfoResultCode;
+
+typedef struct
+{
+	pid_t			css_pid;
+	pid_t			sender_css_pid;
+	/*BackendId		sender_backend_id;*/
+	dsm_handle		dsm_seg_handle;
+	CmdStatusInfoRequestType	request_type;
+	CmdStatusInfoResultCode		result_code;
+	bool			is_valid;
+	bool			is_processed;
+} CmdStatusSlot;
+
+#define NumCmdStatusSlots	(MaxBackends + NUM_AUXPROCTYPES)
+
+#define PG_CMD_STATUS_INFO_MAGIC	0x79fb2449
+#define CMD_STATUS_BUFFER_SIZE		1024
+
+/*
+ * These structs are allocated on the program stack as local variables in the
+ * ExecutorRun hook.  The top of stack is current_query_stack, see below.
+ */
+typedef struct CmdInfoStack {
+	QueryDesc			   *query_desc;
+	struct CmdInfoStack	   *parent;
+} CmdInfoStack;
+
+
+static CmdStatusSlot *CmdStatusSlots = NULL;
+static volatile CmdStatusSlot *MyCmdStatusSlot = NULL;
+
+static CmdInfoStack	   *current_query_stack = NULL;
+static int				query_stack_size = 0;
+
+static ExecutorRun_hook_type	prev_ExecutorRun = NULL;
+
+static void cmdstatus_ExecutorRun(QueryDesc *queryDesc,
+								  ScanDirection direction, long count);
+
+
+Size
+CmdStatusShmemSize(void)
+{
+	return NumCmdStatusSlots * sizeof(CmdStatusSlot);
+}
+
+void
+CmdStatusShmemInit(void)
+{
+	Size		size = CmdStatusShmemSize();
+	bool		found;
+
+	CmdStatusSlots = (CmdStatusSlot *)
+		ShmemInitStruct("CmdStatusSlots", size, &found);
+
+	if (!found)
+		MemSet(CmdStatusSlots, 0, size);
+}
+
+static void
+CleanupCmdStatusSlot(int status, Datum arg)
+{
+	int		css_idx = DatumGetInt32(arg);
+	volatile CmdStatusSlot *slot;
+
+	slot = &CmdStatusSlots[css_idx - 1];
+	Assert(slot == MyCmdStatusSlot);
+
+	MyCmdStatusSlot = NULL;
+
+	if (slot->css_pid != MyProcPid)
+	{
+		elog(LOG, "process %d releasing ProcSignal slot %d, but it contains %d",
+			 MyProcPid, css_idx, (int) slot->css_pid);
+		return;					/* XXX better to zero the slot anyway? */
+	}
+
+	slot->css_pid = 0;
+	slot->is_valid = false;
+}
+
+void
+CmdStatusInit(int css_idx)
+{
+	volatile CmdStatusSlot *slot;
+
+	slot = &CmdStatusSlots[css_idx - 1];
+
+	if (slot->css_pid != 0)
+		elog(LOG, "process %d taking over CmdStatus slot %d, but it's not empty",
+			 MyProcPid, css_idx);
+
+	slot->css_pid = MyProcPid;
+	slot->is_valid = false;
+
+	MyCmdStatusSlot = slot;
+
+	on_shmem_exit(CleanupCmdStatusSlot, Int32GetDatum(css_idx));
+
+	/* also install executor hooks */
+	prev_ExecutorRun = ExecutorRun_hook;
+	ExecutorRun_hook = cmdstatus_ExecutorRun;
+}
+
+static int
+SendCmdStatusInfoSignal(pid_t target_pid, BackendId target_backend_id,
+						dsm_handle dsm_seg_handle,
+						CmdStatusInfoRequestType request_type)
+{
+	MyCmdStatusSlot->sender_css_pid = target_pid;
+	/*MyCmdStatusSlot->sender_backend_id = target_backend_id;*/
+	MyCmdStatusSlot->dsm_seg_handle = dsm_seg_handle;
+	MyCmdStatusSlot->request_type = request_type;
+	MyCmdStatusSlot->is_processed = false;
+	MyCmdStatusSlot->is_valid = true;		/* this should be set the latest */
+
+	return SendProcSignal(target_pid, PROCSIG_CMD_STATUS_INFO, target_backend_id);
+}
+
+static void
+InvalidateCmdStatusSlot(void)
+{
+	MyCmdStatusSlot->is_valid = false;
+	MyCmdStatusSlot->is_processed = false;
+	MyCmdStatusSlot->sender_css_pid = 0;
+	/*MyCmdStatusSlot->sender_backend_id = 0; */
+	MyCmdStatusSlot->dsm_seg_handle = 0;
+	MyCmdStatusSlot->request_type = 0;
+}
+
+
+
+static void
+cmdstatus_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, long count)
+{
+	CmdInfoStack	current;
+
+	current.query_desc = queryDesc;
+	current.parent = current_query_stack;
+
+	current_query_stack = &current;
+	query_stack_size++;
+
+	PG_TRY();
+	{
+		if (prev_ExecutorRun)
+			prev_ExecutorRun(queryDesc, direction, count);
+		else
+			standard_ExecutorRun(queryDesc, direction, count);
+
+		Assert(current_query_stack == &current);
+		Assert(query_stack_size > 0);
+
+		query_stack_size--;
+		current_query_stack = current.parent;
+	}
+	PG_CATCH();
+	{
+		Assert(current_query_stack == &current);
+		Assert(query_stack_size > 0);
+
+		query_stack_size--;
+		current_query_stack = current.parent;
+
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+}
+
+
+static StringInfo
+explain_query(QueryDesc *queryDesc)
+{
+	StringInfo		str;
+	ExplainState   *es;
+
+	es = NewExplainState();
+	es->analyze = false;
+	es->verbose = false;
+	es->buffers = false;
+	es->format = EXPLAIN_FORMAT_TEXT;
+
+	ExplainBeginOutput(es);
+	/* XXX: appendStringInfo(es->str, "#%d ", depth); ? */
+	ExplainQueryText(es, queryDesc);
+	ExplainPrintPlan(es, queryDesc);
+	ExplainEndOutput(es);
+
+	str = es->str;
+
+	pfree(es);
+	return str;
+}
+
+
+/* signal handler for PROCSIG_CMD_STATUS_INFO */
+void
+HandleCmdStatusInfoInterrupt(void)
+{
+	CmdStatusInfoPending = true;
+	InterruptPending = true;
+
+	SetLatch(MyLatch);
+}
+
+
+static StringInfo
+ProcessCmdStatusSlot(volatile CmdStatusSlot *slot)
+{
+	StringInfo		result = NULL;
+
+	/* Show some optimism. */
+	slot->result_code = CMD_STATUS_RESULT_SUCCESS;
+
+	if (ActivePortal)
+	{
+		switch (slot->request_type)
+		{
+			case CMD_STATUS_REQUEST_EXPLAIN:
+				result = explain_query(ActivePortal->queryDesc);
+				break;
+
+			case CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE:
+				{
+					StringInfo		str;
+					CmdInfoStack   *query;
+
+					result = makeStringInfo();
+
+					if (current_query_stack != NULL)
+					{
+						for (query = current_query_stack;
+							 query != NULL;
+							 query = query->parent)
+						{
+							str = explain_query(query->query_desc);
+							appendBinaryStringInfo(result, str->data, str->len);
+
+							pfree(str->data);
+							pfree(str);
+						}
+					}
+					else
+					{
+						/* XXX */
+						slot->result_code = CMD_STATUS_RESULT_BACKEND_IDLE;
+					}
+					break;
+				}
+
+			case CMD_STATUS_REQUEST_QUERY_TEXT:
+				{
+					result = makeStringInfo();
+					appendStringInfoString(result, ActivePortal->sourceText);
+				}
+				break;
+
+			case CMD_STATUS_REQUEST_PROGRESS_TAG:
+				if (ActivePortal->commandTag != NULL)
+				{
+					result = makeStringInfo();
+
+					if (ActivePortal->queryDesc != NULL &&
+						ActivePortal->queryDesc->estate != NULL)
+					{
+						appendStringInfo(result, "%s %u",
+										 ActivePortal->commandTag,
+										 ActivePortal->queryDesc->estate->es_processed);
+					}
+					else
+					{
+						/* no progress available, at least show the command tag */
+						appendStringInfoString(result, ActivePortal->commandTag);
+					}
+				}
+				else
+				{
+					slot->result_code = CMD_STATUS_RESULT_NO_COMMAND_TAG;
+				}
+				break;
+		}
+	}
+	else
+	{
+		slot->result_code = CMD_STATUS_RESULT_BACKEND_IDLE;
+	}
+
+	return result;
+}
+
+static void
+RestoreResourceOwner(ResourceOwner prevResourceOwner)
+{
+	if (prevResourceOwner != CurrentResourceOwner)
+	{
+		ResourceOwner	res_owner = CurrentResourceOwner;
+
+		CurrentResourceOwner = prevResourceOwner;
+		ResourceOwnerDelete(res_owner);
+	}
+}
+
+void
+ProcessCmdStatusInfoRequest(void)
+{
+	while (CmdStatusInfoPending)
+	{
+		int		i;
+
+		CmdStatusInfoPending = false;
+
+		for (i = 0; i < NumCmdStatusSlots; i++)
+		{
+			volatile CmdStatusSlot *slot = &CmdStatusSlots[i];
+
+			if (slot->sender_css_pid == MyProcPid &&
+				slot->is_valid && !slot->is_processed)
+			{
+				ResourceOwner	prevResourceOwner = CurrentResourceOwner;
+				dsm_segment	   *seg = NULL;
+				shm_toc		   *toc = NULL;
+				shm_mq_handle  *output;
+				shm_mq		   *mq;
+
+				/* Ensure valid resource owner for access to dsm. */
+				if (CurrentResourceOwner == NULL)
+					CurrentResourceOwner = ResourceOwnerCreate(NULL, "ProcessCmdStatusInfoRequest");
+
+				seg = dsm_attach(slot->dsm_seg_handle);
+				if (seg == NULL)
+				{
+					elog(LOG, "unable to map dynamic memory segment for command status");
+
+					slot->is_processed = true;
+					slot->is_valid = false;
+
+					RestoreResourceOwner(prevResourceOwner);
+					continue;
+				}
+
+				toc = shm_toc_attach(PG_CMD_STATUS_INFO_MAGIC, dsm_segment_address(seg));
+				if (toc == NULL)
+				{
+					elog(LOG, "bad magic in dynamic memory segment for command status");
+
+					slot->is_processed = true;
+					slot->is_valid = false;
+
+					dsm_detach(seg);
+
+					RestoreResourceOwner(prevResourceOwner);
+					continue;
+				}
+
+				mq = shm_toc_lookup(toc, 0);
+				output = shm_mq_attach(mq, seg, NULL);
+
+				PG_TRY();
+				{
+					StringInfo		payload;
+					int				res;
+
+					payload = ProcessCmdStatusSlot(slot);
+					if (payload != NULL)
+					{
+						/*
+						 * It's important to set the processed flag and result
+						 * code *before* sending the message through the
+						 * queue.  Otherwise it may result that the receiving
+						 * backend will wake up the queue and re-use its slot
+						 * to send another status request (it doesn't matter
+						 * if that would be a request to the same backend or a
+						 * different one).  The message queue serves as a
+						 * barrier here: it should be generally safe to assume
+						 * that before we send anything to the queue (or
+						 * detach from it), the receiving backend is waiting.
+						 */
+						slot->is_processed = true;
+
+						res = shm_mq_send(output, payload->len, payload->data, false);
+						if (res != SHM_MQ_SUCCESS)
+						{
+							elog(LOG, "cannot send command status to backend with PID %d",
+								 slot->css_pid);
+							slot->is_valid = false;
+						}
+						pfree(payload->data);
+						pfree(payload);
+					}
+					else
+					{
+						slot->is_valid = false;
+					}
+
+					shm_mq_detach(mq);
+					dsm_detach(seg);
+
+					RestoreResourceOwner(prevResourceOwner);
+				}
+				PG_CATCH();
+				{
+					slot->is_processed = true;
+					slot->is_valid = false;
+
+					shm_mq_detach(mq);
+					dsm_detach(seg);
+
+					RestoreResourceOwner(prevResourceOwner);
+
+					PG_RE_THROW();
+				}
+				PG_END_TRY();
+			}
+		}
+	}
+}
+
+static void
+report_result_code(CmdStatusInfoResultCode result, pid_t target_pid)
+{
+	switch (result)
+	{
+		case CMD_STATUS_RESULT_BACKEND_IDLE:
+			elog(INFO, "no command is currently running in backend with PID %d",
+				 target_pid);
+			break;
+
+		case CMD_STATUS_RESULT_NO_COMMAND_TAG:
+			elog(WARNING, "no command tag found for the query in backend with PID %d",
+				 target_pid);
+			break;
+
+		default:
+			elog(ERROR, "general command status request failure");
+			break;
+	}
+}
+
+/*
+ * try to get status of command in another process
+ *
+ * FUNCTION get_cmdstatus(pid, request_type)
+ * RETURNS SETOF text
+ */
+Datum
+pg_cmdstatus(PG_FUNCTION_ARGS)
+{
+	ReturnSetInfo	   *rsinfo	= (ReturnSetInfo *) fcinfo->resultinfo;
+	Tuplestorestate	   *tupstore;
+	TupleDesc			tupdesc;
+	MemoryContext		per_query_ctx;
+	MemoryContext		oldcontext;
+	pid_t				target_pid = (pid_t) PG_GETARG_INT32(0);
+	int					request_type = PG_GETARG_INT32(1);
+	PGPROC			   *proc;
+	shm_toc_estimator	estimator;
+	Size				segsize;
+	dsm_segment		   *seg = NULL;
+	shm_toc			   *toc = NULL;
+	shm_mq			   *mq = NULL;
+	shm_mq_handle	   *input = NULL;
+
+	/* check to see if caller supports us returning a tuplestore */
+	if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("set-valued function called in context that cannot accept a set")));
+
+	if (!(rsinfo->allowedModes & SFRM_Materialize))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("materialize mode required, but it is not allowed in this context")));
+
+	if (request_type < 1 || request_type > CMD_STATUS_MAX_REQUEST)
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("unknown command status request")));
+
+	/* need to build tuplestore in query context */
+	per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+	oldcontext = MemoryContextSwitchTo(per_query_ctx);
+
+	tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc);
+	tupstore = tuplestore_begin_heap(false, false, work_mem);
+	MemoryContextSwitchTo(oldcontext);
+
+	if (target_pid == MyProcPid)
+		ereport(ERROR,
+				(errmsg("backend cannot query command status of itself")));
+
+	/* verify access to target_pid */
+	proc = BackendPidGetProc(target_pid);
+
+	if (proc == NULL)
+		ereport(ERROR,
+				(errmsg("PID %d is not a PostgreSQL server process", target_pid)));
+
+	if (!(superuser() || proc->roleId == GetUserId()))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be superuser or have the same role to explain queries running in other server processes"))));
+
+	/* prepare shared dsm segment */
+	shm_toc_initialize_estimator(&estimator);
+	shm_toc_estimate_keys(&estimator, 1);
+	shm_toc_estimate_chunk(&estimator, CMD_STATUS_BUFFER_SIZE);
+	segsize = shm_toc_estimate(&estimator);
+
+	seg = dsm_create(segsize, 0);
+
+	toc = shm_toc_create(PG_CMD_STATUS_INFO_MAGIC, dsm_segment_address(seg),
+						 segsize);
+
+	/* prepare basic structures */
+	mq = shm_mq_create(shm_toc_allocate(toc, CMD_STATUS_BUFFER_SIZE),
+					   CMD_STATUS_BUFFER_SIZE);
+
+	shm_mq_set_receiver(mq, MyProc);
+	shm_mq_set_sender(mq, proc);
+	shm_toc_insert(toc, 0, mq);
+
+	PG_TRY();
+	{
+		shm_mq_result	res;
+		char		   *data = NULL;
+		Size			length;
+
+		input = shm_mq_attach(mq, seg, NULL);
+
+		if (SendCmdStatusInfoSignal(target_pid, proc->backendId,
+									dsm_segment_handle(seg), request_type))
+		{
+			elog(ERROR, "could not signal backend with PID %d", target_pid);
+		}
+
+		/* try to read from queue */
+		res = shm_mq_receive(input, &length, (void **) &data, false);
+		if (res == SHM_MQ_SUCCESS)
+		{
+			const char	   *p = data;
+
+			/* break into tuples on newline */
+			while (*p)
+			{
+				const char *q = strchr(p, '\n');
+				Size		len = q ? q - p : strlen(p);
+				Datum		value;
+				HeapTuple	tuple;
+				bool		isnull = false;
+
+				value = PointerGetDatum(cstring_to_text_with_len(p, len));
+
+				tuple = heap_form_tuple(tupdesc, &value, &isnull);
+				tuplestore_puttuple(tupstore, tuple);
+
+				if (!q)
+					break;
+
+				p += len + 1;
+			}
+		}
+		else
+		{
+			report_result_code(MyCmdStatusSlot->result_code, target_pid);
+		}
+
+		/* clean up and return the tuplestore */
+		tuplestore_donestoring(tupstore);
+
+		InvalidateCmdStatusSlot();
+
+		shm_mq_detach(mq);
+		dsm_detach(seg);
+	}
+	PG_CATCH();
+	{
+		InvalidateCmdStatusSlot();
+
+		shm_mq_detach(mq);
+		dsm_detach(seg);
+
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+
+	rsinfo->returnMode = SFRM_Materialize;
+	rsinfo->setResult = tupstore;
+	rsinfo->setDesc = tupdesc;
+
+	return (Datum) 0;
+}
diff --git a/src/backend/utils/init/globals.c b/src/backend/utils/init/globals.c
index 23e594e..2269853 100644
--- a/src/backend/utils/init/globals.c
+++ b/src/backend/utils/init/globals.c
@@ -29,6 +29,7 @@ ProtocolVersion FrontendProtocol;
 volatile bool InterruptPending = false;
 volatile bool QueryCancelPending = false;
 volatile bool ProcDiePending = false;
+volatile bool CmdStatusInfoPending = false;
 volatile bool ClientConnectionLost = false;
 volatile uint32 InterruptHoldoffCount = 0;
 volatile uint32 QueryCancelHoldoffCount = 0;
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 7b19714..7e7ba77 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -50,6 +50,7 @@
 #include "storage/smgr.h"
 #include "tcop/tcopprot.h"
 #include "utils/acl.h"
+#include "utils/cmdstatus.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
 #include "utils/memutils.h"
@@ -588,6 +589,9 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 	/* Now that we have a BackendId, we can participate in ProcSignal */
 	ProcSignalInit(MyBackendId);
 
+	/* Init CmdStatus slot */
+	CmdStatusInit(MyBackendId);
+
 	/*
 	 * Also set up timeout handlers needed for backend operation.  We need
 	 * these in every case except bootstrap.
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index ddf7c67..d083aaf 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -3130,6 +3130,8 @@ DESCR("get OID of current session's temp schema, if any");
 DATA(insert OID = 2855 (  pg_is_other_temp_schema	PGNSP PGUID 12 1 0 0 0 f f f f t f s 1 0 16 "26" _null_ _null_ _null_ _null_ _null_ pg_is_other_temp_schema _null_ _null_ _null_ ));
 DESCR("is schema another session's temp schema?");
 
+DATA(insert OID = 4099 ( pg_cmdstatus		PGNSP PGUID 12 1 100 0 0 f f f f f t s 2 0 25 "23 23" _null_ _null_  _null_  _null_ _null_ pg_cmdstatus _null_ _null_ _null_ ));
+DESCR("returns information about another process");
 DATA(insert OID = 2171 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_cancel_backend _null_ _null_ _null_ ));
 DESCR("cancel a server process' current query");
 DATA(insert OID = 2096 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
diff --git a/src/include/miscadmin.h b/src/include/miscadmin.h
index e0cc69f..5f03f63 100644
--- a/src/include/miscadmin.h
+++ b/src/include/miscadmin.h
@@ -80,6 +80,7 @@
 extern PGDLLIMPORT volatile bool InterruptPending;
 extern PGDLLIMPORT volatile bool QueryCancelPending;
 extern PGDLLIMPORT volatile bool ProcDiePending;
+extern PGDLLIMPORT volatile bool CmdStatusInfoPending;
 
 extern volatile bool ClientConnectionLost;
 
diff --git a/src/include/storage/procsignal.h b/src/include/storage/procsignal.h
index af1a0cd..cd856e5 100644
--- a/src/include/storage/procsignal.h
+++ b/src/include/storage/procsignal.h
@@ -41,6 +41,8 @@ typedef enum
 	PROCSIG_RECOVERY_CONFLICT_BUFFERPIN,
 	PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK,
 
+	PROCSIG_CMD_STATUS_INFO,
+
 	NUM_PROCSIGNALS				/* Must be last! */
 } ProcSignalReason;
 
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
index fc1679e..605612e 100644
--- a/src/include/utils/builtins.h
+++ b/src/include/utils/builtins.h
@@ -1243,6 +1243,9 @@ extern Datum pg_identify_object_as_address(PG_FUNCTION_ARGS);
 /* catalog/objectaddress.c */
 extern Datum pg_get_object_address(PG_FUNCTION_ARGS);
 
+/* utils/adt/cmdstatus.c */
+extern Datum pg_cmdstatus(PG_FUNCTION_ARGS);
+
 /* commands/constraint.c */
 extern Datum unique_key_recheck(PG_FUNCTION_ARGS);
 
diff --git a/src/include/utils/cmdstatus.h b/src/include/utils/cmdstatus.h
new file mode 100644
index 0000000..85627a57
--- /dev/null
+++ b/src/include/utils/cmdstatus.h
@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * cmdstatus.h
+ *	  Declarations for command status interrupt handling.
+ *
+ *
+ * Portions Copyright (c) 1996-2015, PostgreSQL Global Development Group
+ *
+ * src/include/utils/cmdstatus.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CMDSTATUS_H
+#define CMDSTATUS_H
+
+extern Size CmdStatusShmemSize(void);
+extern void CmdStatusShmemInit(void);
+extern void CmdStatusInit(int css_idx);
+
+extern void HandleCmdStatusInfoInterrupt(void);
+extern void ProcessCmdStatusInfoRequest(void);
+
+#endif   /* CMDSTATUS_H */

diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 32ac58f..2e3beaf 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -43,6 +43,7 @@
 #include "storage/procsignal.h"
 #include "storage/sinvaladt.h"
 #include "storage/spin.h"
+#include "utils/cmdstatus.h"
 
 
 shmem_startup_hook_type shmem_startup_hook = NULL;
@@ -139,6 +140,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, BTreeShmemSize());
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
+		size = add_size(size, CmdStatusShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -243,6 +245,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	ReplicationOriginShmemInit();
 	WalSndShmemInit();
 	WalRcvShmemInit();
+	CmdStatusShmemInit();
 
 	/*
 	 * Set up other modules that need some shared memory space
diff --git a/src/backend/storage/ipc/procsignal.c b/src/backend/storage/ipc/procsignal.c
index 0abde43..e637be1 100644
--- a/src/backend/storage/ipc/procsignal.c
+++ b/src/backend/storage/ipc/procsignal.c
@@ -26,6 +26,7 @@
 #include "storage/shmem.h"
 #include "storage/sinval.h"
 #include "tcop/tcopprot.h"
+#include "utils/cmdstatus.h"
 
 
 /*
@@ -296,6 +297,9 @@ procsignal_sigusr1_handler(SIGNAL_ARGS)
 	if (CheckProcSignal(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN))
 		RecoveryConflictInterrupt(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN);
 
+	if (CheckProcSignal(PROCSIG_CMD_STATUS_INFO))
+		HandleCmdStatusInfoInterrupt();
+
 	if (set_latch_on_sigusr1)
 		SetLatch(MyLatch);
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index d917af3..1a5b03c 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -67,6 +67,7 @@
 #include "tcop/pquery.h"
 #include "tcop/tcopprot.h"
 #include "tcop/utility.h"
+#include "utils/cmdstatus.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/ps_status.h"
@@ -2991,6 +2992,9 @@ ProcessInterrupts(void)
 
 	if (ParallelMessagePending)
 		HandleParallelMessages();
+
+	if (CmdStatusInfoPending)
+		ProcessCmdStatusInfoRequest();
 }
 
 
diff --git a/src/backend/utils/adt/Makefile b/src/backend/utils/adt/Makefile
index 3ed0b44..2c8687c 100644
--- a/src/backend/utils/adt/Makefile
+++ b/src/backend/utils/adt/Makefile
@@ -18,7 +18,7 @@ endif
 # keep this list arranged alphabetically or it gets to be a mess
 OBJS = acl.o arrayfuncs.o array_expanded.o array_selfuncs.o \
 	array_typanalyze.o array_userfuncs.o arrayutils.o ascii.o \
-	bool.o cash.o char.o date.o datetime.o datum.o dbsize.o domains.o \
+	bool.o cash.o char.o cmdstatus.o date.o datetime.o datum.o dbsize.o domains.o \
 	encode.o enum.o expandeddatum.o \
 	float.o format_type.o formatting.o genfile.o \
 	geo_ops.o geo_selfuncs.o inet_cidr_ntop.o inet_net_pton.o int.o \
diff --git a/src/backend/utils/adt/cmdstatus.c b/src/backend/utils/adt/cmdstatus.c
new file mode 100644
index 0000000..5cc6d51
--- /dev/null
+++ b/src/backend/utils/adt/cmdstatus.c
@@ -0,0 +1,691 @@
+/*-------------------------------------------------------------------------
+ *
+ * cmdstatus.c
+ *	  Definitions for pg_cmdstatus function.
+ *
+ * Copyright (c) 1996-2015, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/backend/utils/adt/cmdstatus.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "funcapi.h"
+#include "miscadmin.h"
+
+#include "access/htup_details.h"
+#include "commands/explain.h"
+#include "lib/stringinfo.h"
+#include "storage/dsm.h"
+#include "storage/ipc.h"
+#include "storage/latch.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "storage/procsignal.h"
+#include "storage/shm_mq.h"
+#include "storage/shm_toc.h"
+#include "tcop/dest.h"
+#include "tcop/pquery.h"
+#include "utils/builtins.h"
+#include "utils/cmdstatus.h"
+
+
+typedef enum {
+	CMD_STATUS_REQUEST_EXPLAIN = 1,
+	CMD_STATUS_REQUEST_QUERY_TEXT = 2,
+	CMD_STATUS_REQUEST_PROGRESS_TAG = 3,
+	CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE = 4
+} CmdStatusInfoRequestType;
+
+#define CMD_STATUS_MAX_REQUEST CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE
+
+typedef enum {
+	CMD_STATUS_RESULT_FAILURE = -1,
+	CMD_STATUS_RESULT_SUCCESS = 0,
+	CMD_STATUS_RESULT_BACKEND_IDLE,
+	CMD_STATUS_RESULT_NO_DATA
+} CmdStatusInfoResultCode;
+
+/*
+ * Each process that wants to be able to query other processes for their
+ * status registers itself in a slot in the shared memory by setting the
+ * slot's process ID.  The slots array is indexed by backend ID, so any slot
+ * can be assigned at max to one backend at any given time.
+ *
+ * In order to actually query some backend for its status, the interested
+ * process will initialize its *own* slot, create a DSM segment and initialize
+ * a shared memory queue in it, then send the SIGUSR1 with the reason
+ * PROCSIG_CMD_STATUS_INFO to the process being queried.  Then the interested
+ * process will wait for the response to be delivered via the shared memory
+ * queue.
+ */
+typedef struct
+{
+	pid_t			css_pid;			/* the ID of process asking for the status */
+	pid_t			sender_css_pid;		/* the ID of process that sends back the result */
+	dsm_handle		dsm_seg_handle;
+	CmdStatusInfoRequestType	request_type;
+	CmdStatusInfoResultCode		result_code;
+	bool			is_valid;
+	bool			is_processed;
+} CmdStatusSlot;
+
+/* TODO: do we really want the aux processes to be able to query other backends? */
+#define NumCmdStatusSlots	(MaxBackends + NUM_AUXPROCTYPES)
+
+#define PG_CMD_STATUS_INFO_MAGIC	0x79fb2449
+#define CMD_STATUS_BUFFER_SIZE		1024
+
+/*
+ * These structs are allocated on the program stack as local variables in the
+ * ExecutorRun hook.  The top of stack is current_query_stack, see below.
+ *
+ * Capturing the execution stack allows us to inspect the inner-most running
+ * query as well as showing the complete backtrace.
+ */
+typedef struct CmdInfoStack {
+	QueryDesc			   *query_desc;
+	struct CmdInfoStack	   *parent;
+} CmdInfoStack;
+
+/* The array of slots pre-allocated on shared memory. */
+static CmdStatusSlot *CmdStatusSlots = NULL;
+
+static volatile CmdStatusSlot *MyCmdStatusSlot = NULL;
+
+static CmdInfoStack	   *current_query_stack = NULL;
+static int				query_stack_size = 0;  /* XXX not really used */
+
+static ExecutorRun_hook_type	prev_ExecutorRun = NULL;
+
+static void cmdstatus_ExecutorRun(QueryDesc *queryDesc,
+								  ScanDirection direction, long count);
+
+static void CleanupCmdStatusSlot(int status, Datum arg);
+static int SendCmdStatusInfoSignal(pid_t target_pid, BackendId target_backend_id,
+						dsm_handle dsm_seg_handle,
+						CmdStatusInfoRequestType request_type);
+static void InvalidateCmdStatusSlot(void);
+static StringInfo ProcessCmdStatusSlot(volatile CmdStatusSlot *slot);
+
+static StringInfo explain_query(QueryDesc *queryDesc);
+static void report_result_code(CmdStatusInfoResultCode result, pid_t target_pid);
+static void RestoreResourceOwner(ResourceOwner prevResourceOwner);
+
+
+Size
+CmdStatusShmemSize(void)
+{
+	return NumCmdStatusSlots * sizeof(CmdStatusSlot);
+}
+
+void
+CmdStatusShmemInit(void)
+{
+	Size		size = CmdStatusShmemSize();
+	bool		found;
+
+	CmdStatusSlots = (CmdStatusSlot *)
+		ShmemInitStruct("CmdStatusSlots", size, &found);
+
+	if (!found)
+		MemSet(CmdStatusSlots, 0, size);
+}
+
+static void
+CleanupCmdStatusSlot(int status, Datum arg)
+{
+	MemSet(MyCmdStatusSlot, 0, sizeof(CmdStatusSlot));
+	MyCmdStatusSlot = NULL;
+}
+
+/*
+ * CmdStatusInit
+ *		Register the current process in the CmdStatusSlots array
+ *
+ * The passed index should be MyBackendId.
+ */
+void
+CmdStatusInit(int css_idx)
+{
+	volatile CmdStatusSlot *slot;
+
+	slot = &CmdStatusSlots[css_idx - 1];
+
+	if (slot->css_pid != 0)
+		elog(LOG, "process %d taking over CmdStatus slot %d, but it's not empty",
+			 MyProcPid, css_idx);
+
+	slot->css_pid = MyProcPid;
+	slot->is_valid = false;
+
+	MyCmdStatusSlot = slot;
+
+	on_shmem_exit(CleanupCmdStatusSlot, (Datum) 0);
+
+	/* also install executor hooks */
+	prev_ExecutorRun = ExecutorRun_hook;
+	ExecutorRun_hook = cmdstatus_ExecutorRun;
+}
+
+/* Prepare the slot on receiving side and signal the target process. */
+static int
+SendCmdStatusInfoSignal(pid_t target_pid, BackendId target_backend_id,
+						dsm_handle dsm_seg_handle,
+						CmdStatusInfoRequestType request_type)
+{
+	MyCmdStatusSlot->sender_css_pid = target_pid;
+	MyCmdStatusSlot->dsm_seg_handle = dsm_seg_handle;
+	MyCmdStatusSlot->request_type = request_type;
+	MyCmdStatusSlot->is_processed = false;
+	MyCmdStatusSlot->is_valid = true;		/* this should be set the latest */
+
+	return SendProcSignal(target_pid, PROCSIG_CMD_STATUS_INFO, target_backend_id);
+}
+
+/* Clean up the slot for next use by this process. */
+static void
+InvalidateCmdStatusSlot(void)
+{
+	MyCmdStatusSlot->is_valid = false;
+	MyCmdStatusSlot->is_processed = false;
+	MyCmdStatusSlot->sender_css_pid = 0;
+	MyCmdStatusSlot->dsm_seg_handle = 0;
+	MyCmdStatusSlot->request_type = 0;
+}
+
+/*
+ * The executor hook.
+ *
+ * Accumulates the query descriptors on the program stack and takes care of
+ * popping the current frame when leaving the function ab-/normally.
+ */
+static void
+cmdstatus_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, long count)
+{
+	CmdInfoStack	current;
+
+	current.query_desc = queryDesc;
+	current.parent = current_query_stack;
+
+	current_query_stack = &current;
+	query_stack_size++;
+
+	PG_TRY();
+	{
+		if (prev_ExecutorRun)
+			prev_ExecutorRun(queryDesc, direction, count);
+		else
+			standard_ExecutorRun(queryDesc, direction, count);
+
+		Assert(current_query_stack == &current);
+		Assert(query_stack_size > 0);
+
+		query_stack_size--;
+		current_query_stack = current.parent;
+	}
+	PG_CATCH();
+	{
+		Assert(current_query_stack == &current);
+		Assert(query_stack_size > 0);
+
+		query_stack_size--;
+		current_query_stack = current.parent;
+
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+}
+
+/* Produce an explain plan of a single query descriptor. */
+static StringInfo
+explain_query(QueryDesc *queryDesc)
+{
+	StringInfo		str;
+	ExplainState   *es;
+
+	es = NewExplainState();
+	es->analyze = false;
+	es->verbose = false;
+	es->buffers = false;
+	es->format = EXPLAIN_FORMAT_TEXT;
+
+	ExplainBeginOutput(es);
+	/* XXX: appendStringInfo(es->str, "#%d ", depth); ? */
+	ExplainQueryText(es, queryDesc);
+	ExplainPrintPlan(es, queryDesc);
+	ExplainEndOutput(es);
+
+	str = es->str;
+
+	pfree(es);
+	return str;
+}
+
+
+/* signal handler for PROCSIG_CMD_STATUS_INFO */
+void
+HandleCmdStatusInfoInterrupt(void)
+{
+	CmdStatusInfoPending = true;
+	InterruptPending = true;
+
+	SetLatch(MyLatch);
+}
+
+/* Produce a response and set the result code for a single slot. */
+static StringInfo
+ProcessCmdStatusSlot(volatile CmdStatusSlot *slot)
+{
+	StringInfo		result = NULL;
+
+	/* Show some optimism, overwrite with error code later if needed. */
+	slot->result_code = CMD_STATUS_RESULT_SUCCESS;
+
+	if (ActivePortal)
+	{
+		switch (slot->request_type)
+		{
+			case CMD_STATUS_REQUEST_EXPLAIN:
+				if (ActivePortal->queryDesc != NULL)
+					result = explain_query(ActivePortal->queryDesc);
+				else if (current_query_stack != NULL)
+					result = explain_query(current_query_stack->query_desc);
+				else
+					slot->result_code = CMD_STATUS_RESULT_NO_DATA;
+				break;
+
+			case CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE:
+				{
+					StringInfo		str;
+					CmdInfoStack   *query;
+
+					result = makeStringInfo();
+
+					if (current_query_stack != NULL)
+					{
+						for (query = current_query_stack;
+							 query != NULL;
+							 query = query->parent)
+						{
+							str = explain_query(query->query_desc);
+							appendBinaryStringInfo(result, str->data, str->len);
+
+							pfree(str->data);
+							pfree(str);
+						}
+					}
+					else
+						slot->result_code = CMD_STATUS_RESULT_BACKEND_IDLE;
+					break;
+				}
+
+			case CMD_STATUS_REQUEST_QUERY_TEXT:
+				result = makeStringInfo();
+				appendStringInfoString(result, ActivePortal->sourceText);
+				break;
+
+			case CMD_STATUS_REQUEST_PROGRESS_TAG:
+				if (ActivePortal->commandTag != NULL)
+				{
+					result = makeStringInfo();
+
+					if (ActivePortal->queryDesc != NULL &&
+						ActivePortal->queryDesc->estate != NULL)
+					{
+						appendStringInfo(result, "%s %u",
+										 ActivePortal->commandTag,
+										 ActivePortal->queryDesc->estate->es_processed);
+					}
+					else
+					{
+						/* no progress available, at least show the command tag */
+						appendStringInfoString(result, ActivePortal->commandTag);
+					}
+				}
+				else
+					slot->result_code = CMD_STATUS_RESULT_NO_DATA;
+				break;
+		}
+	}
+	else
+		slot->result_code = CMD_STATUS_RESULT_BACKEND_IDLE;
+
+	return result;
+}
+
+static void
+RestoreResourceOwner(ResourceOwner prevResourceOwner)
+{
+	if (prevResourceOwner != CurrentResourceOwner)
+	{
+		ResourceOwner	res_owner = CurrentResourceOwner;
+
+		CurrentResourceOwner = prevResourceOwner;
+		ResourceOwnerDelete(res_owner);
+	}
+}
+
+/*
+ * Process all command status requests from other backends by scanning the
+ * whole array of slots looking for the requests targeted at us, which were
+ * not invalidated or already processed by us during earlier rounds.
+ */
+void
+ProcessCmdStatusInfoRequest(void)
+{
+	/*
+	 * We might have been signaled again by another process while handling a
+	 * request, so re-check after going through all the slots.
+	 */
+	while (CmdStatusInfoPending)
+	{
+		int		i;
+
+		CmdStatusInfoPending = false;
+
+		for (i = 0; i < NumCmdStatusSlots; i++)
+		{
+			volatile CmdStatusSlot *slot = &CmdStatusSlots[i];
+
+			if (slot->sender_css_pid == MyProcPid &&
+				slot->is_valid && !slot->is_processed)
+			{
+				ResourceOwner	prevResourceOwner = CurrentResourceOwner;
+				dsm_segment	   *seg = NULL;
+				shm_toc		   *toc = NULL;
+				shm_mq_handle  *output;
+				shm_mq		   *mq;
+
+				/* Ensure valid resource owner for access to dsm. */
+				if (CurrentResourceOwner == NULL)
+					CurrentResourceOwner = ResourceOwnerCreate(NULL, "ProcessCmdStatusInfoRequest");
+
+				seg = dsm_attach(slot->dsm_seg_handle);
+				if (seg == NULL)
+				{
+					elog(LOG, "unable to map dynamic memory segment for command status");
+
+					slot->is_processed = true;
+					slot->is_valid = false;
+
+					RestoreResourceOwner(prevResourceOwner);
+					continue;
+				}
+
+				toc = shm_toc_attach(PG_CMD_STATUS_INFO_MAGIC, dsm_segment_address(seg));
+				if (toc == NULL)
+				{
+					elog(LOG, "bad magic in dynamic memory segment for command status");
+
+					slot->is_processed = true;
+					slot->is_valid = false;
+
+					dsm_detach(seg);
+
+					RestoreResourceOwner(prevResourceOwner);
+					continue;
+				}
+
+				mq = shm_toc_lookup(toc, 0);
+				output = shm_mq_attach(mq, seg, NULL);
+
+				PG_TRY();
+				{
+					StringInfo		payload;
+					int				res;
+
+					payload = ProcessCmdStatusSlot(slot);
+					if (payload != NULL)
+					{
+						/*
+						 * It's important to set the processed flag and result
+						 * code *before* sending the message through the
+						 * queue.  Otherwise it may result that the receiving
+						 * backend will wake up the queue and re-use its slot
+						 * to send another status request (it doesn't matter
+						 * if that would be a request to the same backend or a
+						 * different one).
+						 *
+						 * The message queue serves as a barrier here: it
+						 * should be generally safe to assume that before we
+						 * send anything to the queue or detach from it, the
+						 * receiving backend is waiting.
+						 */
+						slot->is_processed = true;
+
+						/*
+						 * Send the data, including null terminator.
+						 *
+						 * This blocks until the receiving side completes
+						 * reading or detaches from the queue.
+						 */
+						res = shm_mq_send(output, payload->len + 1, payload->data, false);
+						if (res != SHM_MQ_SUCCESS)
+						{
+							elog(LOG, "cannot send command status to backend with PID %d",
+								 slot->css_pid);
+							slot->is_valid = false;
+						}
+						pfree(payload->data);
+						pfree(payload);
+					}
+					else
+					{
+						slot->is_valid = false;
+
+						/*
+						 * If there was no payload to send to the receiver, we
+						 * just detach from the queue and the other side
+						 * should wake up.
+						 */
+					}
+
+					shm_mq_detach(mq);
+					dsm_detach(seg);
+
+					RestoreResourceOwner(prevResourceOwner);
+				}
+				PG_CATCH();
+				{
+					slot->is_processed = true;
+					slot->is_valid = false;
+
+					/*
+					 * Detaching from the queue also wakes up the receiver, be
+					 * sure to update the slot status before detaching.
+					 */
+					shm_mq_detach(mq);
+					dsm_detach(seg);
+
+					RestoreResourceOwner(prevResourceOwner);
+
+					PG_RE_THROW();	/* XXX is it better to log/suppress the error here? */
+				}
+				PG_END_TRY();
+			}
+		}
+	}
+}
+
+static void
+report_result_code(CmdStatusInfoResultCode result, pid_t target_pid)
+{
+	switch (result)
+	{
+		case CMD_STATUS_RESULT_BACKEND_IDLE:
+			elog(INFO, "no command is currently running in backend with PID %d",
+				 target_pid);
+			break;
+
+	case CMD_STATUS_RESULT_NO_DATA:
+			elog(WARNING, "no suitable data found for the query in backend with PID %d",
+				 target_pid);
+			break;
+
+		default:
+			elog(ERROR, "general command status request failure");
+			break;
+	}
+}
+
+/*
+ * Try to get status of a command running in another process.
+ *
+ * FUNCTION pg_cmdstatus(pid, request_type)
+ * RETURNS SETOF text
+ */
+Datum
+pg_cmdstatus(PG_FUNCTION_ARGS)
+{
+	ReturnSetInfo	   *rsinfo	= (ReturnSetInfo *) fcinfo->resultinfo;
+	Tuplestorestate	   *tupstore;
+	TupleDesc			tupdesc;
+	MemoryContext		per_query_ctx;
+	MemoryContext		oldcontext;
+	pid_t				target_pid = (pid_t) PG_GETARG_INT32(0);
+	int					request_type = PG_GETARG_INT32(1);
+	PGPROC			   *proc;
+	shm_toc_estimator	estimator;
+	Size				segsize;
+	dsm_segment		   *seg = NULL;
+	shm_toc			   *toc = NULL;
+	shm_mq			   *mq = NULL;
+	shm_mq_handle	   *input = NULL;
+
+	/* check to see if caller supports us returning a tuplestore */
+	if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("set-valued function called in context that cannot accept a set")));
+
+	if (!(rsinfo->allowedModes & SFRM_Materialize))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("materialize mode required, but it is not allowed in this context")));
+
+	if (request_type < 1 || request_type > CMD_STATUS_MAX_REQUEST)
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("unknown command status request")));
+
+	/* need to build tuplestore in query context */
+	per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+	oldcontext = MemoryContextSwitchTo(per_query_ctx);
+
+	tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc);
+	tupstore = tuplestore_begin_heap(false, false, work_mem);
+	MemoryContextSwitchTo(oldcontext);
+
+	if (target_pid == MyProcPid)
+		ereport(ERROR,
+				(errmsg("backend cannot query command status of itself")));
+
+	/* verify access to target_pid */
+	proc = BackendPidGetProc(target_pid);
+
+	if (proc == NULL)
+		ereport(ERROR,
+				(errmsg("PID %d is not a PostgreSQL server process", target_pid)));
+
+	if (!(superuser() || proc->roleId == GetUserId()))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be superuser or have the same role to explain queries running in other server processes"))));
+
+	/* prepare shared dsm segment */
+	shm_toc_initialize_estimator(&estimator);
+	shm_toc_estimate_keys(&estimator, 1);
+	shm_toc_estimate_chunk(&estimator, CMD_STATUS_BUFFER_SIZE);
+	segsize = shm_toc_estimate(&estimator);
+
+	seg = dsm_create(segsize, 0);
+
+	toc = shm_toc_create(PG_CMD_STATUS_INFO_MAGIC, dsm_segment_address(seg),
+						 segsize);
+
+	/* prepare basic structures */
+	mq = shm_mq_create(shm_toc_allocate(toc, CMD_STATUS_BUFFER_SIZE),
+					   CMD_STATUS_BUFFER_SIZE);
+
+	shm_mq_set_receiver(mq, MyProc);
+	shm_mq_set_sender(mq, proc);
+	shm_toc_insert(toc, 0, mq);
+
+	PG_TRY();
+	{
+		shm_mq_result	res;
+		char		   *data = NULL;
+		Size			length;
+
+		input = shm_mq_attach(mq, seg, NULL);
+
+		if (SendCmdStatusInfoSignal(target_pid, proc->backendId,
+									dsm_segment_handle(seg), request_type))
+		{
+			elog(ERROR, "could not signal backend with PID %d", target_pid);
+		}
+
+		/*
+		 * This blocks until the sender process writes a message to the queue
+		 * or detaches from it.  In either case we wake up and process the
+		 * result.
+		 */
+		res = shm_mq_receive(input, &length, (void **) &data, false);
+		if (res == SHM_MQ_SUCCESS)
+		{
+			const char	   *p = data;
+
+			/* break into tuples on newline */
+			while (*p)
+			{
+				const char *q = strchr(p, '\n');
+				Size		len = q ? q - p : strlen(p);
+				Datum		value;
+				HeapTuple	tuple;
+				bool		isnull = false;
+
+				value = PointerGetDatum(cstring_to_text_with_len(p, len));
+
+				tuple = heap_form_tuple(tupdesc, &value, &isnull);
+				tuplestore_puttuple(tupstore, tuple);
+
+				if (!q)
+					break;
+
+				p += len + 1;
+			}
+		}
+		else
+		{
+			report_result_code(MyCmdStatusSlot->result_code, target_pid);
+		}
+
+		/* clean up and return the tuplestore */
+		tuplestore_donestoring(tupstore);
+
+		InvalidateCmdStatusSlot();
+
+		shm_mq_detach(mq);
+		dsm_detach(seg);
+	}
+	PG_CATCH();
+	{
+		InvalidateCmdStatusSlot();
+
+		shm_mq_detach(mq);
+		dsm_detach(seg);
+
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+
+	rsinfo->returnMode = SFRM_Materialize;
+	rsinfo->setResult = tupstore;
+	rsinfo->setDesc = tupdesc;
+
+	return (Datum) 0;
+}
diff --git a/src/backend/utils/init/globals.c b/src/backend/utils/init/globals.c
index 23e594e..2269853 100644
--- a/src/backend/utils/init/globals.c
+++ b/src/backend/utils/init/globals.c
@@ -29,6 +29,7 @@ ProtocolVersion FrontendProtocol;
 volatile bool InterruptPending = false;
 volatile bool QueryCancelPending = false;
 volatile bool ProcDiePending = false;
+volatile bool CmdStatusInfoPending = false;
 volatile bool ClientConnectionLost = false;
 volatile uint32 InterruptHoldoffCount = 0;
 volatile uint32 QueryCancelHoldoffCount = 0;
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 7b19714..7e7ba77 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -50,6 +50,7 @@
 #include "storage/smgr.h"
 #include "tcop/tcopprot.h"
 #include "utils/acl.h"
+#include "utils/cmdstatus.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
 #include "utils/memutils.h"
@@ -588,6 +589,9 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 	/* Now that we have a BackendId, we can participate in ProcSignal */
 	ProcSignalInit(MyBackendId);
 
+	/* Init CmdStatus slot */
+	CmdStatusInit(MyBackendId);
+
 	/*
 	 * Also set up timeout handlers needed for backend operation.  We need
 	 * these in every case except bootstrap.
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index ddf7c67..d083aaf 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -3130,6 +3130,8 @@ DESCR("get OID of current session's temp schema, if any");
 DATA(insert OID = 2855 (  pg_is_other_temp_schema	PGNSP PGUID 12 1 0 0 0 f f f f t f s 1 0 16 "26" _null_ _null_ _null_ _null_ _null_ pg_is_other_temp_schema _null_ _null_ _null_ ));
 DESCR("is schema another session's temp schema?");
 
+DATA(insert OID = 4099 ( pg_cmdstatus		PGNSP PGUID 12 1 100 0 0 f f f f f t s 2 0 25 "23 23" _null_ _null_  _null_  _null_ _null_ pg_cmdstatus _null_ _null_ _null_ ));
+DESCR("returns information about another process");
 DATA(insert OID = 2171 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_cancel_backend _null_ _null_ _null_ ));
 DESCR("cancel a server process' current query");
 DATA(insert OID = 2096 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
diff --git a/src/include/miscadmin.h b/src/include/miscadmin.h
index e0cc69f..5f03f63 100644
--- a/src/include/miscadmin.h
+++ b/src/include/miscadmin.h
@@ -80,6 +80,7 @@
 extern PGDLLIMPORT volatile bool InterruptPending;
 extern PGDLLIMPORT volatile bool QueryCancelPending;
 extern PGDLLIMPORT volatile bool ProcDiePending;
+extern PGDLLIMPORT volatile bool CmdStatusInfoPending;
 
 extern volatile bool ClientConnectionLost;
 
diff --git a/src/include/storage/procsignal.h b/src/include/storage/procsignal.h
index af1a0cd..cd856e5 100644
--- a/src/include/storage/procsignal.h
+++ b/src/include/storage/procsignal.h
@@ -41,6 +41,8 @@ typedef enum
 	PROCSIG_RECOVERY_CONFLICT_BUFFERPIN,
 	PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK,
 
+	PROCSIG_CMD_STATUS_INFO,
+
 	NUM_PROCSIGNALS				/* Must be last! */
 } ProcSignalReason;
 
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
index fc1679e..605612e 100644
--- a/src/include/utils/builtins.h
+++ b/src/include/utils/builtins.h
@@ -1243,6 +1243,9 @@ extern Datum pg_identify_object_as_address(PG_FUNCTION_ARGS);
 /* catalog/objectaddress.c */
 extern Datum pg_get_object_address(PG_FUNCTION_ARGS);
 
+/* utils/adt/cmdstatus.c */
+extern Datum pg_cmdstatus(PG_FUNCTION_ARGS);
+
 /* commands/constraint.c */
 extern Datum unique_key_recheck(PG_FUNCTION_ARGS);
 
diff --git a/src/include/utils/cmdstatus.h b/src/include/utils/cmdstatus.h
new file mode 100644
index 0000000..85627a57
--- /dev/null
+++ b/src/include/utils/cmdstatus.h
@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * cmdstatus.h
+ *	  Declarations for command status interrupt handling.
+ *
+ *
+ * Portions Copyright (c) 1996-2015, PostgreSQL Global Development Group
+ *
+ * src/include/utils/cmdstatus.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CMDSTATUS_H
+#define CMDSTATUS_H
+
+extern Size CmdStatusShmemSize(void);
+extern void CmdStatusShmemInit(void);
+extern void CmdStatusInit(int css_idx);
+
+extern void HandleCmdStatusInfoInterrupt(void);
+extern void ProcessCmdStatusInfoRequest(void);
+
+#endif   /* CMDSTATUS_H */

diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 32ac58f..2e3beaf 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -43,6 +43,7 @@
 #include "storage/procsignal.h"
 #include "storage/sinvaladt.h"
 #include "storage/spin.h"
+#include "utils/cmdstatus.h"
 
 
 shmem_startup_hook_type shmem_startup_hook = NULL;
@@ -139,6 +140,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, BTreeShmemSize());
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
+		size = add_size(size, CmdStatusShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -243,6 +245,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	ReplicationOriginShmemInit();
 	WalSndShmemInit();
 	WalRcvShmemInit();
+	CmdStatusShmemInit();
 
 	/*
 	 * Set up other modules that need some shared memory space
diff --git a/src/backend/storage/ipc/procsignal.c b/src/backend/storage/ipc/procsignal.c
index 0abde43..e637be1 100644
--- a/src/backend/storage/ipc/procsignal.c
+++ b/src/backend/storage/ipc/procsignal.c
@@ -26,6 +26,7 @@
 #include "storage/shmem.h"
 #include "storage/sinval.h"
 #include "tcop/tcopprot.h"
+#include "utils/cmdstatus.h"
 
 
 /*
@@ -296,6 +297,9 @@ procsignal_sigusr1_handler(SIGNAL_ARGS)
 	if (CheckProcSignal(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN))
 		RecoveryConflictInterrupt(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN);
 
+	if (CheckProcSignal(PROCSIG_CMD_STATUS_INFO))
+		HandleCmdStatusInfoInterrupt();
+
 	if (set_latch_on_sigusr1)
 		SetLatch(MyLatch);
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index d917af3..1a5b03c 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -67,6 +67,7 @@
 #include "tcop/pquery.h"
 #include "tcop/tcopprot.h"
 #include "tcop/utility.h"
+#include "utils/cmdstatus.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/ps_status.h"
@@ -2991,6 +2992,9 @@ ProcessInterrupts(void)
 
 	if (ParallelMessagePending)
 		HandleParallelMessages();
+
+	if (CmdStatusInfoPending)
+		ProcessCmdStatusInfoRequest();
 }
 
 
diff --git a/src/backend/utils/adt/Makefile b/src/backend/utils/adt/Makefile
index 3ed0b44..2c8687c 100644
--- a/src/backend/utils/adt/Makefile
+++ b/src/backend/utils/adt/Makefile
@@ -18,7 +18,7 @@ endif
 # keep this list arranged alphabetically or it gets to be a mess
 OBJS = acl.o arrayfuncs.o array_expanded.o array_selfuncs.o \
 	array_typanalyze.o array_userfuncs.o arrayutils.o ascii.o \
-	bool.o cash.o char.o date.o datetime.o datum.o dbsize.o domains.o \
+	bool.o cash.o char.o cmdstatus.o date.o datetime.o datum.o dbsize.o domains.o \
 	encode.o enum.o expandeddatum.o \
 	float.o format_type.o formatting.o genfile.o \
 	geo_ops.o geo_selfuncs.o inet_cidr_ntop.o inet_net_pton.o int.o \
diff --git a/src/backend/utils/adt/cmdstatus.c b/src/backend/utils/adt/cmdstatus.c
new file mode 100644
index 0000000..6cb04f4
--- /dev/null
+++ b/src/backend/utils/adt/cmdstatus.c
@@ -0,0 +1,675 @@
+/*-------------------------------------------------------------------------
+ *
+ * cmdstatus.c
+ *	  Definitions for pg_cmdstatus function.
+ *
+ * Copyright (c) 1996-2015, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/backend/utils/adt/cmdstatus.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "funcapi.h"
+#include "miscadmin.h"
+
+#include "access/htup_details.h"
+#include "commands/explain.h"
+#include "lib/stringinfo.h"
+#include "storage/dsm.h"
+#include "storage/ipc.h"
+#include "storage/latch.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "storage/procsignal.h"
+#include "storage/shm_mq.h"
+#include "storage/shm_toc.h"
+#include "tcop/dest.h"
+#include "tcop/pquery.h"
+#include "utils/builtins.h"
+#include "utils/cmdstatus.h"
+
+
+typedef enum {
+	CMD_STATUS_REQUEST_EXPLAIN = 1,
+	CMD_STATUS_REQUEST_QUERY_TEXT = 2,
+	CMD_STATUS_REQUEST_PROGRESS_TAG = 3,
+	CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE = 4
+} CmdStatusInfoRequestType;
+
+#define CMD_STATUS_MAX_REQUEST CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE
+
+typedef enum {
+	CMD_STATUS_RESULT_FAILURE = -1,
+	CMD_STATUS_RESULT_SUCCESS = 0,
+	CMD_STATUS_RESULT_BACKEND_IDLE,
+	CMD_STATUS_RESULT_NO_DATA
+} CmdStatusInfoResultCode;
+
+/*
+ * We allocate an array the size of NumCmdStatusSlots of DSM handles in the
+ * shared memory.  This slots array is indexed by backend ID, so each slot can
+ * corresponds to at max. one backend at any given time.
+ *
+ * In order to actually query some backend for its status, the interested
+ * process will create a DSM segment, initialize a table of contents in it,
+ * fill the target process id and request type and create a shared memory
+ * queue in the segment.
+ *
+ * The interested process will then put the such initialized DSM segment's
+ * handle in its own slot and send the SIGUSR1 with the reason
+ * PROCSIG_CMD_STATUS_INFO to the process being queried.  The interested
+ * process will wait for the response to be delivered via the shared memory
+ * queue and the result code via a field in the DSM segment.
+ *
+ * The layout of a DSM segment is given by the following TOC keys enumeration:
+ */
+typedef enum {
+	CmdStatusSlotKeyTargetProcessID,
+	CmdStatusSlotKeyIsProcessedFlag,
+	CmdStatusSlotKeyRequestType,
+	CmdStatusSlotKeyResultCode,
+	CmdStatusSlotKeyMemoryQueue,
+
+	CmdStatusTotalSlotKeys
+} CmdStatusSlotKey;
+
+#define NumCmdStatusSlots	MaxBackends
+
+#define PG_CMD_STATUS_INFO_MAGIC	0x79fb2449
+#define CMD_STATUS_BUFFER_SIZE		1024
+
+/*
+ * These structs are allocated on the program stack as local variables in the
+ * ExecutorRun hook.  The top of stack is current_query_stack, see below.
+ *
+ * Capturing the execution stack allows us to inspect the inner-most running
+ * query as well as showing the complete backtrace.
+ */
+typedef struct CmdInfoStack {
+	QueryDesc			   *query_desc;
+	struct CmdInfoStack	   *parent;
+} CmdInfoStack;
+
+/* The array of slots pre-allocated on shared memory. */
+static volatile dsm_handle *CmdStatusSlots = NULL;
+
+/* Pointer into the slots array, to a slot assigned for this backend. */
+static volatile dsm_handle *MyCmdStatusSlot = NULL;
+
+static CmdInfoStack	   *current_query_stack = NULL;
+static int				query_stack_size = 0;  /* XXX not really used */
+
+static ExecutorRun_hook_type	prev_ExecutorRun = NULL;
+
+static void cmdstatus_ExecutorRun(QueryDesc *queryDesc,
+								  ScanDirection direction, long count);
+
+static void CleanupCmdStatusSlot(int status, Datum arg);
+static StringInfo ProcessCmdStatusSlot(CmdStatusInfoRequestType request_type,
+					 CmdStatusInfoResultCode *result_code);
+
+static StringInfo explain_query(QueryDesc *queryDesc);
+static void report_result_code(CmdStatusInfoResultCode result, pid_t target_pid);
+static void RestoreResourceOwner(ResourceOwner prevResourceOwner);
+
+
+Size
+CmdStatusShmemSize(void)
+{
+	return NumCmdStatusSlots * sizeof(dsm_handle);
+}
+
+void
+CmdStatusShmemInit(void)
+{
+	Size		size = CmdStatusShmemSize();
+	bool		found;
+
+	CmdStatusSlots = (dsm_handle *) ShmemInitStruct("CmdStatusSlots", size, &found);
+
+	if (!found)
+		MemSet(CmdStatusSlots, 0, size);
+}
+
+static void
+CleanupCmdStatusSlot(int status, Datum arg)
+{
+	Assert(MyCmdStatusSlot != NULL);
+
+	*MyCmdStatusSlot = 0;	/* just in case */
+
+	MyCmdStatusSlot = NULL;
+}
+
+/*
+ * CmdStatusInit
+ *		Initialize MyCmdStatusSlot
+ *
+ * The passed index should be MyBackendId.
+ */
+void
+CmdStatusInit(int css_idx)
+{
+	MyCmdStatusSlot = &CmdStatusSlots[css_idx - 1];
+
+	on_shmem_exit(CleanupCmdStatusSlot, (Datum) 0);
+
+	/* also install executor hooks */
+	prev_ExecutorRun = ExecutorRun_hook;
+	ExecutorRun_hook = cmdstatus_ExecutorRun;
+}
+
+/*
+ * The executor hook.
+ *
+ * Accumulates the query descriptors on the program stack and takes care of
+ * popping the current frame when leaving the function ab-/normally.
+ */
+static void
+cmdstatus_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, long count)
+{
+	CmdInfoStack	current;
+
+	current.query_desc = queryDesc;
+	current.parent = current_query_stack;
+
+	current_query_stack = &current;
+	query_stack_size++;
+
+	PG_TRY();
+	{
+		if (prev_ExecutorRun)
+			prev_ExecutorRun(queryDesc, direction, count);
+		else
+			standard_ExecutorRun(queryDesc, direction, count);
+
+		Assert(current_query_stack == &current);
+		Assert(query_stack_size > 0);
+
+		query_stack_size--;
+		current_query_stack = current.parent;
+	}
+	PG_CATCH();
+	{
+		Assert(current_query_stack == &current);
+		Assert(query_stack_size > 0);
+
+		query_stack_size--;
+		current_query_stack = current.parent;
+
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+}
+
+/* Produce an explain plan of a single query descriptor. */
+static StringInfo
+explain_query(QueryDesc *queryDesc)
+{
+	StringInfo		str;
+	ExplainState   *es;
+
+	es = NewExplainState();
+	es->analyze = false;
+	es->verbose = false;
+	es->buffers = false;
+	es->format = EXPLAIN_FORMAT_TEXT;
+
+	ExplainBeginOutput(es);
+	/* XXX: appendStringInfo(es->str, "#%d ", depth); ? */
+	ExplainQueryText(es, queryDesc);
+	ExplainPrintPlan(es, queryDesc);
+	ExplainEndOutput(es);
+
+	str = es->str;
+
+	pfree(es);
+	return str;
+}
+
+
+/* signal handler for PROCSIG_CMD_STATUS_INFO */
+void
+HandleCmdStatusInfoInterrupt(void)
+{
+	CmdStatusInfoPending = true;
+	InterruptPending = true;
+
+	SetLatch(MyLatch);
+}
+
+/* Produce a response and set the result code for a single slot. */
+static StringInfo
+ProcessCmdStatusSlot(CmdStatusInfoRequestType request_type,
+					 CmdStatusInfoResultCode *result_code)
+{
+	StringInfo		result = NULL;
+
+	/* Show some optimism, overwrite with error code later if needed. */
+	*result_code = CMD_STATUS_RESULT_SUCCESS;
+
+	if (ActivePortal)
+	{
+		switch (request_type)
+		{
+			case CMD_STATUS_REQUEST_EXPLAIN:
+				if (ActivePortal->queryDesc != NULL)
+					result = explain_query(ActivePortal->queryDesc);
+				else if (current_query_stack != NULL)
+					result = explain_query(current_query_stack->query_desc);
+				else
+					*result_code = CMD_STATUS_RESULT_NO_DATA;
+				break;
+
+			case CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE:
+				{
+					StringInfo		str;
+					CmdInfoStack   *query;
+
+					result = makeStringInfo();
+
+					if (current_query_stack != NULL)
+					{
+						for (query = current_query_stack;
+							 query != NULL;
+							 query = query->parent)
+						{
+							str = explain_query(query->query_desc);
+							appendBinaryStringInfo(result, str->data, str->len);
+
+							pfree(str->data);
+							pfree(str);
+						}
+					}
+					else
+						*result_code = CMD_STATUS_RESULT_BACKEND_IDLE;
+					break;
+				}
+
+			case CMD_STATUS_REQUEST_QUERY_TEXT:
+				result = makeStringInfo();
+				appendStringInfoString(result, ActivePortal->sourceText);
+				break;
+
+			case CMD_STATUS_REQUEST_PROGRESS_TAG:
+				if (ActivePortal->commandTag != NULL)
+				{
+					result = makeStringInfo();
+
+					if (ActivePortal->queryDesc != NULL &&
+						ActivePortal->queryDesc->estate != NULL)
+					{
+						appendStringInfo(result, "%s %u",
+										 ActivePortal->commandTag,
+										 ActivePortal->queryDesc->estate->es_processed);
+					}
+					else
+					{
+						/* no progress available, at least show the command tag */
+						appendStringInfoString(result, ActivePortal->commandTag);
+					}
+				}
+				else
+					*result_code = CMD_STATUS_RESULT_NO_DATA;
+				break;
+		}
+	}
+	else
+		*result_code = CMD_STATUS_RESULT_BACKEND_IDLE;
+
+	return result;
+}
+
+static void
+RestoreResourceOwner(ResourceOwner prevResourceOwner)
+{
+	if (prevResourceOwner != CurrentResourceOwner)
+	{
+		ResourceOwner	res_owner = CurrentResourceOwner;
+
+		CurrentResourceOwner = prevResourceOwner;
+		ResourceOwnerDelete(res_owner);
+	}
+}
+
+/*
+ * Process all command status requests from other backends by scanning the
+ * whole array of slots looking for the requests targeted at us, which were
+ * not already processed by us during earlier rounds.
+ *
+ * Most of the times it is expected that the first valid slot we find is for
+ * us, so there's no penalty for actually attaching it and looking inside.
+ */
+void
+ProcessCmdStatusInfoRequest(void)
+{
+	ResourceOwner	prevResourceOwner = CurrentResourceOwner;
+
+	/* Ensure valid resource owner for access to dsm. */
+	if (CurrentResourceOwner == NULL)
+		CurrentResourceOwner = ResourceOwnerCreate(NULL, "ProcessCmdStatusInfoRequest");
+
+	/*
+	 * We might have been signaled again by another process while handling a
+	 * request, so re-check after going through all the slots.
+	 */
+	while (CmdStatusInfoPending)
+	{
+		int		i;
+
+		CmdStatusInfoPending = false;
+
+		for (i = 0; i < NumCmdStatusSlots; i++)
+		{
+			dsm_handle slot = CmdStatusSlots[i];
+
+			if (slot != 0)
+			{
+				dsm_segment	   *seg = NULL;
+				shm_toc		   *toc = NULL;
+				pid_t		   *target_pid_ptr;
+				bool		   *is_processed_flag_ptr;
+				CmdStatusInfoRequestType   *request_type_ptr;
+				CmdStatusInfoResultCode	   *result_code_ptr;
+				shm_mq		   *mq;
+				shm_mq_handle  *output;
+
+				seg = dsm_attach(slot);
+				if (seg == NULL)
+				{
+					elog(LOG, "unable to map dynamic memory segment for command status");
+					continue;
+				}
+
+				toc = shm_toc_attach(PG_CMD_STATUS_INFO_MAGIC, dsm_segment_address(seg));
+				if (toc == NULL)
+				{
+					elog(LOG, "bad magic in dynamic memory segment for command status");
+
+					dsm_detach(seg);
+					continue;
+				}
+
+				target_pid_ptr = (pid_t *)
+					shm_toc_lookup(toc, CmdStatusSlotKeyTargetProcessID);
+				is_processed_flag_ptr = (bool *)
+					shm_toc_lookup(toc, CmdStatusSlotKeyIsProcessedFlag);
+
+				if (*target_pid_ptr != MyProcPid || *is_processed_flag_ptr)
+				{
+					dsm_detach(seg);
+					continue;
+				}
+
+				/* Set the flag early to avoid re-processing during next round. */
+				*is_processed_flag_ptr = true;
+
+				request_type_ptr = (CmdStatusInfoRequestType *)
+					shm_toc_lookup(toc, CmdStatusSlotKeyRequestType);
+
+				result_code_ptr = (CmdStatusInfoResultCode *)
+					shm_toc_lookup(toc, CmdStatusSlotKeyResultCode);
+
+				mq = shm_toc_lookup(toc, CmdStatusSlotKeyMemoryQueue);
+				output = shm_mq_attach(mq, seg, NULL);
+
+				PG_TRY();
+				{
+					StringInfo		payload;
+					int				res;
+
+					payload = ProcessCmdStatusSlot(*request_type_ptr, result_code_ptr);
+					if (payload != NULL)
+					{
+						/*
+						 * Send the data, including null terminator.
+						 *
+						 * This blocks until the receiving side completes
+						 * reading or detaches from the queue.
+						 */
+						res = shm_mq_send(output, payload->len + 1, payload->data, false);
+						if (res != SHM_MQ_SUCCESS)
+							elog(LOG, "cannot send command status via shared memory queue");
+
+						pfree(payload->data);
+						pfree(payload);
+					}
+					/*
+					 * If there was no payload to send, we just detach from
+					 * the queue and the receiver should wake up.
+					 */
+
+					shm_mq_detach(mq);
+					dsm_detach(seg);
+				}
+				PG_CATCH();
+				{
+					/*
+					 * Detaching from the queue also wakes up the receiver, be
+					 * sure to update the slot status before detaching.
+					 */
+					shm_mq_detach(mq);
+					dsm_detach(seg);
+
+					RestoreResourceOwner(prevResourceOwner);	/* XXX remove if not re-throwing */
+
+					PG_RE_THROW();	/* XXX is it better to log/suppress the error here? */
+				}
+				PG_END_TRY();
+			}
+		}
+	}
+
+	RestoreResourceOwner(prevResourceOwner);
+}
+
+static void
+report_result_code(CmdStatusInfoResultCode result, pid_t target_pid)
+{
+	switch (result)
+	{
+		case CMD_STATUS_RESULT_BACKEND_IDLE:
+			elog(INFO, "no command is currently running in backend with PID %d",
+				 target_pid);
+			break;
+
+		case CMD_STATUS_RESULT_NO_DATA:
+			elog(WARNING, "no suitable data found for the query in backend with PID %d",
+				 target_pid);
+			break;
+
+		default:
+			elog(ERROR, "general command status request failure when querying backend with PID %d",
+				 target_pid);
+			break;
+	}
+}
+
+/*
+ * Try to get status of a command running in another process.
+ *
+ * FUNCTION pg_cmdstatus(pid, request_type)
+ * RETURNS SETOF text
+ */
+Datum
+pg_cmdstatus(PG_FUNCTION_ARGS)
+{
+	ReturnSetInfo	   *rsinfo	= (ReturnSetInfo *) fcinfo->resultinfo;
+	Tuplestorestate	   *tupstore;
+	TupleDesc			tupdesc;
+	MemoryContext		per_query_ctx;
+	MemoryContext		oldcontext;
+	pid_t				target_pid = (pid_t) PG_GETARG_INT32(0);
+	int					request_type = PG_GETARG_INT32(1);
+	PGPROC			   *target_proc;
+	shm_toc_estimator	estimator;
+	Size				segsize;
+	dsm_segment		   *seg;
+	shm_toc			   *toc;
+	pid_t			   *target_pid_ptr;
+	bool			   *is_processed_flag_ptr;
+	CmdStatusInfoRequestType   *request_type_ptr;
+	CmdStatusInfoResultCode	   *result_code_ptr;
+	shm_mq			   *mq;
+	shm_mq_handle	   *input;
+
+	/* check to see if caller supports us returning a tuplestore */
+	if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("set-valued function called in context that cannot accept a set")));
+
+	if (!(rsinfo->allowedModes & SFRM_Materialize))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("materialize mode required, but it is not allowed in this context")));
+
+	if (request_type < 1 || request_type > CMD_STATUS_MAX_REQUEST)
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("unknown command status request")));
+
+	if (target_pid == MyProcPid)
+		ereport(ERROR,
+				(errmsg("backend cannot query command status of itself")));
+
+	/* verify access to target_pid */
+	target_proc = BackendPidGetProc(target_pid);
+
+	if (target_proc == NULL)
+		ereport(ERROR,
+				(errmsg("PID %d is not a PostgreSQL server process", target_pid)));
+
+	if (!(superuser() || target_proc->roleId == GetUserId()))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be superuser or have the same role to explain queries running in other server processes"))));
+
+	if (*MyCmdStatusSlot != 0)
+		ereport(ERROR,
+				(errmsg("pg_cmdstatus() call is already in progress")));
+
+	/* need to build tuplestore in query context */
+	per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+	oldcontext = MemoryContextSwitchTo(per_query_ctx);
+
+	tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc);
+	tupstore = tuplestore_begin_heap(false, false, work_mem);
+	MemoryContextSwitchTo(oldcontext);
+
+	/* prepare shared dsm segment */
+	shm_toc_initialize_estimator(&estimator);
+	shm_toc_estimate_keys(&estimator, CmdStatusTotalSlotKeys);
+	shm_toc_estimate_chunk(&estimator, sizeof(pid_t));
+	shm_toc_estimate_chunk(&estimator, sizeof(bool));
+	shm_toc_estimate_chunk(&estimator, sizeof(CmdStatusInfoRequestType));
+	shm_toc_estimate_chunk(&estimator, sizeof(CmdStatusInfoResultCode));
+	shm_toc_estimate_chunk(&estimator, CMD_STATUS_BUFFER_SIZE);
+	segsize = shm_toc_estimate(&estimator);
+
+	seg = dsm_create(segsize, 0);
+
+	toc = shm_toc_create(PG_CMD_STATUS_INFO_MAGIC, dsm_segment_address(seg), segsize);
+
+	target_pid_ptr = (pid_t *) shm_toc_allocate(toc, sizeof(pid_t));
+	*target_pid_ptr = target_pid;
+	shm_toc_insert(toc, CmdStatusSlotKeyTargetProcessID, target_pid_ptr);
+
+	is_processed_flag_ptr = (bool *) shm_toc_allocate(toc, sizeof(bool));
+	*is_processed_flag_ptr = false;
+	shm_toc_insert(toc, CmdStatusSlotKeyIsProcessedFlag, is_processed_flag_ptr);
+
+	request_type_ptr = (CmdStatusInfoRequestType *)
+		shm_toc_allocate(toc, sizeof(CmdStatusInfoRequestType));
+	*request_type_ptr = request_type;
+	shm_toc_insert(toc, CmdStatusSlotKeyRequestType, request_type_ptr);
+
+	result_code_ptr = (CmdStatusInfoResultCode *)
+		shm_toc_allocate(toc, sizeof(CmdStatusInfoResultCode));
+	*result_code_ptr = CMD_STATUS_RESULT_FAILURE;
+	shm_toc_insert(toc, CmdStatusSlotKeyResultCode, result_code_ptr);
+
+	mq = shm_mq_create(shm_toc_allocate(toc, CMD_STATUS_BUFFER_SIZE),
+					   CMD_STATUS_BUFFER_SIZE);
+	shm_toc_insert(toc, CmdStatusSlotKeyMemoryQueue, mq);
+
+	shm_mq_set_receiver(mq, MyProc);
+	shm_mq_set_sender(mq, target_proc);
+
+	PG_TRY();
+	{
+		shm_mq_result	res;
+		char		   *data = NULL;
+		Size			length;
+
+		input = shm_mq_attach(mq, seg, NULL);
+
+		*MyCmdStatusSlot = dsm_segment_handle(seg);
+
+		if (SendProcSignal(target_pid, PROCSIG_CMD_STATUS_INFO, target_proc->backendId))
+			elog(ERROR, "could not signal backend with PID %d", target_pid);
+
+		/*
+		 * This blocks until the sender process writes a message to the queue
+		 * or detaches from it.  In either case we wake up and process the
+		 * result.
+		 */
+		res = shm_mq_receive(input, &length, (void **) &data, false);
+		if (res == SHM_MQ_SUCCESS)
+		{
+			const char	   *p = data;
+
+			/* break into tuples on newline */
+			while (*p)
+			{
+				const char *q = strchr(p, '\n');
+				Size		len = q ? q - p : strlen(p);
+				Datum		value;
+				HeapTuple	tuple;
+				bool		isnull = false;
+
+				value = PointerGetDatum(cstring_to_text_with_len(p, len));
+
+				tuple = heap_form_tuple(tupdesc, &value, &isnull);
+				tuplestore_puttuple(tupstore, tuple);
+
+				if (!q)
+					break;
+
+				p += len + 1;
+			}
+		}
+		else
+		{
+			report_result_code(*result_code_ptr, target_pid);
+		}
+
+		/* clean up and return the tuplestore */
+		tuplestore_donestoring(tupstore);
+
+		*MyCmdStatusSlot = 0;
+
+		shm_mq_detach(mq);
+		dsm_detach(seg);
+	}
+	PG_CATCH();
+	{
+		*MyCmdStatusSlot = 0;
+
+		shm_mq_detach(mq);
+		dsm_detach(seg);
+
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+
+	rsinfo->returnMode = SFRM_Materialize;
+	rsinfo->setResult = tupstore;
+	rsinfo->setDesc = tupdesc;
+
+	return (Datum) 0;
+}
diff --git a/src/backend/utils/init/globals.c b/src/backend/utils/init/globals.c
index 23e594e..2269853 100644
--- a/src/backend/utils/init/globals.c
+++ b/src/backend/utils/init/globals.c
@@ -29,6 +29,7 @@ ProtocolVersion FrontendProtocol;
 volatile bool InterruptPending = false;
 volatile bool QueryCancelPending = false;
 volatile bool ProcDiePending = false;
+volatile bool CmdStatusInfoPending = false;
 volatile bool ClientConnectionLost = false;
 volatile uint32 InterruptHoldoffCount = 0;
 volatile uint32 QueryCancelHoldoffCount = 0;
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 7b19714..7e7ba77 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -50,6 +50,7 @@
 #include "storage/smgr.h"
 #include "tcop/tcopprot.h"
 #include "utils/acl.h"
+#include "utils/cmdstatus.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
 #include "utils/memutils.h"
@@ -588,6 +589,9 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 	/* Now that we have a BackendId, we can participate in ProcSignal */
 	ProcSignalInit(MyBackendId);
 
+	/* Init CmdStatus slot */
+	CmdStatusInit(MyBackendId);
+
 	/*
 	 * Also set up timeout handlers needed for backend operation.  We need
 	 * these in every case except bootstrap.
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index ddf7c67..d083aaf 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -3130,6 +3130,8 @@ DESCR("get OID of current session's temp schema, if any");
 DATA(insert OID = 2855 (  pg_is_other_temp_schema	PGNSP PGUID 12 1 0 0 0 f f f f t f s 1 0 16 "26" _null_ _null_ _null_ _null_ _null_ pg_is_other_temp_schema _null_ _null_ _null_ ));
 DESCR("is schema another session's temp schema?");
 
+DATA(insert OID = 4099 ( pg_cmdstatus		PGNSP PGUID 12 1 100 0 0 f f f f f t s 2 0 25 "23 23" _null_ _null_  _null_  _null_ _null_ pg_cmdstatus _null_ _null_ _null_ ));
+DESCR("returns information about another process");
 DATA(insert OID = 2171 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_cancel_backend _null_ _null_ _null_ ));
 DESCR("cancel a server process' current query");
 DATA(insert OID = 2096 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
diff --git a/src/include/miscadmin.h b/src/include/miscadmin.h
index e0cc69f..5f03f63 100644
--- a/src/include/miscadmin.h
+++ b/src/include/miscadmin.h
@@ -80,6 +80,7 @@
 extern PGDLLIMPORT volatile bool InterruptPending;
 extern PGDLLIMPORT volatile bool QueryCancelPending;
 extern PGDLLIMPORT volatile bool ProcDiePending;
+extern PGDLLIMPORT volatile bool CmdStatusInfoPending;
 
 extern volatile bool ClientConnectionLost;
 
diff --git a/src/include/storage/procsignal.h b/src/include/storage/procsignal.h
index af1a0cd..cd856e5 100644
--- a/src/include/storage/procsignal.h
+++ b/src/include/storage/procsignal.h
@@ -41,6 +41,8 @@ typedef enum
 	PROCSIG_RECOVERY_CONFLICT_BUFFERPIN,
 	PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK,
 
+	PROCSIG_CMD_STATUS_INFO,
+
 	NUM_PROCSIGNALS				/* Must be last! */
 } ProcSignalReason;
 
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
index fc1679e..605612e 100644
--- a/src/include/utils/builtins.h
+++ b/src/include/utils/builtins.h
@@ -1243,6 +1243,9 @@ extern Datum pg_identify_object_as_address(PG_FUNCTION_ARGS);
 /* catalog/objectaddress.c */
 extern Datum pg_get_object_address(PG_FUNCTION_ARGS);
 
+/* utils/adt/cmdstatus.c */
+extern Datum pg_cmdstatus(PG_FUNCTION_ARGS);
+
 /* commands/constraint.c */
 extern Datum unique_key_recheck(PG_FUNCTION_ARGS);
 
diff --git a/src/include/utils/cmdstatus.h b/src/include/utils/cmdstatus.h
new file mode 100644
index 0000000..85627a57
--- /dev/null
+++ b/src/include/utils/cmdstatus.h
@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * cmdstatus.h
+ *	  Declarations for command status interrupt handling.
+ *
+ *
+ * Portions Copyright (c) 1996-2015, PostgreSQL Global Development Group
+ *
+ * src/include/utils/cmdstatus.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CMDSTATUS_H
+#define CMDSTATUS_H
+
+extern Size CmdStatusShmemSize(void);
+extern void CmdStatusShmemInit(void);
+extern void CmdStatusInit(int css_idx);
+
+extern void HandleCmdStatusInfoInterrupt(void);
+extern void ProcessCmdStatusInfoRequest(void);
+
+#endif   /* CMDSTATUS_H */

diff --git a/contrib/auto_explain/auto_explain.c b/contrib/auto_explain/auto_explain.c
index 2a184ed..d2f46bb 100644
--- a/contrib/auto_explain/auto_explain.c
+++ b/contrib/auto_explain/auto_explain.c
@@ -288,7 +288,7 @@ explain_ExecutorEnd(QueryDesc *queryDesc)
 		 * Make sure stats accumulation is done.  (Note: it's okay if several
 		 * levels of hook all do this.)
 		 */
-		InstrEndLoop(queryDesc->totaltime);
+		InstrEndLoop(queryDesc->totaltime, false);
 
 		/* Log plan if duration is exceeded. */
 		msec = queryDesc->totaltime->total * 1000.0;
diff --git a/contrib/pg_stat_statements/pg_stat_statements.c b/contrib/pg_stat_statements/pg_stat_statements.c
index 59b8a2e..d90fc6d 100644
--- a/contrib/pg_stat_statements/pg_stat_statements.c
+++ b/contrib/pg_stat_statements/pg_stat_statements.c
@@ -926,7 +926,7 @@ pgss_ExecutorEnd(QueryDesc *queryDesc)
 		 * Make sure stats accumulation is done.  (Note: it's okay if several
 		 * levels of hook all do this.)
 		 */
-		InstrEndLoop(queryDesc->totaltime);
+		InstrEndLoop(queryDesc->totaltime, false);
 
 		pgss_store(queryDesc->sourceText,
 				   queryId,
diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 5d06fa4..e5a28a9 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -654,7 +654,7 @@ report_triggers(ResultRelInfo *rInfo, bool show_relname, ExplainState *es)
 		char	   *conname = NULL;
 
 		/* Must clean up instrumentation state */
-		InstrEndLoop(instr);
+		InstrEndLoop(instr, false);
 
 		/*
 		 * We ignore triggers that were never invoked; they likely aren't
@@ -1233,62 +1233,75 @@ ExplainNode(PlanState *planstate, List *ancestors,
 		}
 	}
 
-	/*
-	 * We have to forcibly clean up the instrumentation state because we
-	 * haven't done ExecutorEnd yet.  This is pretty grotty ...
-	 *
-	 * Note: contrib/auto_explain could cause instrumentation to be set up
-	 * even though we didn't ask for it here.  Be careful not to print any
-	 * instrumentation results the user didn't ask for.  But we do the
-	 * InstrEndLoop call anyway, if possible, to reduce the number of cases
-	 * auto_explain has to contend with.
-	 */
 	if (planstate->instrument)
-		InstrEndLoop(planstate->instrument);
-
-	if (es->analyze &&
-		planstate->instrument && planstate->instrument->nloops > 0)
 	{
-		double		nloops = planstate->instrument->nloops;
-		double		startup_sec = 1000.0 * planstate->instrument->startup / nloops;
-		double		total_sec = 1000.0 * planstate->instrument->total / nloops;
-		double		rows = planstate->instrument->ntuples / nloops;
+		/*
+		 * We have to forcibly clean up the instrumentation state because we
+		 * haven't done ExecutorEnd yet.  This is pretty grotty ...
+		 *
+		 * Note: contrib/auto_explain could cause instrumentation to be set up
+		 * even though we didn't ask for it here.  Be careful not to print any
+		 * instrumentation results the user didn't ask for.  But we do the
+		 * InstrEndLoop call anyway, if possible, to reduce the number of cases
+		 * auto_explain has to contend with.
+		 */
+		InstrEndLoop(planstate->instrument, es->running);
 
-		if (es->format == EXPLAIN_FORMAT_TEXT)
-		{
-			if (es->timing)
-				appendStringInfo(es->str,
-							" (actual time=%.3f..%.3f rows=%.0f loops=%.0f)",
-								 startup_sec, total_sec, rows, nloops);
-			else
-				appendStringInfo(es->str,
-								 " (actual rows=%.0f loops=%.0f)",
-								 rows, nloops);
-		}
-		else
+		if (es->analyze)
 		{
-			if (es->timing)
+			double		nloops = planstate->instrument->nloops;
+
+			if (es->running && planstate->instrument->running)
+				nloops += 1; /* so we can display something */
+
+			if (nloops > 0)
 			{
-				ExplainPropertyFloat("Actual Startup Time", startup_sec, 3, es);
-				ExplainPropertyFloat("Actual Total Time", total_sec, 3, es);
+				double		startup_sec = 1000.0 * planstate->instrument->startup / nloops;
+				double		total_sec = 1000.0 * planstate->instrument->total / nloops;
+				double		rows = planstate->instrument->ntuples / nloops;
+				double		percent_done = 100.0 * rows / plan->plan_rows;
+
+				if (es->format == EXPLAIN_FORMAT_TEXT)
+				{
+					if (es->timing)
+						appendStringInfo(es->str,
+										 " (actual time=%.3f..%.3f rows=%.0f loops=%.0f)",
+										 startup_sec, total_sec, rows,
+										 planstate->instrument->nloops);
+					else
+						appendStringInfo(es->str,
+										 " (actual rows=%.0f loops=%.0f)",
+										 rows, planstate->instrument->nloops);
+
+					if (es->running)
+						appendStringInfo(es->str, " %.1f%%", percent_done);
+				}
+				else
+				{
+					if (es->timing)
+					{
+						ExplainPropertyFloat("Actual Startup Time", startup_sec, 3, es);
+						ExplainPropertyFloat("Actual Total Time", total_sec, 3, es);
+					}
+					ExplainPropertyFloat("Actual Rows", rows, 0, es);
+					ExplainPropertyFloat("Actual Loops", planstate->instrument->nloops, 0, es);
+				}
 			}
-			ExplainPropertyFloat("Actual Rows", rows, 0, es);
-			ExplainPropertyFloat("Actual Loops", nloops, 0, es);
-		}
-	}
-	else if (es->analyze)
-	{
-		if (es->format == EXPLAIN_FORMAT_TEXT)
-			appendStringInfoString(es->str, " (never executed)");
-		else
-		{
-			if (es->timing)
+			else
 			{
-				ExplainPropertyFloat("Actual Startup Time", 0.0, 3, es);
-				ExplainPropertyFloat("Actual Total Time", 0.0, 3, es);
+				if (es->format == EXPLAIN_FORMAT_TEXT)
+					appendStringInfoString(es->str, " (never executed)");
+				else
+				{
+					if (es->timing)
+					{
+						ExplainPropertyFloat("Actual Startup Time", 0.0, 3, es);
+						ExplainPropertyFloat("Actual Total Time", 0.0, 3, es);
+					}
+					ExplainPropertyFloat("Actual Rows", 0.0, 0, es);
+					ExplainPropertyFloat("Actual Loops", 0.0, 0, es);
+				}
 			}
-			ExplainPropertyFloat("Actual Rows", 0.0, 0, es);
-			ExplainPropertyFloat("Actual Loops", 0.0, 0, es);
 		}
 	}
 
@@ -2650,7 +2663,7 @@ show_modifytable_info(ModifyTableState *mtstate, List *ancestors,
 			double		insert_path;
 			double		other_path;
 
-			InstrEndLoop(mtstate->mt_plans[0]->instrument);
+			InstrEndLoop(mtstate->mt_plans[0]->instrument, es->running);
 
 			/* count the number of source rows */
 			total = mtstate->mt_plans[0]->instrument->ntuples;
diff --git a/src/backend/executor/execAmi.c b/src/backend/executor/execAmi.c
index 93e1e9a..33162f2 100644
--- a/src/backend/executor/execAmi.c
+++ b/src/backend/executor/execAmi.c
@@ -72,7 +72,7 @@ ExecReScan(PlanState *node)
 {
 	/* If collecting timing stats, update them */
 	if (node->instrument)
-		InstrEndLoop(node->instrument);
+		InstrEndLoop(node->instrument, false);
 
 	/*
 	 * If we have changed parameters, propagate that info.
diff --git a/src/backend/executor/instrument.c b/src/backend/executor/instrument.c
index f5351eb..132153e 100644
--- a/src/backend/executor/instrument.c
+++ b/src/backend/executor/instrument.c
@@ -100,7 +100,7 @@ InstrStopNode(Instrumentation *instr, double nTuples)
 
 /* Finish a run cycle for a plan node */
 void
-InstrEndLoop(Instrumentation *instr)
+InstrEndLoop(Instrumentation *instr, bool partial_run)
 {
 	double		totaltime;
 
@@ -108,7 +108,7 @@ InstrEndLoop(Instrumentation *instr)
 	if (!instr->running)
 		return;
 
-	if (!INSTR_TIME_IS_ZERO(instr->starttime))
+	if (!INSTR_TIME_IS_ZERO(instr->starttime) && !partial_run)
 		elog(ERROR, "InstrEndLoop called on running node");
 
 	/* Accumulate per-cycle statistics into totals */
@@ -117,11 +117,15 @@ InstrEndLoop(Instrumentation *instr)
 	instr->startup += instr->firsttuple;
 	instr->total += totaltime;
 	instr->ntuples += instr->tuplecount;
-	instr->nloops += 1;
 
 	/* Reset for next cycle (if any) */
-	instr->running = false;
-	INSTR_TIME_SET_ZERO(instr->starttime);
+	if (!partial_run)
+	{
+		instr->nloops += 1;
+
+		instr->running = false;
+		INSTR_TIME_SET_ZERO(instr->starttime);
+	}
 	INSTR_TIME_SET_ZERO(instr->counter);
 	instr->firsttuple = 0;
 	instr->tuplecount = 0;
diff --git a/src/backend/utils/adt/cmdstatus.c b/src/backend/utils/adt/cmdstatus.c
index 5078100..b969907 100644
--- a/src/backend/utils/adt/cmdstatus.c
+++ b/src/backend/utils/adt/cmdstatus.c
@@ -95,7 +95,12 @@ typedef struct CmdInfoStack {
 } CmdInfoStack;
 
 
+/* GUCs */
 int cmdstatus_interrupt_timeout = CMD_STATUS_DEFAULT_INTERRUPT_TIMEOUT;
+bool cmdstatus_analyze = false;
+bool cmdstatus_instrument_timer = false;
+bool cmdstatus_instrument_rows = false;
+bool cmdstatus_instrument_buffers = false;
 
 /* The array of slots pre-allocated on shared memory. */
 static volatile dsm_handle *CmdStatusSlots = NULL;
@@ -106,8 +111,10 @@ static volatile dsm_handle *MyCmdStatusSlot = NULL;
 static CmdInfoStack	   *current_query_stack = NULL;
 static int				query_stack_size = 0;  /* XXX not really used */
 
+static ExecutorStart_hook_type	prev_ExecutorStart = NULL;
 static ExecutorRun_hook_type	prev_ExecutorRun = NULL;
 
+static void cmdstatus_ExecutorStart(QueryDesc *queryDesc, int eflags);
 static void cmdstatus_ExecutorRun(QueryDesc *queryDesc,
 								  ScanDirection direction, long count);
 
@@ -162,12 +169,42 @@ CmdStatusInit(int css_idx)
 	on_shmem_exit(CleanupCmdStatusSlot, (Datum) 0);
 
 	/* also install executor hooks */
+	prev_ExecutorStart = ExecutorStart_hook;
+	ExecutorStart_hook = cmdstatus_ExecutorStart;
+
 	prev_ExecutorRun = ExecutorRun_hook;
 	ExecutorRun_hook = cmdstatus_ExecutorRun;
 }
 
+
+/*
+ * The ExecutorStart hook.
+ *
+ * Turns on query instrumentation options based on configuration setting.
+ */
+static void
+cmdstatus_ExecutorStart(QueryDesc *queryDesc, int eflags)
+{
+	if (cmdstatus_analyze)
+	{
+		if (cmdstatus_instrument_timer)
+			queryDesc->instrument_options |= INSTRUMENT_TIMER;
+
+		if (cmdstatus_instrument_rows)
+			queryDesc->instrument_options |= INSTRUMENT_ROWS;
+
+		if (cmdstatus_instrument_buffers)
+			queryDesc->instrument_options |= INSTRUMENT_BUFFERS;
+	}
+
+	if (prev_ExecutorStart)
+		prev_ExecutorStart(queryDesc, eflags);
+	else
+		standard_ExecutorStart(queryDesc, eflags);
+}
+
 /*
- * The executor hook.
+ * The ExecutorRun hook.
  *
  * Accumulates the query descriptors on the program stack and takes care of
  * popping the current frame when leaving the function ab-/normally.
@@ -217,9 +254,11 @@ explain_query(QueryDesc *queryDesc)
 	ExplainState   *es;
 
 	es = NewExplainState();
-	es->analyze = false;
+	es->running = true;
+	es->analyze = cmdstatus_analyze;
+	es->timing = cmdstatus_instrument_timer;
 	es->verbose = false;
-	es->buffers = false;
+	es->buffers = cmdstatus_instrument_buffers;
 	es->format = EXPLAIN_FORMAT_TEXT;
 
 	ExplainBeginOutput(es);
diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index 7cac9d3..21054de 100644
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -1619,6 +1619,46 @@ static struct config_bool ConfigureNamesBool[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"cmdstatus_analyze", PGC_USERSET, STATS,
+			gettext_noop("Automatically instrument all queries for extraction of EXPLAIN ANALYZE plans with pg_cmdstatus() function."),
+			NULL,
+		},
+		&cmdstatus_analyze,
+		false,
+		NULL, NULL, NULL
+	},
+
+	{
+		{"cmdstatus_instrument_timer", PGC_USERSET, STATS,
+			gettext_noop("Automatically instrument all queries for timing, requires cmdstatus_analyze=on."),
+			NULL,
+		},
+		&cmdstatus_instrument_timer,
+		false,
+		NULL, NULL, NULL
+	},
+
+	{
+		{"cmdstatus_instrument_rows", PGC_USERSET, STATS,
+			gettext_noop("Automatically instrument all queries for tracking row counts, requires cmdstatus_analyze=on."),
+			NULL,
+		},
+		&cmdstatus_instrument_rows,
+		false,
+		NULL, NULL, NULL
+	},
+
+	{
+		{"cmdstatus_instrument_buffers", PGC_USERSET, STATS,
+			gettext_noop("Automatically instrument all queries for tracking buffers usage, requires cmdstatus_analyze=on."),
+			NULL,
+		},
+		&cmdstatus_instrument_buffers,
+		false,
+		NULL, NULL, NULL
+	},
+
 	/* End-of-list marker */
 	{
 		{NULL, 0, 0, NULL, NULL}, NULL, false, NULL, NULL, NULL
diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
index c33e585..a275f51 100644
--- a/src/backend/utils/misc/postgresql.conf.sample
+++ b/src/backend/utils/misc/postgresql.conf.sample
@@ -471,6 +471,13 @@
 #log_statement_stats = off
 
 
+# - Automatic Query Instrumentation -
+
+#cmdstatus_analyze = off
+#cmdstatus_instrument_timer = off
+#cmdstatus_instrument_rows = off
+#cmdstatus_instrument_buffers = off
+
 #------------------------------------------------------------------------------
 # AUTOVACUUM PARAMETERS
 #------------------------------------------------------------------------------
diff --git a/src/include/commands/explain.h b/src/include/commands/explain.h
index 26fcc5b..3334f41 100644
--- a/src/include/commands/explain.h
+++ b/src/include/commands/explain.h
@@ -35,6 +35,7 @@ typedef struct ExplainState
 	bool		timing;			/* print detailed node timing */
 	bool		summary;		/* print total planning and execution timing */
 	ExplainFormat format;		/* output format */
+	bool		running;		/* explain on a running statement */
 	/* other states */
 	PlannedStmt *pstmt;			/* top of plan */
 	List	   *rtable;			/* range table */
diff --git a/src/include/executor/instrument.h b/src/include/executor/instrument.h
index c9a2129..a18b089 100644
--- a/src/include/executor/instrument.h
+++ b/src/include/executor/instrument.h
@@ -68,6 +68,6 @@ extern PGDLLIMPORT BufferUsage pgBufferUsage;
 extern Instrumentation *InstrAlloc(int n, int instrument_options);
 extern void InstrStartNode(Instrumentation *instr);
 extern void InstrStopNode(Instrumentation *instr, double nTuples);
-extern void InstrEndLoop(Instrumentation *instr);
+extern void InstrEndLoop(Instrumentation *instr, bool partial_run);
 
 #endif   /* INSTRUMENT_H */
diff --git a/src/include/utils/cmdstatus.h b/src/include/utils/cmdstatus.h
index d6379f0..a9a508a 100644
--- a/src/include/utils/cmdstatus.h
+++ b/src/include/utils/cmdstatus.h
@@ -16,6 +16,10 @@
 #define CMD_STATUS_DEFAULT_INTERRUPT_TIMEOUT		10	/* milliseconds */
 
 extern int cmdstatus_interrupt_timeout;
+extern bool cmdstatus_analyze;
+extern bool cmdstatus_instrument_timer;
+extern bool cmdstatus_instrument_rows;
+extern bool cmdstatus_instrument_buffers;
 
 extern Size CmdStatusShmemSize(void);
 extern void CmdStatusShmemInit(void);

diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 32ac58f..2e3beaf 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -43,6 +43,7 @@
 #include "storage/procsignal.h"
 #include "storage/sinvaladt.h"
 #include "storage/spin.h"
+#include "utils/cmdstatus.h"
 
 
 shmem_startup_hook_type shmem_startup_hook = NULL;
@@ -139,6 +140,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, BTreeShmemSize());
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
+		size = add_size(size, CmdStatusShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -243,6 +245,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	ReplicationOriginShmemInit();
 	WalSndShmemInit();
 	WalRcvShmemInit();
+	CmdStatusShmemInit();
 
 	/*
 	 * Set up other modules that need some shared memory space
diff --git a/src/backend/storage/ipc/procsignal.c b/src/backend/storage/ipc/procsignal.c
index 0abde43..e637be1 100644
--- a/src/backend/storage/ipc/procsignal.c
+++ b/src/backend/storage/ipc/procsignal.c
@@ -26,6 +26,7 @@
 #include "storage/shmem.h"
 #include "storage/sinval.h"
 #include "tcop/tcopprot.h"
+#include "utils/cmdstatus.h"
 
 
 /*
@@ -296,6 +297,9 @@ procsignal_sigusr1_handler(SIGNAL_ARGS)
 	if (CheckProcSignal(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN))
 		RecoveryConflictInterrupt(PROCSIG_RECOVERY_CONFLICT_BUFFERPIN);
 
+	if (CheckProcSignal(PROCSIG_CMD_STATUS_INFO))
+		HandleCmdStatusInfoInterrupt();
+
 	if (set_latch_on_sigusr1)
 		SetLatch(MyLatch);
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index d917af3..1a5b03c 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -67,6 +67,7 @@
 #include "tcop/pquery.h"
 #include "tcop/tcopprot.h"
 #include "tcop/utility.h"
+#include "utils/cmdstatus.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/ps_status.h"
@@ -2991,6 +2992,9 @@ ProcessInterrupts(void)
 
 	if (ParallelMessagePending)
 		HandleParallelMessages();
+
+	if (CmdStatusInfoPending)
+		ProcessCmdStatusInfoRequest();
 }
 
 
diff --git a/src/backend/utils/adt/Makefile b/src/backend/utils/adt/Makefile
index 3ed0b44..2c8687c 100644
--- a/src/backend/utils/adt/Makefile
+++ b/src/backend/utils/adt/Makefile
@@ -18,7 +18,7 @@ endif
 # keep this list arranged alphabetically or it gets to be a mess
 OBJS = acl.o arrayfuncs.o array_expanded.o array_selfuncs.o \
 	array_typanalyze.o array_userfuncs.o arrayutils.o ascii.o \
-	bool.o cash.o char.o date.o datetime.o datum.o dbsize.o domains.o \
+	bool.o cash.o char.o cmdstatus.o date.o datetime.o datum.o dbsize.o domains.o \
 	encode.o enum.o expandeddatum.o \
 	float.o format_type.o formatting.o genfile.o \
 	geo_ops.o geo_selfuncs.o inet_cidr_ntop.o inet_net_pton.o int.o \
diff --git a/src/backend/utils/adt/cmdstatus.c b/src/backend/utils/adt/cmdstatus.c
new file mode 100644
index 0000000..5078100
--- /dev/null
+++ b/src/backend/utils/adt/cmdstatus.c
@@ -0,0 +1,791 @@
+/*-------------------------------------------------------------------------
+ *
+ * cmdstatus.c
+ *	  Definitions for pg_cmdstatus function.
+ *
+ * Copyright (c) 1996-2015, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/backend/utils/adt/cmdstatus.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "funcapi.h"
+#include "miscadmin.h"
+
+#include "access/htup_details.h"
+#include "commands/explain.h"
+#include "lib/stringinfo.h"
+#include "storage/dsm.h"
+#include "storage/ipc.h"
+#include "storage/latch.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "storage/procsignal.h"
+#include "storage/shm_mq.h"
+#include "storage/shm_toc.h"
+#include "tcop/dest.h"
+#include "tcop/pquery.h"
+#include "utils/builtins.h"
+#include "utils/cmdstatus.h"
+
+
+typedef enum {
+	CMD_STATUS_REQUEST_EXPLAIN = 1,
+	CMD_STATUS_REQUEST_QUERY_TEXT = 2,
+	CMD_STATUS_REQUEST_PROGRESS_TAG = 3,
+	CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE = 4
+} CmdStatusInfoRequestType;
+
+#define CMD_STATUS_MAX_REQUEST CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE
+
+typedef enum {
+	CMD_STATUS_RESULT_FAILURE = -1,
+	CMD_STATUS_RESULT_SUCCESS = 0,
+	CMD_STATUS_RESULT_BACKEND_IDLE,
+	CMD_STATUS_RESULT_NO_DATA
+} CmdStatusInfoResultCode;
+
+/*
+ * We allocate an array the size of NumCmdStatusSlots of DSM handles in the
+ * shared memory.  This slots array is indexed by backend ID, so each slot can
+ * corresponds to at max. one backend at any given time.
+ *
+ * In order to actually query some backend for its status, the interested
+ * process will create a DSM segment, initialize a table of contents in it,
+ * fill the target process id and request type and create a shared memory
+ * queue in the segment.
+ *
+ * The interested process will then put the such initialized DSM segment's
+ * handle in its own slot and send the SIGUSR1 with the reason
+ * PROCSIG_CMD_STATUS_INFO to the process being queried.  The interested
+ * process will wait for the response to be delivered via the shared memory
+ * queue and the result code via a field in the DSM segment.
+ *
+ * The layout of a DSM segment is given by the following TOC keys enumeration:
+ */
+typedef enum {
+	CmdStatusSlotKeyTargetProcessID,
+	CmdStatusSlotKeyIsProcessedFlag,
+	CmdStatusSlotKeyRequestType,
+	CmdStatusSlotKeyResultCode,
+	CmdStatusSlotKeyMemoryQueue,
+
+	CmdStatusTotalSlotKeys
+} CmdStatusSlotKey;
+
+#define NumCmdStatusSlots	MaxBackends
+
+#define PG_CMD_STATUS_INFO_MAGIC	0x79fb2449
+#define CMD_STATUS_BUFFER_SIZE		1024
+
+/*
+ * These structs are allocated on the program stack as local variables in the
+ * ExecutorRun hook.  The top of stack is current_query_stack, see below.
+ *
+ * Capturing the execution stack allows us to inspect the inner-most running
+ * query as well as showing the complete backtrace.
+ */
+typedef struct CmdInfoStack {
+	QueryDesc			   *query_desc;
+	struct CmdInfoStack	   *parent;
+} CmdInfoStack;
+
+
+int cmdstatus_interrupt_timeout = CMD_STATUS_DEFAULT_INTERRUPT_TIMEOUT;
+
+/* The array of slots pre-allocated on shared memory. */
+static volatile dsm_handle *CmdStatusSlots = NULL;
+
+/* Pointer into the slots array, to a slot assigned for this backend. */
+static volatile dsm_handle *MyCmdStatusSlot = NULL;
+
+static CmdInfoStack	   *current_query_stack = NULL;
+static int				query_stack_size = 0;  /* XXX not really used */
+
+static ExecutorRun_hook_type	prev_ExecutorRun = NULL;
+
+static void cmdstatus_ExecutorRun(QueryDesc *queryDesc,
+								  ScanDirection direction, long count);
+
+static void CleanupCmdStatusSlot(int status, Datum arg);
+static StringInfo ProcessCmdStatusSlot(CmdStatusInfoRequestType request_type,
+					 CmdStatusInfoResultCode *result_code);
+
+static StringInfo explain_query(QueryDesc *queryDesc);
+static void report_result_code(CmdStatusInfoResultCode result, pid_t target_pid);
+static void RestoreResourceOwner(ResourceOwner prevResourceOwner);
+
+
+Size
+CmdStatusShmemSize(void)
+{
+	return NumCmdStatusSlots * sizeof(dsm_handle);
+}
+
+void
+CmdStatusShmemInit(void)
+{
+	Size		size = CmdStatusShmemSize();
+	bool		found;
+
+	CmdStatusSlots = (dsm_handle *) ShmemInitStruct("CmdStatusSlots", size, &found);
+
+	if (!found)
+		MemSet(CmdStatusSlots, 0, size);
+}
+
+static void
+CleanupCmdStatusSlot(int status, Datum arg)
+{
+	Assert(MyCmdStatusSlot != NULL);
+
+	*MyCmdStatusSlot = 0;	/* just in case */
+
+	MyCmdStatusSlot = NULL;
+}
+
+/*
+ * CmdStatusInit
+ *		Initialize MyCmdStatusSlot
+ *
+ * The passed index should be MyBackendId.
+ */
+void
+CmdStatusInit(int css_idx)
+{
+	MyCmdStatusSlot = &CmdStatusSlots[css_idx - 1];
+
+	on_shmem_exit(CleanupCmdStatusSlot, (Datum) 0);
+
+	/* also install executor hooks */
+	prev_ExecutorRun = ExecutorRun_hook;
+	ExecutorRun_hook = cmdstatus_ExecutorRun;
+}
+
+/*
+ * The executor hook.
+ *
+ * Accumulates the query descriptors on the program stack and takes care of
+ * popping the current frame when leaving the function ab-/normally.
+ */
+static void
+cmdstatus_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, long count)
+{
+	CmdInfoStack	current;
+
+	current.query_desc = queryDesc;
+	current.parent = current_query_stack;
+
+	current_query_stack = &current;
+	query_stack_size++;
+
+	PG_TRY();
+	{
+		if (prev_ExecutorRun)
+			prev_ExecutorRun(queryDesc, direction, count);
+		else
+			standard_ExecutorRun(queryDesc, direction, count);
+
+		Assert(current_query_stack == &current);
+		Assert(query_stack_size > 0);
+
+		query_stack_size--;
+		current_query_stack = current.parent;
+	}
+	PG_CATCH();
+	{
+		Assert(current_query_stack == &current);
+		Assert(query_stack_size > 0);
+
+		query_stack_size--;
+		current_query_stack = current.parent;
+
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+}
+
+/* Produce an explain plan of a single query descriptor. */
+static StringInfo
+explain_query(QueryDesc *queryDesc)
+{
+	StringInfo		str;
+	ExplainState   *es;
+
+	es = NewExplainState();
+	es->analyze = false;
+	es->verbose = false;
+	es->buffers = false;
+	es->format = EXPLAIN_FORMAT_TEXT;
+
+	ExplainBeginOutput(es);
+	/* XXX: appendStringInfo(es->str, "#%d ", depth); ? */
+	ExplainQueryText(es, queryDesc);
+	ExplainPrintPlan(es, queryDesc);
+	ExplainEndOutput(es);
+
+	str = es->str;
+
+	pfree(es);
+	return str;
+}
+
+
+/* signal handler for PROCSIG_CMD_STATUS_INFO */
+void
+HandleCmdStatusInfoInterrupt(void)
+{
+	CmdStatusInfoPending = true;
+	InterruptPending = true;
+
+	SetLatch(MyLatch);
+}
+
+/* Produce a response and set the result code for a single slot. */
+static StringInfo
+ProcessCmdStatusSlot(CmdStatusInfoRequestType request_type,
+					 CmdStatusInfoResultCode *result_code)
+{
+	StringInfo		result = NULL;
+
+	/* Show some optimism, overwrite with error code later if needed. */
+	*result_code = CMD_STATUS_RESULT_SUCCESS;
+
+	if (ActivePortal)
+	{
+		switch (request_type)
+		{
+			case CMD_STATUS_REQUEST_EXPLAIN:
+				if (ActivePortal->queryDesc != NULL)
+					result = explain_query(ActivePortal->queryDesc);
+				else if (current_query_stack != NULL)
+					result = explain_query(current_query_stack->query_desc);
+				else
+					*result_code = CMD_STATUS_RESULT_NO_DATA;
+				break;
+
+			case CMD_STATUS_REQUEST_EXPLAIN_BACKTRACE:
+				{
+					StringInfo		str;
+					CmdInfoStack   *query;
+
+					result = makeStringInfo();
+
+					if (current_query_stack != NULL)
+					{
+						for (query = current_query_stack;
+							 query != NULL;
+							 query = query->parent)
+						{
+							str = explain_query(query->query_desc);
+							appendBinaryStringInfo(result, str->data, str->len);
+
+							pfree(str->data);
+							pfree(str);
+						}
+					}
+					else
+						*result_code = CMD_STATUS_RESULT_BACKEND_IDLE;
+					break;
+				}
+
+			case CMD_STATUS_REQUEST_QUERY_TEXT:
+				result = makeStringInfo();
+				appendStringInfoString(result, ActivePortal->sourceText);
+				break;
+
+			case CMD_STATUS_REQUEST_PROGRESS_TAG:
+				if (ActivePortal->commandTag != NULL)
+				{
+					result = makeStringInfo();
+
+					if (ActivePortal->queryDesc != NULL &&
+						ActivePortal->queryDesc->estate != NULL)
+					{
+						appendStringInfo(result, "%s %u",
+										 ActivePortal->commandTag,
+										 ActivePortal->queryDesc->estate->es_processed);
+					}
+					else
+					{
+						/* no progress available, at least show the command tag */
+						appendStringInfoString(result, ActivePortal->commandTag);
+					}
+				}
+				else
+					*result_code = CMD_STATUS_RESULT_NO_DATA;
+				break;
+		}
+	}
+	else
+		*result_code = CMD_STATUS_RESULT_BACKEND_IDLE;
+
+	return result;
+}
+
+static void
+RestoreResourceOwner(ResourceOwner prevResourceOwner)
+{
+	if (prevResourceOwner != CurrentResourceOwner)
+	{
+		ResourceOwner	res_owner = CurrentResourceOwner;
+
+		CurrentResourceOwner = prevResourceOwner;
+		ResourceOwnerDelete(res_owner);
+	}
+}
+
+/*
+ * Process all command status requests from other backends by scanning the
+ * whole array of slots looking for the requests targeted at us, which were
+ * not already processed by us during earlier rounds.
+ *
+ * Most of the times it is expected that the first valid slot we find is for
+ * us, so there's no penalty for actually attaching it and looking inside.
+ */
+void
+ProcessCmdStatusInfoRequest(void)
+{
+	MemoryContext	context = CurrentMemoryContext;
+	ResourceOwner	prevResourceOwner = CurrentResourceOwner;
+	struct timeval	tmleft;
+
+	tmleft.tv_sec = 0;
+	tmleft.tv_usec = cmdstatus_interrupt_timeout * 1000L;
+
+	/* Ensure valid resource owner for access to dsm. */
+	if (CurrentResourceOwner == NULL)
+		CurrentResourceOwner = ResourceOwnerCreate(NULL, "ProcessCmdStatusInfoRequest");
+
+	/*
+	 * We might have been signaled again by another process while handling a
+	 * request, so re-check after going through all the slots.
+	 */
+	while (CmdStatusInfoPending)
+	{
+		int		i;
+
+		CmdStatusInfoPending = false;
+
+		for (i = 0; i < NumCmdStatusSlots; i++)
+		{
+			dsm_handle slot = CmdStatusSlots[i];
+
+			if (slot != 0)
+			{
+				dsm_segment	   *seg = NULL;
+				shm_toc		   *toc = NULL;
+				pid_t		   *target_pid_ptr;
+				bool		   *is_processed_flag_ptr;
+				CmdStatusInfoRequestType   *request_type_ptr;
+				CmdStatusInfoResultCode	   *result_code_ptr;
+				shm_mq		   *mq;
+				shm_mq_handle  *output;
+				struct timeval		tmnow;
+				struct timeval		tmthen;
+				struct timeval		tmtemp;
+
+				seg = dsm_attach(slot);
+				if (seg == NULL)
+				{
+					elog(LOG, "unable to map dynamic memory segment for command status");
+					continue;
+				}
+
+				toc = shm_toc_attach(PG_CMD_STATUS_INFO_MAGIC, dsm_segment_address(seg));
+				if (toc == NULL)
+				{
+					elog(LOG, "bad magic in dynamic memory segment for command status");
+
+					dsm_detach(seg);
+					continue;
+				}
+
+				target_pid_ptr = (pid_t *)
+					shm_toc_lookup(toc, CmdStatusSlotKeyTargetProcessID);
+				is_processed_flag_ptr = (bool *)
+					shm_toc_lookup(toc, CmdStatusSlotKeyIsProcessedFlag);
+
+				if (*target_pid_ptr != MyProcPid || *is_processed_flag_ptr)
+				{
+					dsm_detach(seg);
+					continue;
+				}
+
+				/* Set the flag early to avoid re-processing during next round. */
+				*is_processed_flag_ptr = true;
+
+				request_type_ptr = (CmdStatusInfoRequestType *)
+					shm_toc_lookup(toc, CmdStatusSlotKeyRequestType);
+
+				result_code_ptr = (CmdStatusInfoResultCode *)
+					shm_toc_lookup(toc, CmdStatusSlotKeyResultCode);
+
+				mq = shm_toc_lookup(toc, CmdStatusSlotKeyMemoryQueue);
+				output = shm_mq_attach(mq, seg, NULL);
+
+				PG_TRY();
+				{
+					StringInfo		payload;
+					int				res;
+
+					payload = ProcessCmdStatusSlot(*request_type_ptr, result_code_ptr);
+					if (payload != NULL)
+					{
+						for (;;)
+						{
+							/* Send the data, including null terminator. */
+							res = shm_mq_send(output, payload->len + 1, payload->data, true);
+							if (res == SHM_MQ_SUCCESS)
+							{
+								break;
+							}
+							else if (res == SHM_MQ_DETACHED)
+							{
+								elog(LOG, "receiving backend has detached from the shared memory queue prematurely");
+								break;
+							}
+							else if (res == SHM_MQ_WOULD_BLOCK)
+							{
+								int		waitres;
+
+								gettimeofday(&tmthen, NULL);
+
+								waitres = WaitLatch(MyLatch, WL_LATCH_SET | WL_TIMEOUT,
+													tmleft.tv_usec / 1000L);
+								if (waitres & WL_TIMEOUT)
+								{
+									elog(LOG, "timeout while sending command status response");
+									break;
+								}
+
+								if (waitres & WL_LATCH_SET)
+									ResetLatch(MyLatch);
+
+								gettimeofday(&tmnow, NULL);
+
+								/* left = left + then - now */
+								timeradd(&tmleft, &tmthen, &tmtemp);
+								timersub(&tmtemp, &tmnow, &tmleft);
+
+								if (tmleft.tv_sec < 0)
+								{
+									tmleft.tv_sec = 0;
+									tmleft.tv_usec = 0;
+								}
+							}
+						}
+
+						pfree(payload->data);
+						pfree(payload);
+					}
+					/*
+					 * If there was no payload to be sent, we just detach from
+					 * the queue and the receiver should wake up.
+					 */
+
+					shm_mq_detach(mq);
+					dsm_detach(seg);
+				}
+				PG_CATCH();
+				{
+					/*
+					 * Detaching from the queue also wakes up the receiver, be
+					 * sure to update the slot status before detaching.
+					 */
+					shm_mq_detach(mq);
+					dsm_detach(seg);
+
+					MemoryContextSwitchTo(context);
+					PG_TRY();
+					{
+						ErrorData	   *edata = CopyErrorData();
+
+						/* XXX is there a way to just report the current ERROR with LOG instead, without making a copy first? */
+						elog(LOG, "an error occurred while processing command status request: %s",
+							 edata->message);
+
+						FreeErrorData(edata);
+						FlushErrorState();
+					}
+					PG_CATCH();
+					{
+						FlushErrorState();
+						MemoryContextSwitchTo(context);
+
+						elog(LOG, "out of memory while processing command status request");
+					}
+					PG_END_TRY();
+					continue;
+				}
+				PG_END_TRY();
+			}
+		}
+	}
+
+	RestoreResourceOwner(prevResourceOwner);
+}
+
+static void
+report_result_code(CmdStatusInfoResultCode result, pid_t target_pid)
+{
+	switch (result)
+	{
+		case CMD_STATUS_RESULT_SUCCESS:
+			/* nothing to report */
+			break;
+
+		case CMD_STATUS_RESULT_BACKEND_IDLE:
+			elog(INFO, "no command is currently running in backend with PID %d",
+				 target_pid);
+			break;
+
+		case CMD_STATUS_RESULT_NO_DATA:
+			elog(WARNING, "no suitable data found for the query in backend with PID %d",
+				 target_pid);
+			break;
+
+		default:
+			elog(ERROR, "general command status request failure when querying backend with PID %d",
+				 target_pid);
+			break;
+	}
+}
+
+/*
+ * Try to get status of a command running in another process.
+ *
+ * FUNCTION pg_cmdstatus(pid, request_type)
+ * RETURNS SETOF text
+ */
+Datum
+pg_cmdstatus(PG_FUNCTION_ARGS)
+{
+	ReturnSetInfo	   *rsinfo	= (ReturnSetInfo *) fcinfo->resultinfo;
+	Tuplestorestate	   *tupstore;
+	TupleDesc			tupdesc;
+	MemoryContext		per_query_ctx;
+	MemoryContext		oldcontext;
+	pid_t				target_pid = (pid_t) PG_GETARG_INT32(0);
+	int					request_type = PG_GETARG_INT32(1);
+	int					timeout = PG_GETARG_INT32(2);
+	PGPROC			   *target_proc;
+	shm_toc_estimator	estimator;
+	Size				segsize;
+	dsm_segment		   *seg;
+	shm_toc			   *toc;
+	pid_t			   *target_pid_ptr;
+	bool			   *is_processed_flag_ptr;
+	CmdStatusInfoRequestType   *request_type_ptr;
+	CmdStatusInfoResultCode	   *result_code_ptr;
+	shm_mq			   *mq;
+	shm_mq_handle	   *input;
+	struct timeval		tmnow;
+	struct timeval		tmthen;
+	struct timeval		tmtemp;
+	struct timeval		tmleft;
+
+	/* check to see if caller supports us returning a tuplestore */
+	if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("set-valued function called in context that cannot accept a set")));
+
+	if (!(rsinfo->allowedModes & SFRM_Materialize))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("materialize mode required, but it is not allowed in this context")));
+
+	if (request_type < 1 || request_type > CMD_STATUS_MAX_REQUEST)
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("unknown command status request")));
+
+	if (target_pid == MyProcPid)
+		ereport(ERROR,
+				(errmsg("backend cannot query command status of itself")));
+
+	/* verify access to target_pid */
+	target_proc = BackendPidGetProc(target_pid);
+
+	if (target_proc == NULL)
+		ereport(ERROR,
+				(errmsg("PID %d is not a PostgreSQL server process", target_pid)));
+
+	if (!(superuser() || target_proc->roleId == GetUserId()))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be superuser or have the same role to explain queries running in other server processes"))));
+
+	if (*MyCmdStatusSlot != 0)
+		ereport(ERROR,
+				(errmsg("pg_cmdstatus() call is already in progress")));
+
+	/* need to build tuplestore in query context */
+	per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+	oldcontext = MemoryContextSwitchTo(per_query_ctx);
+
+	tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc);
+	tupstore = tuplestore_begin_heap(false, false, work_mem);
+	MemoryContextSwitchTo(oldcontext);
+
+	/* prepare shared dsm segment */
+	shm_toc_initialize_estimator(&estimator);
+	shm_toc_estimate_keys(&estimator, CmdStatusTotalSlotKeys);
+	shm_toc_estimate_chunk(&estimator, sizeof(pid_t));
+	shm_toc_estimate_chunk(&estimator, sizeof(bool));
+	shm_toc_estimate_chunk(&estimator, sizeof(CmdStatusInfoRequestType));
+	shm_toc_estimate_chunk(&estimator, sizeof(CmdStatusInfoResultCode));
+	shm_toc_estimate_chunk(&estimator, CMD_STATUS_BUFFER_SIZE);
+	segsize = shm_toc_estimate(&estimator);
+
+	seg = dsm_create(segsize, 0);
+
+	toc = shm_toc_create(PG_CMD_STATUS_INFO_MAGIC, dsm_segment_address(seg), segsize);
+
+	target_pid_ptr = (pid_t *) shm_toc_allocate(toc, sizeof(pid_t));
+	*target_pid_ptr = target_pid;
+	shm_toc_insert(toc, CmdStatusSlotKeyTargetProcessID, target_pid_ptr);
+
+	is_processed_flag_ptr = (bool *) shm_toc_allocate(toc, sizeof(bool));
+	*is_processed_flag_ptr = false;
+	shm_toc_insert(toc, CmdStatusSlotKeyIsProcessedFlag, is_processed_flag_ptr);
+
+	request_type_ptr = (CmdStatusInfoRequestType *)
+		shm_toc_allocate(toc, sizeof(CmdStatusInfoRequestType));
+	*request_type_ptr = request_type;
+	shm_toc_insert(toc, CmdStatusSlotKeyRequestType, request_type_ptr);
+
+	result_code_ptr = (CmdStatusInfoResultCode *)
+		shm_toc_allocate(toc, sizeof(CmdStatusInfoResultCode));
+	*result_code_ptr = CMD_STATUS_RESULT_FAILURE;
+	shm_toc_insert(toc, CmdStatusSlotKeyResultCode, result_code_ptr);
+
+	mq = shm_mq_create(shm_toc_allocate(toc, CMD_STATUS_BUFFER_SIZE),
+					   CMD_STATUS_BUFFER_SIZE);
+	shm_toc_insert(toc, CmdStatusSlotKeyMemoryQueue, mq);
+
+	shm_mq_set_receiver(mq, MyProc);
+	shm_mq_set_sender(mq, target_proc);
+
+	PG_TRY();
+	{
+		shm_mq_result	res;
+		char		   *data = NULL;
+		Size			length;
+
+		input = shm_mq_attach(mq, seg, NULL);
+
+		*MyCmdStatusSlot = dsm_segment_handle(seg);
+
+		if (SendProcSignal(target_pid, PROCSIG_CMD_STATUS_INFO, target_proc->backendId))
+			elog(ERROR, "could not signal backend with PID %d", target_pid);
+
+		tmleft.tv_sec = timeout / 1000L;
+		tmleft.tv_usec = (timeout % 1000L) * 1000L;
+
+		for (;;)
+		{
+			/*
+			 * Read without blocking, otherwise cancel request or timeout
+			 * cannot be handled promptly.
+			 */
+			res = shm_mq_receive(input, &length, (void **) &data, true);
+			if (res == SHM_MQ_SUCCESS)
+			{
+				const char	   *p = data;
+
+				/* break into tuples on newline */
+				while (*p)
+				{
+					const char *q = strchr(p, '\n');
+					Size		len = q ? q - p : strlen(p);
+					Datum		value;
+					HeapTuple	tuple;
+					bool		isnull = false;
+
+					value = PointerGetDatum(cstring_to_text_with_len(p, len));
+
+					tuple = heap_form_tuple(tupdesc, &value, &isnull);
+					tuplestore_puttuple(tupstore, tuple);
+
+					if (!q)
+						break;
+
+					p += len + 1;
+				}
+			}
+			else if (res == SHM_MQ_DETACHED)
+			{
+				report_result_code(*result_code_ptr, target_pid);
+				break;
+			}
+			else if (res == SHM_MQ_WOULD_BLOCK)
+			{
+				int		waitres;
+				long	left_ms;
+
+				if (timeout)
+					gettimeofday(&tmthen, NULL);
+
+				/* Wait up to tmleft in ms (or 1 sec if timeout is not set). */
+				left_ms = timeout ? tmleft.tv_sec * 1000L + tmleft.tv_usec / 1000L : 1000L;
+
+				waitres = WaitLatch(MyLatch, WL_LATCH_SET | WL_TIMEOUT, left_ms);
+				if (timeout && (waitres & WL_TIMEOUT) != 0)
+				{
+					elog(INFO, "timeout waiting for reply from backend with PID %d",
+						 target_pid);
+					break;
+				}
+
+				CHECK_FOR_INTERRUPTS();
+				if (waitres & WL_LATCH_SET)
+					ResetLatch(MyLatch);
+
+				if (timeout)
+				{
+					gettimeofday(&tmnow, NULL);
+
+					/* left = left + then - now */
+					timeradd(&tmleft, &tmthen, &tmtemp);
+					timersub(&tmtemp, &tmnow, &tmleft);
+
+					if (tmleft.tv_sec < 0)
+					{
+						tmleft.tv_sec = 0;
+						tmleft.tv_usec = 0;
+					}
+				}
+			}
+		}
+
+		/* clean up and return the tuplestore */
+		tuplestore_donestoring(tupstore);
+
+		*MyCmdStatusSlot = 0;
+
+		shm_mq_detach(mq);
+		dsm_detach(seg);
+	}
+	PG_CATCH();
+	{
+		*MyCmdStatusSlot = 0;
+
+		shm_mq_detach(mq);
+		dsm_detach(seg);
+
+		PG_RE_THROW();
+	}
+	PG_END_TRY();
+
+	rsinfo->returnMode = SFRM_Materialize;
+	rsinfo->setResult = tupstore;
+	rsinfo->setDesc = tupdesc;
+
+	return (Datum) 0;
+}
diff --git a/src/backend/utils/init/globals.c b/src/backend/utils/init/globals.c
index 23e594e..2269853 100644
--- a/src/backend/utils/init/globals.c
+++ b/src/backend/utils/init/globals.c
@@ -29,6 +29,7 @@ ProtocolVersion FrontendProtocol;
 volatile bool InterruptPending = false;
 volatile bool QueryCancelPending = false;
 volatile bool ProcDiePending = false;
+volatile bool CmdStatusInfoPending = false;
 volatile bool ClientConnectionLost = false;
 volatile uint32 InterruptHoldoffCount = 0;
 volatile uint32 QueryCancelHoldoffCount = 0;
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 7b19714..7e7ba77 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -50,6 +50,7 @@
 #include "storage/smgr.h"
 #include "tcop/tcopprot.h"
 #include "utils/acl.h"
+#include "utils/cmdstatus.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
 #include "utils/memutils.h"
@@ -588,6 +589,9 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 	/* Now that we have a BackendId, we can participate in ProcSignal */
 	ProcSignalInit(MyBackendId);
 
+	/* Init CmdStatus slot */
+	CmdStatusInit(MyBackendId);
+
 	/*
 	 * Also set up timeout handlers needed for backend operation.  We need
 	 * these in every case except bootstrap.
diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index b3dac51..7cac9d3 100644
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -73,6 +73,7 @@
 #include "tsearch/ts_cache.h"
 #include "utils/builtins.h"
 #include "utils/bytea.h"
+#include "utils/cmdstatus.h"
 #include "utils/guc_tables.h"
 #include "utils/memutils.h"
 #include "utils/pg_locale.h"
@@ -2662,6 +2663,17 @@ static struct config_int ConfigureNamesInt[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"cmdstatus_interrupt_timeout", PGC_USERSET, STATS,
+			gettext_noop("Timeout for processing all pending command status requests."),
+			NULL,
+		 GUC_UNIT_MS /* min max */
+		},
+		&cmdstatus_interrupt_timeout,
+		CMD_STATUS_DEFAULT_INTERRUPT_TIMEOUT, 1, 1000,
+		NULL, NULL, NULL
+	},
+
 	/* End-of-list marker */
 	{
 		{NULL, 0, 0, NULL, NULL}, NULL, 0, 0, 0, NULL, NULL, NULL
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index ddf7c67..5edbfd0 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -3130,6 +3130,8 @@ DESCR("get OID of current session's temp schema, if any");
 DATA(insert OID = 2855 (  pg_is_other_temp_schema	PGNSP PGUID 12 1 0 0 0 f f f f t f s 1 0 16 "26" _null_ _null_ _null_ _null_ _null_ pg_is_other_temp_schema _null_ _null_ _null_ ));
 DESCR("is schema another session's temp schema?");
 
+DATA(insert OID = 4099 ( pg_cmdstatus		PGNSP PGUID 12 1 100 0 0 f f f f f t s 3 0 25 "23 23 23" _null_ _null_  _null_  _null_ _null_ pg_cmdstatus _null_ _null_ _null_ ));
+DESCR("returns information about another process");
 DATA(insert OID = 2171 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_cancel_backend _null_ _null_ _null_ ));
 DESCR("cancel a server process' current query");
 DATA(insert OID = 2096 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
diff --git a/src/include/miscadmin.h b/src/include/miscadmin.h
index e0cc69f..5f03f63 100644
--- a/src/include/miscadmin.h
+++ b/src/include/miscadmin.h
@@ -80,6 +80,7 @@
 extern PGDLLIMPORT volatile bool InterruptPending;
 extern PGDLLIMPORT volatile bool QueryCancelPending;
 extern PGDLLIMPORT volatile bool ProcDiePending;
+extern PGDLLIMPORT volatile bool CmdStatusInfoPending;
 
 extern volatile bool ClientConnectionLost;
 
diff --git a/src/include/storage/procsignal.h b/src/include/storage/procsignal.h
index af1a0cd..cd856e5 100644
--- a/src/include/storage/procsignal.h
+++ b/src/include/storage/procsignal.h
@@ -41,6 +41,8 @@ typedef enum
 	PROCSIG_RECOVERY_CONFLICT_BUFFERPIN,
 	PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK,
 
+	PROCSIG_CMD_STATUS_INFO,
+
 	NUM_PROCSIGNALS				/* Must be last! */
 } ProcSignalReason;
 
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
index fc1679e..605612e 100644
--- a/src/include/utils/builtins.h
+++ b/src/include/utils/builtins.h
@@ -1243,6 +1243,9 @@ extern Datum pg_identify_object_as_address(PG_FUNCTION_ARGS);
 /* catalog/objectaddress.c */
 extern Datum pg_get_object_address(PG_FUNCTION_ARGS);
 
+/* utils/adt/cmdstatus.c */
+extern Datum pg_cmdstatus(PG_FUNCTION_ARGS);
+
 /* commands/constraint.c */
 extern Datum unique_key_recheck(PG_FUNCTION_ARGS);
 
diff --git a/src/include/utils/cmdstatus.h b/src/include/utils/cmdstatus.h
new file mode 100644
index 0000000..d6379f0
--- /dev/null
+++ b/src/include/utils/cmdstatus.h
@@ -0,0 +1,27 @@
+/*-------------------------------------------------------------------------
+ *
+ * cmdstatus.h
+ *	  Declarations for command status interrupt handling.
+ *
+ *
+ * Portions Copyright (c) 1996-2015, PostgreSQL Global Development Group
+ *
+ * src/include/utils/cmdstatus.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CMDSTATUS_H
+#define CMDSTATUS_H
+
+#define CMD_STATUS_DEFAULT_INTERRUPT_TIMEOUT		10	/* milliseconds */
+
+extern int cmdstatus_interrupt_timeout;
+
+extern Size CmdStatusShmemSize(void);
+extern void CmdStatusShmemInit(void);
+extern void CmdStatusInit(int css_idx);
+
+extern void HandleCmdStatusInfoInterrupt(void);
+extern void ProcessCmdStatusInfoRequest(void);
+
+#endif   /* CMDSTATUS_H */

From 9f192d17e4674b2a042ca435ad5219f59722cd7a Mon Sep 17 00:00:00 2001
From: Oleksandr Shulgin <oleksandr.shulgin@zalando.de>
Date: Fri, 25 Sep 2015 17:29:34 +0200
Subject: [PATCH] Add auto_explain.publish_plans

This adds an optional feature to publish the plans of every query being
executed into per-backend dynamic shared memory segment.  The plans can then be
examined by other backends by use of newly added pg_explain_backend() function.
The process ID that is passed to the function must be this server's backend PID
and the caller must be either superuser or the same role that the other backend
is running under.

In order to support addition of the SQL-callable function, EXTENSION packaging
is provided for auto_explain.
---
 contrib/auto_explain/Makefile              |   2 +
 contrib/auto_explain/auto_explain--1.0.sql |  10 +
 contrib/auto_explain/auto_explain.c        | 326 ++++++++++++++++++++++++++---
 contrib/auto_explain/auto_explain.control  |   5 +
 4 files changed, 315 insertions(+), 28 deletions(-)
 create mode 100644 contrib/auto_explain/auto_explain--1.0.sql
 create mode 100644 contrib/auto_explain/auto_explain.control

diff --git a/contrib/auto_explain/Makefile b/contrib/auto_explain/Makefile
index fcf36c5..b6057a3 100644
--- a/contrib/auto_explain/Makefile
+++ b/contrib/auto_explain/Makefile
@@ -3,6 +3,8 @@
 MODULE_big = auto_explain
 OBJS = auto_explain.o $(WIN32RES)
 PGFILEDESC = "auto_explain - logging facility for execution plans"
+EXTENSION = auto_explain
+DATA = auto_explain--1.0.sql
 
 ifdef USE_PGXS
 PG_CONFIG = pg_config
diff --git a/contrib/auto_explain/auto_explain--1.0.sql b/contrib/auto_explain/auto_explain--1.0.sql
new file mode 100644
index 0000000..6059949
--- /dev/null
+++ b/contrib/auto_explain/auto_explain--1.0.sql
@@ -0,0 +1,10 @@
+/* contrib/auto_explain/auto_explain--1.0.sql */
+
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION auto_explain" to load this file. \quit
+
+-- Register functions.
+CREATE FUNCTION pg_explain_backend(INT)
+RETURNS SETOF TEXT
+AS 'MODULE_PATHNAME'
+LANGUAGE C;
diff --git a/contrib/auto_explain/auto_explain.c b/contrib/auto_explain/auto_explain.c
index 2a184ed..0fa123f 100644
--- a/contrib/auto_explain/auto_explain.c
+++ b/contrib/auto_explain/auto_explain.c
@@ -14,9 +14,18 @@
 
 #include <limits.h>
 
+#include "access/htup_details.h"
 #include "commands/explain.h"
 #include "executor/instrument.h"
+#include "miscadmin.h"
+#include "storage/dsm.h"
+#include "storage/ipc.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "storage/shmem.h"
 #include "utils/guc.h"
+#include "utils/builtins.h"
+#include "utils/memutils.h"
 
 PG_MODULE_MAGIC;
 
@@ -29,6 +38,7 @@ static bool auto_explain_log_triggers = false;
 static bool auto_explain_log_timing = true;
 static int	auto_explain_log_format = EXPLAIN_FORMAT_TEXT;
 static bool auto_explain_log_nested_statements = false;
+static bool auto_explain_publish_plans = false;
 
 static const struct config_enum_entry format_options[] = {
 	{"text", EXPLAIN_FORMAT_TEXT, false},
@@ -38,10 +48,23 @@ static const struct config_enum_entry format_options[] = {
 	{NULL, 0, false}
 };
 
+
+/* Shared memory structs */
+static dsm_handle *published_plan_handles = NULL;
+
+#define MaxPublishedPlans		MaxBackends
+#define explain_shmem_size()	(sizeof(dsm_handle) * MaxPublishedPlans)
+
+static dsm_segment	   *MyPublishedPlanSegment = NULL;
+static dsm_handle	   *MyPublishedPlanHandle = NULL;
+
+
 /* Current nesting depth of ExecutorRun calls */
 static int	nesting_level = 0;
 
 /* Saved hook values in case of unload */
+static shmem_startup_hook_type prev_shmem_startup_hook = NULL;
+
 static ExecutorStart_hook_type prev_ExecutorStart = NULL;
 static ExecutorRun_hook_type prev_ExecutorRun = NULL;
 static ExecutorFinish_hook_type prev_ExecutorFinish = NULL;
@@ -51,15 +74,28 @@ static ExecutorEnd_hook_type prev_ExecutorEnd = NULL;
 	(auto_explain_log_min_duration >= 0 && \
 	 (nesting_level == 0 || auto_explain_log_nested_statements))
 
+#define publish_explain_enabled() \
+	(auto_explain_publish_plans && \
+	 nesting_level == 0)	/* XXX what do we do with the nested statements? */
+
 void		_PG_init(void);
 void		_PG_fini(void);
 
+PG_FUNCTION_INFO_V1(pg_explain_backend);
+
+static void explain_shmem_startup(void);
+static void attach_published_plan_handles(void);
+
 static void explain_ExecutorStart(QueryDesc *queryDesc, int eflags);
 static void explain_ExecutorRun(QueryDesc *queryDesc,
 					ScanDirection direction,
 					long count);
 static void explain_ExecutorFinish(QueryDesc *queryDesc);
 static void explain_ExecutorEnd(QueryDesc *queryDesc);
+static StringInfo explain_query(QueryDesc *queryDesc);
+
+static void explain_publish_plan(QueryDesc *queryDesc);
+static void explain_unpublish_my_plan(void);
 
 
 /*
@@ -159,9 +195,26 @@ _PG_init(void)
 							 NULL,
 							 NULL);
 
+	DefineCustomBoolVariable("auto_explain.publish_plans",
+							 "Publish plan of every executed statement in shared memory.",
+							 NULL,
+							 &auto_explain_publish_plans,
+							 false,
+							 PGC_SUSET,
+							 0,
+							 NULL,
+							 NULL,
+							 NULL);
+
 	EmitWarningsOnPlaceholders("auto_explain");
 
+	if (auto_explain_publish_plans)
+		RequestAddinShmemSpace(explain_shmem_size());
+
 	/* Install hooks. */
+	prev_shmem_startup_hook = shmem_startup_hook;
+	shmem_startup_hook = explain_shmem_startup;
+
 	prev_ExecutorStart = ExecutorStart_hook;
 	ExecutorStart_hook = explain_ExecutorStart;
 	prev_ExecutorRun = ExecutorRun_hook;
@@ -183,8 +236,42 @@ _PG_fini(void)
 	ExecutorRun_hook = prev_ExecutorRun;
 	ExecutorFinish_hook = prev_ExecutorFinish;
 	ExecutorEnd_hook = prev_ExecutorEnd;
+
+	shmem_startup_hook = prev_shmem_startup_hook;
 }
 
+
+static void
+explain_shmem_startup(void)
+{
+	if (prev_shmem_startup_hook)
+		prev_shmem_startup_hook();
+
+	attach_published_plan_handles();
+}
+
+static void
+attach_published_plan_handles(void)
+{
+	bool		found;
+
+	if (auto_explain_publish_plans && published_plan_handles == NULL)
+	{
+		LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE);
+
+		published_plan_handles =
+			(dsm_handle *) ShmemInitStruct("auto_explain.published_plan_handles",
+										   explain_shmem_size(), &found);
+		if (!found)
+			MemSet(published_plan_handles, 0, explain_shmem_size());
+
+		MyPublishedPlanHandle = &published_plan_handles[MyBackendId];
+
+		LWLockRelease(AddinShmemInitLock);
+	}
+}
+
+
 /*
  * ExecutorStart hook: start up logging if needed
  */
@@ -234,6 +321,11 @@ explain_ExecutorStart(QueryDesc *queryDesc, int eflags)
 static void
 explain_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, long count)
 {
+	if (publish_explain_enabled())
+	{
+		explain_publish_plan(queryDesc);
+	}
+
 	nesting_level++;
 	PG_TRY();
 	{
@@ -257,6 +349,11 @@ explain_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, long count)
 static void
 explain_ExecutorFinish(QueryDesc *queryDesc)
 {
+	if (MyPublishedPlanSegment)
+	{
+		explain_unpublish_my_plan();
+	}
+
 	nesting_level++;
 	PG_TRY();
 	{
@@ -294,32 +391,7 @@ explain_ExecutorEnd(QueryDesc *queryDesc)
 		msec = queryDesc->totaltime->total * 1000.0;
 		if (msec >= auto_explain_log_min_duration)
 		{
-			ExplainState *es = NewExplainState();
-
-			es->analyze = (queryDesc->instrument_options && auto_explain_log_analyze);
-			es->verbose = auto_explain_log_verbose;
-			es->buffers = (es->analyze && auto_explain_log_buffers);
-			es->timing = (es->analyze && auto_explain_log_timing);
-			es->summary = es->analyze;
-			es->format = auto_explain_log_format;
-
-			ExplainBeginOutput(es);
-			ExplainQueryText(es, queryDesc);
-			ExplainPrintPlan(es, queryDesc);
-			if (es->analyze && auto_explain_log_triggers)
-				ExplainPrintTriggers(es, queryDesc);
-			ExplainEndOutput(es);
-
-			/* Remove last line break */
-			if (es->str->len > 0 && es->str->data[es->str->len - 1] == '\n')
-				es->str->data[--es->str->len] = '\0';
-
-			/* Fix JSON to output an object */
-			if (auto_explain_log_format == EXPLAIN_FORMAT_JSON)
-			{
-				es->str->data[0] = '{';
-				es->str->data[es->str->len - 1] = '}';
-			}
+			StringInfo		str = explain_query(queryDesc);
 
 			/*
 			 * Note: we rely on the existing logging of context or
@@ -329,10 +401,11 @@ explain_ExecutorEnd(QueryDesc *queryDesc)
 			 */
 			ereport(LOG,
 					(errmsg("duration: %.3f ms  plan:\n%s",
-							msec, es->str->data),
+							msec, str->data),
 					 errhidestmt(true)));
 
-			pfree(es->str->data);
+			pfree(str->data);
+			pfree(str);
 		}
 	}
 
@@ -341,3 +414,200 @@ explain_ExecutorEnd(QueryDesc *queryDesc)
 	else
 		standard_ExecutorEnd(queryDesc);
 }
+
+static StringInfo
+explain_query(QueryDesc *queryDesc)
+{
+	StringInfo		result;
+	ExplainState   *es = NewExplainState();
+
+	es->analyze = (queryDesc->instrument_options && auto_explain_log_analyze);
+	es->verbose = auto_explain_log_verbose;
+	es->buffers = (es->analyze && auto_explain_log_buffers);
+	es->timing = (es->analyze && auto_explain_log_timing);
+	es->summary = es->analyze;
+	es->format = auto_explain_log_format;
+
+	ExplainBeginOutput(es);
+	ExplainQueryText(es, queryDesc);
+	ExplainPrintPlan(es, queryDesc);
+	if (es->analyze && auto_explain_log_triggers)
+		ExplainPrintTriggers(es, queryDesc);
+	ExplainEndOutput(es);
+
+	/* Remove last line break */
+	if (es->str->len > 0 && es->str->data[es->str->len - 1] == '\n')
+		es->str->data[--es->str->len] = '\0';
+
+	/* Fix JSON to output an object */
+	if (auto_explain_log_format == EXPLAIN_FORMAT_JSON)
+	{
+		es->str->data[0] = '{';
+		es->str->data[es->str->len - 1] = '}';
+	}
+
+	result = es->str;
+	pfree(es);
+
+	return result;
+}
+
+static void
+explain_publish_plan(QueryDesc *queryDesc)
+{
+	StringInfo		str = explain_query(queryDesc);
+	dsm_segment	   *dsm;
+
+	attach_published_plan_handles();
+
+	dsm = dsm_create(str->len + 1, DSM_CREATE_NULL_IF_MAXSEGMENTS);
+	if (dsm)
+	{
+		char	   *buffer = (char *) dsm_segment_address(dsm);
+		dsm_handle	handle;
+
+		memcpy(buffer, str->data, str->len + 1);
+
+		MyPublishedPlanSegment = dsm;
+
+		handle = dsm_segment_handle(dsm);
+		*MyPublishedPlanHandle = handle;
+
+		elog(DEBUG5, "published explain plan in a DSM segment: %d", handle);
+	}
+	else
+		elog(LOG, "explain_publish_plan: out of dynamic shared memory, needed: %d",
+			 str->len + 1);
+
+	pfree(str->data);
+	pfree(str);
+}
+
+static void
+explain_unpublish_my_plan(void)
+{
+	Assert(MyPublishedPlanSegment);
+	Assert(MyPublishedPlanHandle);
+
+	elog(DEBUG5, "unpublishing explain plan in a DSM segment: %d", *MyPublishedPlanHandle);
+
+	*MyPublishedPlanHandle = 0;
+
+	dsm_detach(MyPublishedPlanSegment);
+	MyPublishedPlanSegment = NULL;
+}
+
+
+/*
+ * Retrieve the plan of a statement currently running in a server backend
+ * specified by the process ID.
+ *
+ * FUNCTION pg_explain_backend(pid)
+ * RETURNS SETOF text
+ */
+Datum
+pg_explain_backend(PG_FUNCTION_ARGS)
+{
+	ReturnSetInfo	   *rsinfo	= (ReturnSetInfo *) fcinfo->resultinfo;
+	Tuplestorestate	   *tupstore;
+	TupleDesc			tupdesc;
+	MemoryContext		per_query_ctx;
+	MemoryContext		oldcontext;
+	pid_t				target_pid = (pid_t) PG_GETARG_INT32(0);
+	PGPROC			   *target_proc;
+	dsm_handle			handle = 0;
+	dsm_segment		   *seg = NULL;
+
+	/* check to see if caller supports us returning a tuplestore */
+	if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("set-valued function called in context that cannot accept a set")));
+
+	if (!(rsinfo->allowedModes & SFRM_Materialize))
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("materialize mode required, but it is not allowed in this context")));
+
+	/* verify access to target_pid */
+	target_proc = BackendPidGetProc(target_pid);
+
+	if (target_proc == NULL)
+		ereport(ERROR,
+				(errmsg("PID %d is not a PostgreSQL server process", target_pid)));
+
+	if (!(superuser() || target_proc->roleId == GetUserId()))
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be superuser or have the same role to explain queries running in other server processes"))));
+
+	attach_published_plan_handles();
+	if (published_plan_handles == NULL)
+		ereport(ERROR,
+				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+				 errmsg("cannot attach to published plans shared memory"),
+				 errhint("is auto_explain.publish_plans turned on?")));
+
+	/* need to build tuplestore in query context */
+	per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+	oldcontext = MemoryContextSwitchTo(per_query_ctx);
+
+	tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc);
+	tupstore = tuplestore_begin_heap(false, false, work_mem);
+	MemoryContextSwitchTo(oldcontext);
+
+	if (target_pid == MyProcPid)
+	{
+		/* cannot attach to our own segment, but we know where to look */
+		seg = MyPublishedPlanSegment;
+	}
+	else
+	{
+		handle = published_plan_handles[target_proc->backendId];
+		seg =  dsm_attach(handle);
+	}
+	if (seg != NULL)
+	{
+		PG_TRY();
+		{
+			const char	   *p = (const char *) dsm_segment_address(seg);
+
+			/* break into tuples on newline */
+			while (*p)
+			{
+				const char *q = strchr(p, '\n');
+				Size		len = q ? q - p : strlen(p);
+				Datum		value;
+				HeapTuple	tuple;
+				bool		isnull = false;
+
+				value = PointerGetDatum(cstring_to_text_with_len(p, len));
+
+				tuple = heap_form_tuple(tupdesc, &value, &isnull);
+				tuplestore_puttuple(tupstore, tuple);
+
+				if (!q)
+					break;
+
+				p += len + 1;
+			}
+
+			/* detach DSM, but only if it's not our own one */
+			if (handle)
+				dsm_detach(seg);
+		}
+		PG_CATCH();
+		{
+			if (handle)
+				dsm_detach(seg);
+			PG_RE_THROW();
+		}
+		PG_END_TRY();
+	}
+
+	rsinfo->returnMode = SFRM_Materialize;
+	rsinfo->setResult = tupstore;
+	rsinfo->setDesc = tupdesc;
+
+	return (Datum) 0;
+}
diff --git a/contrib/auto_explain/auto_explain.control b/contrib/auto_explain/auto_explain.control
new file mode 100644
index 0000000..bd92c71
--- /dev/null
+++ b/contrib/auto_explain/auto_explain.control
@@ -0,0 +1,5 @@
+# auto_explain extension
+comment = 'logging facility for execution plans'
+default_version = '1.0'
+module_pathname = '$libdir/auto_explain'
+relocatable = true
-- 
2.1.4

From 9294995e200fca2abdccf0825ef852f26df1f4a2 Mon Sep 17 00:00:00 2001
From: Oleksandr Shulgin <oleksandr.shulgin@zalando.de>
Date: Mon, 28 Sep 2015 16:20:42 +0200
Subject: [PATCH 2/2] Add SHM table of contents to the explain DSM

By doing so we achieve two things:

1) verify the actual contents of the segment we've attached to, by
enforcing the magic number check;

2) transmit the actual size of the payload, so the receiving side can
allocate and parse in process-local memory, detaching from the DSM
early.
---
 contrib/auto_explain/auto_explain.c | 59 ++++++++++++++++++++++++++++++++-----
 1 file changed, 51 insertions(+), 8 deletions(-)

diff --git a/contrib/auto_explain/auto_explain.c b/contrib/auto_explain/auto_explain.c
index 0fa123f..ac6b750 100644
--- a/contrib/auto_explain/auto_explain.c
+++ b/contrib/auto_explain/auto_explain.c
@@ -23,6 +23,7 @@
 #include "storage/proc.h"
 #include "storage/procarray.h"
 #include "storage/shmem.h"
+#include "storage/shm_toc.h"
 #include "utils/guc.h"
 #include "utils/builtins.h"
 #include "utils/memutils.h"
@@ -48,6 +49,7 @@ static const struct config_enum_entry format_options[] = {
 	{NULL, 0, false}
 };
 
+#define PG_EXPLAIN_BACKEND_MAGIC	0x79fb2449
 
 /* Shared memory structs */
 static dsm_handle *published_plan_handles = NULL;
@@ -455,18 +457,40 @@ explain_query(QueryDesc *queryDesc)
 static void
 explain_publish_plan(QueryDesc *queryDesc)
 {
-	StringInfo		str = explain_query(queryDesc);
+	StringInfo		str;
+	Size			plan_size;
+	shm_toc_estimator	toc_estimator;
+	Size				seg_size;
 	dsm_segment	   *dsm;
+	shm_toc		   *toc = NULL;
 
 	attach_published_plan_handles();
 
-	dsm = dsm_create(str->len + 1, DSM_CREATE_NULL_IF_MAXSEGMENTS);
+	str = explain_query(queryDesc);
+	plan_size = str->len + 1;
+
+	shm_toc_initialize_estimator(&toc_estimator);
+	shm_toc_estimate_keys(&toc_estimator, 2);	/* size, plan */
+	shm_toc_estimate_chunk(&toc_estimator, sizeof(Size));
+	shm_toc_estimate_chunk(&toc_estimator, plan_size);
+	seg_size = shm_toc_estimate(&toc_estimator);
+
+	dsm = dsm_create(seg_size, DSM_CREATE_NULL_IF_MAXSEGMENTS);
 	if (dsm)
 	{
-		char	   *buffer = (char *) dsm_segment_address(dsm);
+		Size	   *size_ptr;
+		char	   *buffer;
 		dsm_handle	handle;
 
-		memcpy(buffer, str->data, str->len + 1);
+		toc = shm_toc_create(PG_EXPLAIN_BACKEND_MAGIC, dsm_segment_address(dsm), seg_size);
+
+		size_ptr = (Size *) shm_toc_allocate(toc, sizeof(Size));
+		*size_ptr = plan_size;
+		shm_toc_insert(toc, 0, size_ptr);
+
+		buffer = (char *) shm_toc_allocate(toc, plan_size);
+		memcpy(buffer, str->data, plan_size);
+		shm_toc_insert(toc, 1, buffer);
 
 		MyPublishedPlanSegment = dsm;
 
@@ -570,9 +594,30 @@ pg_explain_backend(PG_FUNCTION_ARGS)
 	{
 		PG_TRY();
 		{
-			const char	   *p = (const char *) dsm_segment_address(seg);
+			shm_toc		   *toc;
+			Size			plan_size;
+			char		   *buffer;
+			const char	   *p;
+
+			toc = shm_toc_attach(PG_EXPLAIN_BACKEND_MAGIC, dsm_segment_address(seg));
+			if (toc == NULL)
+				ereport(ERROR,
+						(errmsg("bad magic in dynamic memory segment")));
+
+			plan_size = *((Size *) shm_toc_lookup(toc, 0));
+
+			buffer = palloc(plan_size);
+			memcpy(buffer, shm_toc_lookup(toc, 1), plan_size);
+
+			/* we can detach DSM already, but only if it's not our own one */
+			if (handle)
+			{
+				handle = 0;		/* avoid possible extra detach in PG_CATCH */
+				dsm_detach(seg);
+			}
 
 			/* break into tuples on newline */
+			p = buffer;
 			while (*p)
 			{
 				const char *q = strchr(p, '\n');
@@ -592,9 +637,7 @@ pg_explain_backend(PG_FUNCTION_ARGS)
 				p += len + 1;
 			}
 
-			/* detach DSM, but only if it's not our own one */
-			if (handle)
-				dsm_detach(seg);
+			pfree(buffer);
 		}
 		PG_CATCH();
 		{
-- 
2.1.4