Optional message to user when terminating/cancelling backend

From b937d85e470fd1490246f0db2890a3b8b08457c3 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Sun, 18 Jun 2017 09:00:52 +0200
Subject: [PATCH] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend() or
pg_cancel_backend() to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed process. The new syntax is overloaded
as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);
---
 doc/src/sgml/func.sgml                  |   6 +-
 src/backend/storage/ipc/ipci.c          |   3 +
 src/backend/tcop/postgres.c             |  38 ++++++-
 src/backend/utils/adt/misc.c            |  60 ++++++++--
 src/backend/utils/init/postinit.c       |   2 +
 src/backend/utils/misc/Makefile         |   6 +-
 src/backend/utils/misc/backend_cancel.c | 189 ++++++++++++++++++++++++++++++++
 src/include/catalog/pg_proc.h           |   4 +
 src/include/utils/backend_cancel.h      |  25 +++++
 9 files changed, 314 insertions(+), 19 deletions(-)
 create mode 100644 src/backend/utils/misc/backend_cancel.c
 create mode 100644 src/include/utils/backend_cancel.h

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index e073f7b57c..4e4d0f1ad6 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18330,7 +18330,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</> [, <parameter>message</parameter> <type>text</>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18355,7 +18355,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</> [, <parameter>message</parameter> <type>text</>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18386,6 +18386,8 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, the text
+    will be appended to the error message returned to the signalled backend.
    </para>
 
    <para>
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 2d1ed143e0..f998ee82d3 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -44,6 +44,7 @@
 #include "storage/procsignal.h"
 #include "storage/sinvaladt.h"
 #include "storage/spin.h"
+#include "utils/backend_cancel.h"
 #include "utils/backend_random.h"
 #include "utils/snapmgr.h"
 
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, CancelBackendMsgShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendCancelShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index b8d860ebdb..b3135927d0 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -69,6 +69,7 @@
 #include "tcop/pquery.h"
 #include "tcop/tcopprot.h"
 #include "tcop/utility.h"
+#include "utils/backend_cancel.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/ps_status.h"
@@ -2879,9 +2880,22 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasCancelMessage())
+			{
+				char   *buffer = palloc0(MAX_CANCEL_MSG);
+
+				GetCancelMessage(&buffer, MAX_CANCEL_MSG);
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command: \"%s\"",
+						 buffer)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -2994,9 +3008,21 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasCancelMessage())
+			{
+				char   *buffer = palloc0(MAX_CANCEL_MSG);
+
+				GetCancelMessage(&buffer, MAX_CANCEL_MSG);
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request: \"%s\"",
+								buffer)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index 62341b84d1..38d4fd8ad9 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -41,6 +41,7 @@
 #include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
 #include "utils/acl.h"
+#include "utils/backend_cancel.h"
 #include "utils/builtins.h"
 #include "utils/timestamp.h"
 
@@ -216,7 +217,7 @@ current_query(PG_FUNCTION_ARGS)
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -248,6 +249,18 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+	{
+		int		r;
+
+		r = SetBackendCancelMessage(pid, msg);
+
+		if (r != -1 && r != strlen(msg))
+			ereport(NOTICE,
+					(errmsg("message is too long and has been truncated")));
+	}
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -278,10 +291,10 @@ pg_signal_backend(int pid, int sig)
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
+static bool
+pg_cancel_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -296,16 +309,32 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
 }
 
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_cancel_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_cancel_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid = PG_GETARG_INT32(0);
+	char 	   *msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_cancel_backend_internal(pid, msg));
+}
+
+
 /*
  * Signal to terminate a backend process.  This is allowed if you are a member
  * of the role whose process is being terminated.
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
+static bool
+pg_terminate_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -317,7 +346,22 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
+}
+
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_terminate_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_terminate_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid = PG_GETARG_INT32(0);
+	char 	   *msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_terminate_backend_internal(pid, msg));
 }
 
 /*
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index eb6960d93f..c2abaf34ee 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/backend_cancel.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
 #include "utils/memutils.h"
@@ -740,6 +741,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendCancelInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/backend/utils/misc/Makefile b/src/backend/utils/misc/Makefile
index a53fcdf188..619c837e08 100644
--- a/src/backend/utils/misc/Makefile
+++ b/src/backend/utils/misc/Makefile
@@ -14,9 +14,9 @@ include $(top_builddir)/src/Makefile.global
 
 override CPPFLAGS := -I. -I$(srcdir) $(CPPFLAGS)
 
-OBJS = backend_random.o guc.o help_config.o pg_config.o pg_controldata.o \
-       pg_rusage.o ps_status.o queryenvironment.o rls.o sampling.o \
-       superuser.o timeout.o tzparser.o
+OBJS = backend_cancel.o backend_random.o guc.o help_config.o pg_config.o \
+       pg_controldata.o pg_rusage.o ps_status.o queryenvironment.o rls.o \
+	   sampling.o superuser.o timeout.o tzparser.o
 
 # This location might depend on the installation directories. Therefore
 # we can't substitute it into pg_config.h.
diff --git a/src/backend/utils/misc/backend_cancel.c b/src/backend/utils/misc/backend_cancel.c
new file mode 100644
index 0000000000..194554eab2
--- /dev/null
+++ b/src/backend/utils/misc/backend_cancel.c
@@ -0,0 +1,189 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_cancel.c
+ *	  Backend cancellation messaging
+ *
+ *
+ * Module for supporting passing a user defined message to a cancelled,
+ * or terminated, backend from the user/administrator.
+ *
+ * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/utils/misc/backend_cancel.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "miscadmin.h"
+#include "storage/ipc.h"
+#include "storage/spin.h"
+#include "storage/shmem.h"
+#include "utils/backend_cancel.h"
+
+/*
+ * Each backend is registered per pid in the array which is indexed by Backend
+ * ID. Reading and writing the message is protected by a per-slot spinlock.
+ */
+typedef struct
+{
+	pid_t	pid;
+	slock_t	mutex;
+	char	message[MAX_CANCEL_MSG];
+	int		len;
+} BackendCancelShmemStruct;
+
+static BackendCancelShmemStruct	*BackendCancelSlots = NULL;
+static volatile BackendCancelShmemStruct *MyCancelSlot = NULL;
+
+static void CleanupCancelBackend(int status, Datum argument);
+
+Size
+CancelBackendMsgShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendCancelShmemStruct);
+}
+
+void
+BackendCancelShmemInit(void)
+{
+	Size	size = CancelBackendMsgShmemSize();
+	bool	found;
+	int		i;
+
+	BackendCancelSlots = (BackendCancelShmemStruct *)
+		ShmemInitStruct("BackendCancelSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendCancelSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendCancelSlots[i].mutex));
+	}
+}
+
+void
+BackendCancelInit(int backend_id)
+{
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->len = 0;
+	slot->pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupCancelBackend, Int32GetDatum(backend_id));
+}
+
+static void
+CleanupCancelBackend(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->len > 0)
+		slot->message[0] = '\0';
+
+	slot->len = 0;
+	slot->pid = 0;
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns the length of message actually created. If the returned length
+ * is less than the length of the message parameter, truncation has occurred.
+ * If the backend wasn't found and no message was set, -1 is returned. If two
+ * backends collide in setting a message, the existing message will be
+ * overwritten by the last one in.
+ */
+int
+SetBackendCancelMessage(pid_t backend, char *message)
+{
+	BackendCancelShmemStruct *slot;
+	int		i;
+	int		message_len;
+
+	if (!message)
+		return 0;
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		slot = &BackendCancelSlots[i];
+
+		if (slot->pid != 0 && slot->pid == backend)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->pid != backend)
+			{
+				SpinLockRelease(&slot->mutex);
+				goto error;
+			}
+
+			strlcpy(slot->message, message, sizeof(slot->message));
+			slot->len = strlen(slot->message);
+			message_len = slot->len;
+			SpinLockRelease(&slot->mutex);
+
+			return message_len;
+		}
+	}
+
+error:
+
+	elog(LOG, "Cancellation message requested for missing backend %d by %d",
+		 (int) backend, MyProcPid);
+
+	return -1;
+}
+
+bool
+HasCancelMessage(void)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = (slot->len > 0);
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * Return the configured cancellation message and its length. If the returned
+ * length is greater than the size of the passed buffer, truncation has been
+ * performed. The message is cleared on reading.
+ */
+int
+GetCancelMessage(char **buffer, size_t buf_len)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->len > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(*buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->len;
+		slot->len = 0;
+		slot->message[0] = '\0';
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index 1191b4ab1b..1b2bc18ff7 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -3203,8 +3203,12 @@ DESCR("is schema another session's temp schema?");
 
 DATA(insert OID = 2171 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v s 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 = 772 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_cancel_backend_msg _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 s 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
 DESCR("terminate a server process");
+DATA(insert OID = 972 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend_msg _null_ _null_ _null_ ));
+DESCR("terminate a server process");
 DATA(insert OID = 2172 ( pg_start_backup		PGNSP PGUID 12 1 0 0 0 f f f f t f v r 3 0 3220 "25 16 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 r 0 0 3220 "" _null_ _null_ _null_ _null_ _null_ pg_stop_backup _null_ _null_ _null_ ));
diff --git a/src/include/utils/backend_cancel.h b/src/include/utils/backend_cancel.h
new file mode 100644
index 0000000000..7f210553d6
--- /dev/null
+++ b/src/include/utils/backend_cancel.h
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_cancel.h
+ *		Declarations for backend cancellation messaging
+ *
+ * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
+ *
+ *	  src/include/utils/backend_cancel.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BACKEND_CANCEL_H
+#define BACKEND_CANCEL_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size CancelBackendMsgShmemSize(void);
+extern void BackendCancelShmemInit(void);
+extern void BackendCancelInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern bool HasCancelMessage(void);
+extern int GetCancelMessage(char **msg, size_t len);
+
+#endif /* BACKEND_CANCEL_H */
-- 
2.13.0.rc0.45.ge2cb6ab.dirty

From ef476fe12f0d2c5255770f75bd7dd62831e37229 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Sun, 3 Sep 2017 22:43:16 +0200
Subject: [PATCH] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend() or
pg_cancel_backend() to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
overloaded the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);
---
 doc/src/sgml/func.sgml                  |   6 +-
 src/backend/storage/ipc/ipci.c          |   3 +
 src/backend/tcop/postgres.c             |  38 ++++++-
 src/backend/utils/adt/misc.c            |  60 ++++++++--
 src/backend/utils/init/postinit.c       |   2 +
 src/backend/utils/misc/Makefile         |   6 +-
 src/backend/utils/misc/backend_cancel.c | 189 ++++++++++++++++++++++++++++++++
 src/include/catalog/pg_proc.h           |   4 +
 src/include/utils/backend_cancel.h      |  25 +++++
 9 files changed, 314 insertions(+), 19 deletions(-)
 create mode 100644 src/backend/utils/misc/backend_cancel.c
 create mode 100644 src/include/utils/backend_cancel.h

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 641b3b8f4e..ecde80aad2 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18359,7 +18359,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</> [, <parameter>message</parameter> <type>text</>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18384,7 +18384,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</> [, <parameter>message</parameter> <type>text</>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18415,6 +18415,8 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, the text
+    will be appended to the error message returned to the signalled backend.
    </para>
 
    <para>
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 2d1ed143e0..f998ee82d3 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -44,6 +44,7 @@
 #include "storage/procsignal.h"
 #include "storage/sinvaladt.h"
 #include "storage/spin.h"
+#include "utils/backend_cancel.h"
 #include "utils/backend_random.h"
 #include "utils/snapmgr.h"
 
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, CancelBackendMsgShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendCancelShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 8d3fecf6d6..248cd84ee5 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -69,6 +69,7 @@
 #include "tcop/pquery.h"
 #include "tcop/tcopprot.h"
 #include "tcop/utility.h"
+#include "utils/backend_cancel.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/ps_status.h"
@@ -2879,9 +2880,22 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasCancelMessage())
+			{
+				char   *buffer = palloc0(MAX_CANCEL_MSG);
+
+				GetCancelMessage(&buffer, MAX_CANCEL_MSG);
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command: \"%s\"",
+						 buffer)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -2994,9 +3008,21 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasCancelMessage())
+			{
+				char   *buffer = palloc0(MAX_CANCEL_MSG);
+
+				GetCancelMessage(&buffer, MAX_CANCEL_MSG);
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request: \"%s\"",
+								buffer)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index 62341b84d1..38d4fd8ad9 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -41,6 +41,7 @@
 #include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
 #include "utils/acl.h"
+#include "utils/backend_cancel.h"
 #include "utils/builtins.h"
 #include "utils/timestamp.h"
 
@@ -216,7 +217,7 @@ current_query(PG_FUNCTION_ARGS)
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -248,6 +249,18 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+	{
+		int		r;
+
+		r = SetBackendCancelMessage(pid, msg);
+
+		if (r != -1 && r != strlen(msg))
+			ereport(NOTICE,
+					(errmsg("message is too long and has been truncated")));
+	}
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -278,10 +291,10 @@ pg_signal_backend(int pid, int sig)
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
+static bool
+pg_cancel_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -296,16 +309,32 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
 }
 
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_cancel_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_cancel_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid = PG_GETARG_INT32(0);
+	char 	   *msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_cancel_backend_internal(pid, msg));
+}
+
+
 /*
  * Signal to terminate a backend process.  This is allowed if you are a member
  * of the role whose process is being terminated.
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
+static bool
+pg_terminate_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -317,7 +346,22 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
+}
+
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_terminate_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_terminate_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid = PG_GETARG_INT32(0);
+	char 	   *msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_terminate_backend_internal(pid, msg));
 }
 
 /*
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index eb6960d93f..c2abaf34ee 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/backend_cancel.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
 #include "utils/memutils.h"
@@ -740,6 +741,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendCancelInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/backend/utils/misc/Makefile b/src/backend/utils/misc/Makefile
index a53fcdf188..619c837e08 100644
--- a/src/backend/utils/misc/Makefile
+++ b/src/backend/utils/misc/Makefile
@@ -14,9 +14,9 @@ include $(top_builddir)/src/Makefile.global
 
 override CPPFLAGS := -I. -I$(srcdir) $(CPPFLAGS)
 
-OBJS = backend_random.o guc.o help_config.o pg_config.o pg_controldata.o \
-       pg_rusage.o ps_status.o queryenvironment.o rls.o sampling.o \
-       superuser.o timeout.o tzparser.o
+OBJS = backend_cancel.o backend_random.o guc.o help_config.o pg_config.o \
+       pg_controldata.o pg_rusage.o ps_status.o queryenvironment.o rls.o \
+	   sampling.o superuser.o timeout.o tzparser.o
 
 # This location might depend on the installation directories. Therefore
 # we can't substitute it into pg_config.h.
diff --git a/src/backend/utils/misc/backend_cancel.c b/src/backend/utils/misc/backend_cancel.c
new file mode 100644
index 0000000000..194554eab2
--- /dev/null
+++ b/src/backend/utils/misc/backend_cancel.c
@@ -0,0 +1,189 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_cancel.c
+ *	  Backend cancellation messaging
+ *
+ *
+ * Module for supporting passing a user defined message to a cancelled,
+ * or terminated, backend from the user/administrator.
+ *
+ * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/utils/misc/backend_cancel.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "miscadmin.h"
+#include "storage/ipc.h"
+#include "storage/spin.h"
+#include "storage/shmem.h"
+#include "utils/backend_cancel.h"
+
+/*
+ * Each backend is registered per pid in the array which is indexed by Backend
+ * ID. Reading and writing the message is protected by a per-slot spinlock.
+ */
+typedef struct
+{
+	pid_t	pid;
+	slock_t	mutex;
+	char	message[MAX_CANCEL_MSG];
+	int		len;
+} BackendCancelShmemStruct;
+
+static BackendCancelShmemStruct	*BackendCancelSlots = NULL;
+static volatile BackendCancelShmemStruct *MyCancelSlot = NULL;
+
+static void CleanupCancelBackend(int status, Datum argument);
+
+Size
+CancelBackendMsgShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendCancelShmemStruct);
+}
+
+void
+BackendCancelShmemInit(void)
+{
+	Size	size = CancelBackendMsgShmemSize();
+	bool	found;
+	int		i;
+
+	BackendCancelSlots = (BackendCancelShmemStruct *)
+		ShmemInitStruct("BackendCancelSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendCancelSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendCancelSlots[i].mutex));
+	}
+}
+
+void
+BackendCancelInit(int backend_id)
+{
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->len = 0;
+	slot->pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupCancelBackend, Int32GetDatum(backend_id));
+}
+
+static void
+CleanupCancelBackend(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->len > 0)
+		slot->message[0] = '\0';
+
+	slot->len = 0;
+	slot->pid = 0;
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns the length of message actually created. If the returned length
+ * is less than the length of the message parameter, truncation has occurred.
+ * If the backend wasn't found and no message was set, -1 is returned. If two
+ * backends collide in setting a message, the existing message will be
+ * overwritten by the last one in.
+ */
+int
+SetBackendCancelMessage(pid_t backend, char *message)
+{
+	BackendCancelShmemStruct *slot;
+	int		i;
+	int		message_len;
+
+	if (!message)
+		return 0;
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		slot = &BackendCancelSlots[i];
+
+		if (slot->pid != 0 && slot->pid == backend)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->pid != backend)
+			{
+				SpinLockRelease(&slot->mutex);
+				goto error;
+			}
+
+			strlcpy(slot->message, message, sizeof(slot->message));
+			slot->len = strlen(slot->message);
+			message_len = slot->len;
+			SpinLockRelease(&slot->mutex);
+
+			return message_len;
+		}
+	}
+
+error:
+
+	elog(LOG, "Cancellation message requested for missing backend %d by %d",
+		 (int) backend, MyProcPid);
+
+	return -1;
+}
+
+bool
+HasCancelMessage(void)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = (slot->len > 0);
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * Return the configured cancellation message and its length. If the returned
+ * length is greater than the size of the passed buffer, truncation has been
+ * performed. The message is cleared on reading.
+ */
+int
+GetCancelMessage(char **buffer, size_t buf_len)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->len > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(*buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->len;
+		slot->len = 0;
+		slot->message[0] = '\0';
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index d820b56aa1..ceeb85e13d 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -3247,8 +3247,12 @@ DESCR("is schema another session's temp schema?");
 
 DATA(insert OID = 2171 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v s 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 = 3438 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_cancel_backend_msg _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 s 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
 DESCR("terminate a server process");
+DATA(insert OID = 3437 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend_msg _null_ _null_ _null_ ));
+DESCR("terminate a server process");
 DATA(insert OID = 2172 ( pg_start_backup		PGNSP PGUID 12 1 0 0 0 f f f f t f v r 3 0 3220 "25 16 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 r 0 0 3220 "" _null_ _null_ _null_ _null_ _null_ pg_stop_backup _null_ _null_ _null_ ));
diff --git a/src/include/utils/backend_cancel.h b/src/include/utils/backend_cancel.h
new file mode 100644
index 0000000000..7f210553d6
--- /dev/null
+++ b/src/include/utils/backend_cancel.h
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_cancel.h
+ *		Declarations for backend cancellation messaging
+ *
+ * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
+ *
+ *	  src/include/utils/backend_cancel.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BACKEND_CANCEL_H
+#define BACKEND_CANCEL_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size CancelBackendMsgShmemSize(void);
+extern void BackendCancelShmemInit(void);
+extern void BackendCancelInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern bool HasCancelMessage(void);
+extern int GetCancelMessage(char **msg, size_t len);
+
+#endif /* BACKEND_CANCEL_H */
-- 
2.14.1.145.gb3622a4ee

From d88202f36d66d8bfe88fa34967ed23a2d2eade4a Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Wed, 24 Jan 2018 12:22:20 +0100
Subject: [PATCH] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend() or
pg_cancel_backend() to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
overloaded the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);
---
 doc/src/sgml/func.sgml                  |   6 +-
 src/backend/storage/ipc/ipci.c          |   3 +
 src/backend/tcop/postgres.c             |  38 ++++++-
 src/backend/utils/adt/misc.c            |  52 +++++++--
 src/backend/utils/init/postinit.c       |   2 +
 src/backend/utils/misc/Makefile         |   6 +-
 src/backend/utils/misc/backend_cancel.c | 195 ++++++++++++++++++++++++++++++++
 src/include/catalog/pg_proc.h           |   4 +
 src/include/utils/backend_cancel.h      |  25 ++++
 9 files changed, 312 insertions(+), 19 deletions(-)
 create mode 100644 src/backend/utils/misc/backend_cancel.c
 create mode 100644 src/include/utils/backend_cancel.h

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 487c7ff750..91f58eac55 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18381,7 +18381,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18406,7 +18406,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18437,6 +18437,8 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, the text
+    will be appended to the error message returned to the signalled backend.
    </para>
 
    <para>
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 0c86a581c0..4e21d0f47b 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -44,6 +44,7 @@
 #include "storage/procsignal.h"
 #include "storage/sinvaladt.h"
 #include "storage/spin.h"
+#include "utils/backend_cancel.h"
 #include "utils/backend_random.h"
 #include "utils/snapmgr.h"
 
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, CancelBackendMsgShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendCancelShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index ddc3ec860a..165ea0f906 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -69,6 +69,7 @@
 #include "tcop/pquery.h"
 #include "tcop/tcopprot.h"
 #include "tcop/utility.h"
+#include "utils/backend_cancel.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/ps_status.h"
@@ -2918,9 +2919,22 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasCancelMessage())
+			{
+				char   *buffer = palloc0(MAX_CANCEL_MSG);
+
+				GetCancelMessage(&buffer, MAX_CANCEL_MSG);
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command: \"%s\"",
+						 buffer)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3031,9 +3045,21 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasCancelMessage())
+			{
+				char   *buffer = palloc0(MAX_CANCEL_MSG);
+
+				GetCancelMessage(&buffer, MAX_CANCEL_MSG);
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request: \"%s\"",
+								buffer)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index 2e1e020c4b..30ac42fd99 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -42,6 +42,7 @@
 #include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
 #include "utils/acl.h"
+#include "utils/backend_cancel.h"
 #include "utils/builtins.h"
 #include "utils/timestamp.h"
 
@@ -217,7 +218,7 @@ current_query(PG_FUNCTION_ARGS)
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -249,6 +250,10 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+		SetBackendCancelMessage(pid, msg);
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -279,10 +284,10 @@ pg_signal_backend(int pid, int sig)
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
+static bool
+pg_cancel_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -297,16 +302,32 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
 }
 
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_cancel_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_cancel_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid = PG_GETARG_INT32(0);
+	char 	   *msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_cancel_backend_internal(pid, msg));
+}
+
+
 /*
  * Signal to terminate a backend process.  This is allowed if you are a member
  * of the role whose process is being terminated.
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
+static bool
+pg_terminate_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int		r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -318,7 +339,22 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
+}
+
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_terminate_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_terminate_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid = PG_GETARG_INT32(0);
+	char 	   *msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_terminate_backend_internal(pid, msg));
 }
 
 /*
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index f9b330998d..026419d23d 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -51,6 +51,7 @@
 #include "storage/smgr.h"
 #include "tcop/tcopprot.h"
 #include "utils/acl.h"
+#include "utils/backend_cancel.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
 #include "utils/memutils.h"
@@ -741,6 +742,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendCancelInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/backend/utils/misc/Makefile b/src/backend/utils/misc/Makefile
index a53fcdf188..619c837e08 100644
--- a/src/backend/utils/misc/Makefile
+++ b/src/backend/utils/misc/Makefile
@@ -14,9 +14,9 @@ include $(top_builddir)/src/Makefile.global
 
 override CPPFLAGS := -I. -I$(srcdir) $(CPPFLAGS)
 
-OBJS = backend_random.o guc.o help_config.o pg_config.o pg_controldata.o \
-       pg_rusage.o ps_status.o queryenvironment.o rls.o sampling.o \
-       superuser.o timeout.o tzparser.o
+OBJS = backend_cancel.o backend_random.o guc.o help_config.o pg_config.o \
+       pg_controldata.o pg_rusage.o ps_status.o queryenvironment.o rls.o \
+	   sampling.o superuser.o timeout.o tzparser.o
 
 # This location might depend on the installation directories. Therefore
 # we can't substitute it into pg_config.h.
diff --git a/src/backend/utils/misc/backend_cancel.c b/src/backend/utils/misc/backend_cancel.c
new file mode 100644
index 0000000000..66261893cb
--- /dev/null
+++ b/src/backend/utils/misc/backend_cancel.c
@@ -0,0 +1,195 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_cancel.c
+ *	  Backend cancellation messaging
+ *
+ *
+ * Module for supporting passing a user defined message to a cancelled,
+ * or terminated, backend from the user/administrator.
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/utils/misc/backend_cancel.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "mb/pg_wchar.h"
+#include "miscadmin.h"
+#include "storage/ipc.h"
+#include "storage/spin.h"
+#include "storage/shmem.h"
+#include "utils/backend_cancel.h"
+
+/*
+ * Each backend is registered per pid in the array which is indexed by Backend
+ * ID. Reading and writing the message is protected by a per-slot spinlock.
+ */
+typedef struct
+{
+	pid_t	pid;
+	slock_t	mutex;
+	char	message[MAX_CANCEL_MSG];
+	int		len;
+} BackendCancelShmemStruct;
+
+static BackendCancelShmemStruct	*BackendCancelSlots = NULL;
+static volatile BackendCancelShmemStruct *MyCancelSlot = NULL;
+
+static void CleanupCancelBackend(int status, Datum argument);
+
+Size
+CancelBackendMsgShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendCancelShmemStruct);
+}
+
+void
+BackendCancelShmemInit(void)
+{
+	Size	size = CancelBackendMsgShmemSize();
+	bool	found;
+	int		i;
+
+	BackendCancelSlots = (BackendCancelShmemStruct *)
+		ShmemInitStruct("BackendCancelSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendCancelSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendCancelSlots[i].mutex));
+	}
+}
+
+void
+BackendCancelInit(int backend_id)
+{
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->len = 0;
+	slot->pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupCancelBackend, Int32GetDatum(backend_id));
+}
+
+static void
+CleanupCancelBackend(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->len > 0)
+		slot->message[0] = '\0';
+
+	slot->len = 0;
+	slot->pid = 0;
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns the length of the message actually created. If the returned length
+ * is less than the length of the message parameter, truncation has occurred.
+ * If the backend isn't found, -1 is returned. If no message is passed, zero is
+ * returned. If two backends collide in setting a message, the existing message
+ * will be overwritten by the last one in.
+ */
+int
+SetBackendCancelMessage(pid_t backend, char *message)
+{
+	BackendCancelShmemStruct *slot;
+	int		i;
+	int		len;
+
+	if (!message)
+		return 0;
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		slot = &BackendCancelSlots[i];
+
+		if (slot->pid != 0 && slot->pid == backend)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->pid != backend)
+			{
+				SpinLockRelease(&slot->mutex);
+				goto error;
+			}
+
+			len = pg_mbcliplen(message, strlen(message),
+							   sizeof(slot->message) - 1);
+			memset(slot->message, '\0', sizeof(slot->message));
+			memcpy(slot->message, message, len);
+			slot->len = len;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return len;
+		}
+	}
+
+error:
+
+	elog(LOG, "Cancellation message requested for missing backend %d by %d",
+		 (int) backend, MyProcPid);
+
+	return -1;
+}
+
+bool
+HasCancelMessage(void)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = (slot->len > 0);
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * Return the configured cancellation message and its length. If the returned
+ * length is greater than the size of the passed buffer, truncation has been
+ * performed. The message is cleared on reading.
+ */
+int
+GetCancelMessage(char **buffer, size_t buf_len)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->len > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(*buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->len;
+		slot->len = 0;
+		slot->message[0] = '\0';
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index f01648c961..9f6d4bda6b 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -3254,8 +3254,12 @@ DESCR("is schema another session's temp schema?");
 
 DATA(insert OID = 2171 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v s 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 = 3438 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_cancel_backend_msg _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 s 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
 DESCR("terminate a server process");
+DATA(insert OID = 3437 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend_msg _null_ _null_ _null_ ));
+DESCR("terminate a server process");
 DATA(insert OID = 2172 ( pg_start_backup		PGNSP PGUID 12 1 0 0 0 f f f f t f v r 3 0 3220 "25 16 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 r 0 0 3220 "" _null_ _null_ _null_ _null_ _null_ pg_stop_backup _null_ _null_ _null_ ));
diff --git a/src/include/utils/backend_cancel.h b/src/include/utils/backend_cancel.h
new file mode 100644
index 0000000000..061f0fab18
--- /dev/null
+++ b/src/include/utils/backend_cancel.h
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_cancel.h
+ *		Declarations for backend cancellation messaging
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/utils/backend_cancel.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BACKEND_CANCEL_H
+#define BACKEND_CANCEL_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size CancelBackendMsgShmemSize(void);
+extern void BackendCancelShmemInit(void);
+extern void BackendCancelInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern bool HasCancelMessage(void);
+extern int GetCancelMessage(char **msg, size_t len);
+
+#endif /* BACKEND_CANCEL_H */
-- 
2.14.1.145.gb3622a4ee

From 9ab870d9c112315b15415732cc1a6aa0d77eacb6 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Thu, 25 Jan 2018 23:00:32 +0100
Subject: [PATCH 1/2] Refactor backend signalling code

This moves the system administration functions for signalling backends
from backend/utils/adt/misc.c into a separate file dedicated to backend
signalling. No new functionality is introduced in this commit.
---
 src/backend/storage/ipc/Makefile         |   6 +-
 src/backend/storage/ipc/backend_signal.c | 190 +++++++++++++++++++++++++++++++
 src/backend/utils/adt/misc.c             | 168 ---------------------------
 3 files changed, 193 insertions(+), 171 deletions(-)
 create mode 100644 src/backend/storage/ipc/backend_signal.c

diff --git a/src/backend/storage/ipc/Makefile b/src/backend/storage/ipc/Makefile
index 9dbdc26c9b..ac35c197e0 100644
--- a/src/backend/storage/ipc/Makefile
+++ b/src/backend/storage/ipc/Makefile
@@ -8,8 +8,8 @@ subdir = src/backend/storage/ipc
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o pmsignal.o procarray.o \
-	procsignal.o  shmem.o shmqueue.o shm_mq.o shm_toc.o sinval.o \
-	sinvaladt.o standby.o
+OBJS = backend_signal.o barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o \
+	pmsignal.o procarray.o procsignal.o shmem.o shmqueue.o shm_mq.o \
+	shm_toc.o sinval.o sinvaladt.o standby.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
new file mode 100644
index 0000000000..603b229149
--- /dev/null
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -0,0 +1,190 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.c
+ *	  Routines for signalling backends
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/ipc/backend_signal.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <signal.h>
+
+#include "catalog/pg_authid.h"
+#include "funcapi.h"
+#include "miscadmin.h"
+#include "postmaster/syslogger.h"
+#include "storage/pmsignal.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "utils/builtins.h"
+
+/*
+ * Send a signal to another backend.
+ *
+ * The signal is delivered if the user is either a superuser or the same
+ * role as the backend being signaled. For "dangerous" signals, an explicit
+ * check for superuser needs to be done prior to calling this function.
+ *
+ * Returns 0 on success, 1 on general failure, 2 on normal permission error
+ * and 3 if the caller needs to be a superuser.
+ *
+ * In the event of a general failure (return code 1), a warning message will
+ * be emitted. For permission errors, doing that is the responsibility of
+ * the caller.
+ */
+#define SIGNAL_BACKEND_SUCCESS 0
+#define SIGNAL_BACKEND_ERROR 1
+#define SIGNAL_BACKEND_NOPERMISSION 2
+#define SIGNAL_BACKEND_NOSUPERUSER 3
+static int
+pg_signal_backend(int pid, int sig)
+{
+	PGPROC	   *proc = BackendPidGetProc(pid);
+
+	/*
+	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
+	 * we reach kill(), a process for which we get a valid proc here might
+	 * have terminated on its own.  There's no way to acquire a lock on an
+	 * arbitrary process to prevent that. But since so far all the callers of
+	 * this mechanism involve some request for ending the process anyway, that
+	 * it might end on its own first is not a problem.
+	 */
+	if (proc == NULL)
+	{
+		/*
+		 * This is just a warning so a loop-through-resultset will not abort
+		 * if one backend terminated on its own during the run.
+		 */
+		ereport(WARNING,
+				(errmsg("PID %d is not a PostgreSQL server process", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+
+	/* Only allow superusers to signal superuser-owned backends. */
+	if (superuser_arg(proc->roleId) && !superuser())
+		return SIGNAL_BACKEND_NOSUPERUSER;
+
+	/* Users can signal backends they have role membership in. */
+	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
+		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
+		return SIGNAL_BACKEND_NOPERMISSION;
+
+	/*
+	 * Can the process we just validated above end, followed by the pid being
+	 * recycled for a new process, before reaching here?  Then we'd be trying
+	 * to kill the wrong thing.  Seems near impossible when sequential pid
+	 * assignment and wraparound is used.  Perhaps it could happen on a system
+	 * where pid re-use is randomized.  That race condition possibility seems
+	 * too unlikely to worry about.
+	 */
+
+	/* If we have setsid(), signal the backend's whole process group */
+#ifdef HAVE_SETSID
+	if (kill(-pid, sig))
+#else
+	if (kill(pid, sig))
+#endif
+	{
+		/* Again, just a warning to allow loops */
+		ereport(WARNING,
+				(errmsg("could not send signal to process %d: %m", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+	return SIGNAL_BACKEND_SUCCESS;
+}
+
+/*
+ * Signal to cancel a backend process.  This is allowed if you are a member of
+ * the role whose process is being canceled.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to cancel superuser query"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to terminate a backend process.  This is allowed if you are a member
+ * of the role whose process is being terminated.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to terminate superuser process"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to reload the database configuration
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_reload_conf(PG_FUNCTION_ARGS)
+{
+	if (kill(PostmasterPid, SIGHUP))
+	{
+		ereport(WARNING,
+				(errmsg("failed to send signal to postmaster: %m")));
+		PG_RETURN_BOOL(false);
+	}
+
+	PG_RETURN_BOOL(true);
+}
+
+
+/*
+ * Rotate log file
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_rotate_logfile(PG_FUNCTION_ARGS)
+{
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index 2e1e020c4b..5bfe789c0c 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -15,13 +15,11 @@
 #include "postgres.h"
 
 #include <sys/file.h>
-#include <signal.h>
 #include <dirent.h>
 #include <math.h>
 #include <unistd.h>
 
 #include "access/sysattr.h"
-#include "catalog/pg_authid.h"
 #include "catalog/catalog.h"
 #include "catalog/pg_tablespace.h"
 #include "catalog/pg_type.h"
@@ -35,9 +33,6 @@
 #include "postmaster/syslogger.h"
 #include "rewrite/rewriteHandler.h"
 #include "storage/fd.h"
-#include "storage/pmsignal.h"
-#include "storage/proc.h"
-#include "storage/procarray.h"
 #include "utils/lsyscache.h"
 #include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
@@ -198,169 +193,6 @@ current_query(PG_FUNCTION_ARGS)
 		PG_RETURN_NULL();
 }
 
-/*
- * Send a signal to another backend.
- *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
- *
- * Returns 0 on success, 1 on general failure, 2 on normal permission error
- * and 3 if the caller needs to be a superuser.
- *
- * In the event of a general failure (return code 1), a warning message will
- * be emitted. For permission errors, doing that is the responsibility of
- * the caller.
- */
-#define SIGNAL_BACKEND_SUCCESS 0
-#define SIGNAL_BACKEND_ERROR 1
-#define SIGNAL_BACKEND_NOPERMISSION 2
-#define SIGNAL_BACKEND_NOSUPERUSER 3
-static int
-pg_signal_backend(int pid, int sig)
-{
-	PGPROC	   *proc = BackendPidGetProc(pid);
-
-	/*
-	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
-	 * we reach kill(), a process for which we get a valid proc here might
-	 * have terminated on its own.  There's no way to acquire a lock on an
-	 * arbitrary process to prevent that. But since so far all the callers of
-	 * this mechanism involve some request for ending the process anyway, that
-	 * it might end on its own first is not a problem.
-	 */
-	if (proc == NULL)
-	{
-		/*
-		 * This is just a warning so a loop-through-resultset will not abort
-		 * if one backend terminated on its own during the run.
-		 */
-		ereport(WARNING,
-				(errmsg("PID %d is not a PostgreSQL server process", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-
-	/* Only allow superusers to signal superuser-owned backends. */
-	if (superuser_arg(proc->roleId) && !superuser())
-		return SIGNAL_BACKEND_NOSUPERUSER;
-
-	/* Users can signal backends they have role membership in. */
-	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
-		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
-		return SIGNAL_BACKEND_NOPERMISSION;
-
-	/*
-	 * Can the process we just validated above end, followed by the pid being
-	 * recycled for a new process, before reaching here?  Then we'd be trying
-	 * to kill the wrong thing.  Seems near impossible when sequential pid
-	 * assignment and wraparound is used.  Perhaps it could happen on a system
-	 * where pid re-use is randomized.  That race condition possibility seems
-	 * too unlikely to worry about.
-	 */
-
-	/* If we have setsid(), signal the backend's whole process group */
-#ifdef HAVE_SETSID
-	if (kill(-pid, sig))
-#else
-	if (kill(pid, sig))
-#endif
-	{
-		/* Again, just a warning to allow loops */
-		ereport(WARNING,
-				(errmsg("could not send signal to process %d: %m", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-	return SIGNAL_BACKEND_SUCCESS;
-}
-
-/*
- * Signal to cancel a backend process.  This is allowed if you are a member of
- * the role whose process is being canceled.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to cancel superuser query"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to terminate a backend process.  This is allowed if you are a member
- * of the role whose process is being terminated.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to terminate superuser process"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to reload the database configuration
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_reload_conf(PG_FUNCTION_ARGS)
-{
-	if (kill(PostmasterPid, SIGHUP))
-	{
-		ereport(WARNING,
-				(errmsg("failed to send signal to postmaster: %m")));
-		PG_RETURN_BOOL(false);
-	}
-
-	PG_RETURN_BOOL(true);
-}
-
-
-/*
- * Rotate log file
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_rotate_logfile(PG_FUNCTION_ARGS)
-{
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
 /* Function to find out which databases make use of a tablespace */
 
 typedef struct
-- 
2.14.1.145.gb3622a4ee

From 770d5b785bb3b142507cedddd4aa61617b0195fa Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Thu, 25 Jan 2018 23:49:37 +0100
Subject: [PATCH 2/2] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend() or
pg_cancel_backend() to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
overloaded the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);
---
 doc/src/sgml/func.sgml                   |   6 +-
 src/backend/storage/ipc/backend_signal.c | 237 +++++++++++++++++++++++++++++--
 src/backend/storage/ipc/ipci.c           |   3 +
 src/backend/tcop/postgres.c              |  38 ++++-
 src/backend/utils/init/postinit.c        |   2 +
 src/include/catalog/pg_proc.h            |   4 +
 src/include/storage/backend_signal.h     |  25 ++++
 7 files changed, 299 insertions(+), 16 deletions(-)
 create mode 100644 src/include/storage/backend_signal.h

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 487c7ff750..91f58eac55 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18381,7 +18381,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18406,7 +18406,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18437,6 +18437,8 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, the text
+    will be appended to the error message returned to the signalled backend.
    </para>
 
    <para>
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
index 603b229149..e63af3eaac 100644
--- a/src/backend/storage/ipc/backend_signal.c
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -18,13 +18,34 @@
 
 #include "catalog/pg_authid.h"
 #include "funcapi.h"
+#include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "postmaster/syslogger.h"
+#include "storage/backend_signal.h"
+#include "storage/ipc.h"
 #include "storage/pmsignal.h"
 #include "storage/proc.h"
 #include "storage/procarray.h"
 #include "utils/builtins.h"
 
+/*
+ * Structure for registering a message to be sent to a cancelled, or terminated
+ * backend. Each backend is registered per pid in the array which is indexed by
+ * Backend ID. Reading and writing the message is protected by a per-slot
+ * spinlock.
+ */
+typedef struct
+{
+	pid_t	pid;
+	slock_t	mutex;
+	char	message[MAX_CANCEL_MSG];
+	int		len;
+} BackendCancelShmemStruct;
+
+static BackendCancelShmemStruct	*BackendCancelSlots = NULL;
+static volatile BackendCancelShmemStruct *MyCancelSlot = NULL;
+static void CleanupCancelBackend(int status, Datum argument);
+
 /*
  * Send a signal to another backend.
  *
@@ -44,7 +65,7 @@
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -76,6 +97,14 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+		SetBackendCancelMessage(pid, msg);
+
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+		SetBackendCancelMessage(pid, msg);
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -106,10 +135,10 @@ pg_signal_backend(int pid, int sig)
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
+static bool
+pg_cancel_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -124,16 +153,32 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
 }
 
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_cancel_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_cancel_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid = PG_GETARG_INT32(0);
+	char 	   *msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_cancel_backend_internal(pid, msg));
+}
+
+
 /*
  * Signal to terminate a backend process.  This is allowed if you are a member
  * of the role whose process is being terminated.
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
+static bool
+pg_terminate_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int		r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -145,7 +190,22 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
+}
+
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_terminate_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_terminate_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid = PG_GETARG_INT32(0);
+	char 	   *msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_terminate_backend_internal(pid, msg));
 }
 
 /*
@@ -188,3 +248,164 @@ pg_rotate_logfile(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(true);
 }
 
+
+/*
+ * The following routines handle registering an optional message when
+ * cancelling, or terminating a backend. The message will be stored in
+ * shared memory and is limited to MAX_CANCEL_MSG characters including
+ * the NULL terminator.
+ *
+ * Access to the message slots is protected by spinlocks.
+ */
+Size
+CancelBackendMsgShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendCancelShmemStruct);
+}
+
+void
+BackendCancelShmemInit(void)
+{
+	Size	size = CancelBackendMsgShmemSize();
+	bool	found;
+	int		i;
+
+	BackendCancelSlots = (BackendCancelShmemStruct *)
+		ShmemInitStruct("BackendCancelSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendCancelSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendCancelSlots[i].mutex));
+	}
+}
+
+void
+BackendCancelInit(int backend_id)
+{
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->len = 0;
+	slot->pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupCancelBackend, Int32GetDatum(backend_id));
+}
+
+static void
+CleanupCancelBackend(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->len > 0)
+		slot->message[0] = '\0';
+
+	slot->len = 0;
+	slot->pid = 0;
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns the length of the message actually created. If the returned length
+ * is less than the length of the message parameter, truncation has occurred.
+ * If the backend isn't found, -1 is returned. If no message is passed, zero is
+ * returned. If two backends collide in setting a message, the existing message
+ * will be overwritten by the last one in.
+ */
+int
+SetBackendCancelMessage(pid_t backend, char *message)
+{
+	BackendCancelShmemStruct *slot;
+	int		i;
+	int		len;
+
+	if (!message)
+		return 0;
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		slot = &BackendCancelSlots[i];
+
+		if (slot->pid != 0 && slot->pid == backend)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->pid != backend)
+			{
+				SpinLockRelease(&slot->mutex);
+				goto error;
+			}
+
+			len = pg_mbcliplen(message, strlen(message),
+							   sizeof(slot->message) - 1);
+			memset(slot->message, '\0', sizeof(slot->message));
+			memcpy(slot->message, message, len);
+			slot->len = len;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return len;
+		}
+	}
+
+error:
+
+	elog(LOG, "Cancellation message requested for missing backend %d by %d",
+		 (int) backend, MyProcPid);
+
+	return -1;
+}
+
+bool
+HasCancelMessage(void)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = (slot->len > 0);
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * Return the configured cancellation message and its length. If the returned
+ * length is greater than the size of the passed buffer, truncation has been
+ * performed. The message is cleared on reading.
+ */
+int
+GetCancelMessage(char **buffer, size_t buf_len)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->len > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(*buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->len;
+		slot->len = 0;
+		slot->message[0] = '\0';
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 0c86a581c0..156df36234 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -33,6 +33,7 @@
 #include "replication/walreceiver.h"
 #include "replication/walsender.h"
 #include "replication/origin.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/dsm.h"
 #include "storage/ipc.h"
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, CancelBackendMsgShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendCancelShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index ddc3ec860a..0e36cb1a3f 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -60,6 +60,7 @@
 #include "replication/slot.h"
 #include "replication/walsender.h"
 #include "rewrite/rewriteHandler.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
 #include "storage/proc.h"
@@ -2918,9 +2919,22 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasCancelMessage())
+			{
+				char   *buffer = palloc0(MAX_CANCEL_MSG);
+
+				GetCancelMessage(&buffer, MAX_CANCEL_MSG);
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command: \"%s\"",
+						 buffer)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3031,9 +3045,21 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasCancelMessage())
+			{
+				char   *buffer = palloc0(MAX_CANCEL_MSG);
+
+				GetCancelMessage(&buffer, MAX_CANCEL_MSG);
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request: \"%s\"",
+								buffer)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index f9b330998d..d6aca4d5d3 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -40,6 +40,7 @@
 #include "postmaster/autovacuum.h"
 #include "postmaster/postmaster.h"
 #include "replication/walsender.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/fd.h"
 #include "storage/ipc.h"
@@ -741,6 +742,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendCancelInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index f01648c961..9f6d4bda6b 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -3254,8 +3254,12 @@ DESCR("is schema another session's temp schema?");
 
 DATA(insert OID = 2171 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v s 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 = 3438 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_cancel_backend_msg _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 s 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
 DESCR("terminate a server process");
+DATA(insert OID = 3437 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f t f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend_msg _null_ _null_ _null_ ));
+DESCR("terminate a server process");
 DATA(insert OID = 2172 ( pg_start_backup		PGNSP PGUID 12 1 0 0 0 f f f f t f v r 3 0 3220 "25 16 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 r 0 0 3220 "" _null_ _null_ _null_ _null_ _null_ pg_stop_backup _null_ _null_ _null_ ));
diff --git a/src/include/storage/backend_signal.h b/src/include/storage/backend_signal.h
new file mode 100644
index 0000000000..f232813995
--- /dev/null
+++ b/src/include/storage/backend_signal.h
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.h
+ *		Declarations for backend signalling
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/backend_signal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BACKEND_SIGNAL_H
+#define BACKEND_SIGNAL_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size CancelBackendMsgShmemSize(void);
+extern void BackendCancelShmemInit(void);
+extern void BackendCancelInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern bool HasCancelMessage(void);
+extern int GetCancelMessage(char **msg, size_t len);
+
+#endif /* BACKEND_SIGNAL_H */
-- 
2.14.1.145.gb3622a4ee

From 75fe95d36ff9e54f9e7f5a4c85b8c0e9e83ca7ed Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Mon, 5 Mar 2018 12:16:16 +0100
Subject: [PATCH 1/2] Refactor backend signalling code

This moves the system administration functions for signalling backends
from backend/utils/adt/misc.c into a separate file dedicated to backend
signalling. No new functionality is introduced in this commit.
---
 src/backend/storage/ipc/Makefile         |   6 +-
 src/backend/storage/ipc/backend_signal.c | 190 +++++++++++++++++++++++++++++++
 src/backend/utils/adt/misc.c             | 168 ---------------------------
 3 files changed, 193 insertions(+), 171 deletions(-)
 create mode 100644 src/backend/storage/ipc/backend_signal.c

diff --git a/src/backend/storage/ipc/Makefile b/src/backend/storage/ipc/Makefile
index 9dbdc26c9b..ac35c197e0 100644
--- a/src/backend/storage/ipc/Makefile
+++ b/src/backend/storage/ipc/Makefile
@@ -8,8 +8,8 @@ subdir = src/backend/storage/ipc
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o pmsignal.o procarray.o \
-	procsignal.o  shmem.o shmqueue.o shm_mq.o shm_toc.o sinval.o \
-	sinvaladt.o standby.o
+OBJS = backend_signal.o barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o \
+	pmsignal.o procarray.o procsignal.o shmem.o shmqueue.o shm_mq.o \
+	shm_toc.o sinval.o sinvaladt.o standby.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
new file mode 100644
index 0000000000..603b229149
--- /dev/null
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -0,0 +1,190 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.c
+ *	  Routines for signalling backends
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/ipc/backend_signal.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <signal.h>
+
+#include "catalog/pg_authid.h"
+#include "funcapi.h"
+#include "miscadmin.h"
+#include "postmaster/syslogger.h"
+#include "storage/pmsignal.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "utils/builtins.h"
+
+/*
+ * Send a signal to another backend.
+ *
+ * The signal is delivered if the user is either a superuser or the same
+ * role as the backend being signaled. For "dangerous" signals, an explicit
+ * check for superuser needs to be done prior to calling this function.
+ *
+ * Returns 0 on success, 1 on general failure, 2 on normal permission error
+ * and 3 if the caller needs to be a superuser.
+ *
+ * In the event of a general failure (return code 1), a warning message will
+ * be emitted. For permission errors, doing that is the responsibility of
+ * the caller.
+ */
+#define SIGNAL_BACKEND_SUCCESS 0
+#define SIGNAL_BACKEND_ERROR 1
+#define SIGNAL_BACKEND_NOPERMISSION 2
+#define SIGNAL_BACKEND_NOSUPERUSER 3
+static int
+pg_signal_backend(int pid, int sig)
+{
+	PGPROC	   *proc = BackendPidGetProc(pid);
+
+	/*
+	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
+	 * we reach kill(), a process for which we get a valid proc here might
+	 * have terminated on its own.  There's no way to acquire a lock on an
+	 * arbitrary process to prevent that. But since so far all the callers of
+	 * this mechanism involve some request for ending the process anyway, that
+	 * it might end on its own first is not a problem.
+	 */
+	if (proc == NULL)
+	{
+		/*
+		 * This is just a warning so a loop-through-resultset will not abort
+		 * if one backend terminated on its own during the run.
+		 */
+		ereport(WARNING,
+				(errmsg("PID %d is not a PostgreSQL server process", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+
+	/* Only allow superusers to signal superuser-owned backends. */
+	if (superuser_arg(proc->roleId) && !superuser())
+		return SIGNAL_BACKEND_NOSUPERUSER;
+
+	/* Users can signal backends they have role membership in. */
+	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
+		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
+		return SIGNAL_BACKEND_NOPERMISSION;
+
+	/*
+	 * Can the process we just validated above end, followed by the pid being
+	 * recycled for a new process, before reaching here?  Then we'd be trying
+	 * to kill the wrong thing.  Seems near impossible when sequential pid
+	 * assignment and wraparound is used.  Perhaps it could happen on a system
+	 * where pid re-use is randomized.  That race condition possibility seems
+	 * too unlikely to worry about.
+	 */
+
+	/* If we have setsid(), signal the backend's whole process group */
+#ifdef HAVE_SETSID
+	if (kill(-pid, sig))
+#else
+	if (kill(pid, sig))
+#endif
+	{
+		/* Again, just a warning to allow loops */
+		ereport(WARNING,
+				(errmsg("could not send signal to process %d: %m", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+	return SIGNAL_BACKEND_SUCCESS;
+}
+
+/*
+ * Signal to cancel a backend process.  This is allowed if you are a member of
+ * the role whose process is being canceled.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to cancel superuser query"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to terminate a backend process.  This is allowed if you are a member
+ * of the role whose process is being terminated.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to terminate superuser process"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to reload the database configuration
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_reload_conf(PG_FUNCTION_ARGS)
+{
+	if (kill(PostmasterPid, SIGHUP))
+	{
+		ereport(WARNING,
+				(errmsg("failed to send signal to postmaster: %m")));
+		PG_RETURN_BOOL(false);
+	}
+
+	PG_RETURN_BOOL(true);
+}
+
+
+/*
+ * Rotate log file
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_rotate_logfile(PG_FUNCTION_ARGS)
+{
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index 2e1e020c4b..5bfe789c0c 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -15,13 +15,11 @@
 #include "postgres.h"
 
 #include <sys/file.h>
-#include <signal.h>
 #include <dirent.h>
 #include <math.h>
 #include <unistd.h>
 
 #include "access/sysattr.h"
-#include "catalog/pg_authid.h"
 #include "catalog/catalog.h"
 #include "catalog/pg_tablespace.h"
 #include "catalog/pg_type.h"
@@ -35,9 +33,6 @@
 #include "postmaster/syslogger.h"
 #include "rewrite/rewriteHandler.h"
 #include "storage/fd.h"
-#include "storage/pmsignal.h"
-#include "storage/proc.h"
-#include "storage/procarray.h"
 #include "utils/lsyscache.h"
 #include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
@@ -198,169 +193,6 @@ current_query(PG_FUNCTION_ARGS)
 		PG_RETURN_NULL();
 }
 
-/*
- * Send a signal to another backend.
- *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
- *
- * Returns 0 on success, 1 on general failure, 2 on normal permission error
- * and 3 if the caller needs to be a superuser.
- *
- * In the event of a general failure (return code 1), a warning message will
- * be emitted. For permission errors, doing that is the responsibility of
- * the caller.
- */
-#define SIGNAL_BACKEND_SUCCESS 0
-#define SIGNAL_BACKEND_ERROR 1
-#define SIGNAL_BACKEND_NOPERMISSION 2
-#define SIGNAL_BACKEND_NOSUPERUSER 3
-static int
-pg_signal_backend(int pid, int sig)
-{
-	PGPROC	   *proc = BackendPidGetProc(pid);
-
-	/*
-	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
-	 * we reach kill(), a process for which we get a valid proc here might
-	 * have terminated on its own.  There's no way to acquire a lock on an
-	 * arbitrary process to prevent that. But since so far all the callers of
-	 * this mechanism involve some request for ending the process anyway, that
-	 * it might end on its own first is not a problem.
-	 */
-	if (proc == NULL)
-	{
-		/*
-		 * This is just a warning so a loop-through-resultset will not abort
-		 * if one backend terminated on its own during the run.
-		 */
-		ereport(WARNING,
-				(errmsg("PID %d is not a PostgreSQL server process", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-
-	/* Only allow superusers to signal superuser-owned backends. */
-	if (superuser_arg(proc->roleId) && !superuser())
-		return SIGNAL_BACKEND_NOSUPERUSER;
-
-	/* Users can signal backends they have role membership in. */
-	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
-		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
-		return SIGNAL_BACKEND_NOPERMISSION;
-
-	/*
-	 * Can the process we just validated above end, followed by the pid being
-	 * recycled for a new process, before reaching here?  Then we'd be trying
-	 * to kill the wrong thing.  Seems near impossible when sequential pid
-	 * assignment and wraparound is used.  Perhaps it could happen on a system
-	 * where pid re-use is randomized.  That race condition possibility seems
-	 * too unlikely to worry about.
-	 */
-
-	/* If we have setsid(), signal the backend's whole process group */
-#ifdef HAVE_SETSID
-	if (kill(-pid, sig))
-#else
-	if (kill(pid, sig))
-#endif
-	{
-		/* Again, just a warning to allow loops */
-		ereport(WARNING,
-				(errmsg("could not send signal to process %d: %m", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-	return SIGNAL_BACKEND_SUCCESS;
-}
-
-/*
- * Signal to cancel a backend process.  This is allowed if you are a member of
- * the role whose process is being canceled.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to cancel superuser query"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to terminate a backend process.  This is allowed if you are a member
- * of the role whose process is being terminated.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to terminate superuser process"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to reload the database configuration
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_reload_conf(PG_FUNCTION_ARGS)
-{
-	if (kill(PostmasterPid, SIGHUP))
-	{
-		ereport(WARNING,
-				(errmsg("failed to send signal to postmaster: %m")));
-		PG_RETURN_BOOL(false);
-	}
-
-	PG_RETURN_BOOL(true);
-}
-
-
-/*
- * Rotate log file
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_rotate_logfile(PG_FUNCTION_ARGS)
-{
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
 /* Function to find out which databases make use of a tablespace */
 
 typedef struct
-- 
2.14.1.145.gb3622a4ee

From 0935706d606e807d8f2109e6807791dc7fa62292 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Thu, 25 Jan 2018 23:49:37 +0100
Subject: [PATCH 2/2] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend() or
pg_cancel_backend() to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
overloaded the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);
---
 doc/src/sgml/func.sgml                   |   6 +-
 src/backend/storage/ipc/backend_signal.c | 251 ++++++++++++++++++++++++++++++-
 src/backend/storage/ipc/ipci.c           |   3 +
 src/backend/tcop/postgres.c              |  38 ++++-
 src/backend/utils/init/postinit.c        |   2 +
 src/include/catalog/pg_proc.h            |   5 +
 src/include/storage/backend_signal.h     |  25 +++
 7 files changed, 314 insertions(+), 16 deletions(-)
 create mode 100644 src/include/storage/backend_signal.h

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 2f59af25a6..337d4de62e 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18453,7 +18453,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18478,7 +18478,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18509,6 +18509,8 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, the text
+    will be appended to the error message returned to the signalled backend.
    </para>
 
    <para>
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
index 603b229149..e653bcfd30 100644
--- a/src/backend/storage/ipc/backend_signal.c
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -18,13 +18,34 @@
 
 #include "catalog/pg_authid.h"
 #include "funcapi.h"
+#include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "postmaster/syslogger.h"
+#include "storage/backend_signal.h"
+#include "storage/ipc.h"
 #include "storage/pmsignal.h"
 #include "storage/proc.h"
 #include "storage/procarray.h"
 #include "utils/builtins.h"
 
+/*
+ * Structure for registering a message to be sent to a cancelled, or terminated
+ * backend. Each backend is registered per pid in the array which is indexed by
+ * Backend ID. Reading and writing the message is protected by a per-slot
+ * spinlock.
+ */
+typedef struct
+{
+	pid_t	pid;
+	slock_t	mutex;
+	char	message[MAX_CANCEL_MSG];
+	int		len;
+} BackendCancelShmemStruct;
+
+static BackendCancelShmemStruct	*BackendCancelSlots = NULL;
+static volatile BackendCancelShmemStruct *MyCancelSlot = NULL;
+static void CleanupCancelBackend(int status, Datum argument);
+
 /*
  * Send a signal to another backend.
  *
@@ -44,7 +65,7 @@
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -76,6 +97,10 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+		SetBackendCancelMessage(pid, msg);
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -106,10 +131,10 @@ pg_signal_backend(int pid, int sig)
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
+static bool
+pg_cancel_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -124,16 +149,41 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
 }
 
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_cancel_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_cancel_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		ereport(ERROR,
+				(errmsg("pid cannot be NULL")));
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_cancel_backend_internal(pid, msg));
+}
+
+
 /*
  * Signal to terminate a backend process.  This is allowed if you are a member
  * of the role whose process is being terminated.
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
+static bool
+pg_terminate_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int		r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -145,7 +195,31 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
+}
+
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_terminate_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_terminate_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid;
+	char 	   *msg = NULL;
+	
+	if (PG_ARGISNULL(0))
+		ereport(ERROR,
+				(errmsg("pid cannot be NULL")));
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_terminate_backend_internal(pid, msg));
 }
 
 /*
@@ -188,3 +262,164 @@ pg_rotate_logfile(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(true);
 }
 
+
+/*
+ * The following routines handle registering an optional message when
+ * cancelling, or terminating a backend. The message will be stored in
+ * shared memory and is limited to MAX_CANCEL_MSG characters including
+ * the NULL terminator.
+ *
+ * Access to the message slots is protected by spinlocks.
+ */
+Size
+CancelBackendMsgShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendCancelShmemStruct);
+}
+
+void
+BackendCancelShmemInit(void)
+{
+	Size	size = CancelBackendMsgShmemSize();
+	bool	found;
+	int		i;
+
+	BackendCancelSlots = (BackendCancelShmemStruct *)
+		ShmemInitStruct("BackendCancelSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendCancelSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendCancelSlots[i].mutex));
+	}
+}
+
+void
+BackendCancelInit(int backend_id)
+{
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->len = 0;
+	slot->pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupCancelBackend, Int32GetDatum(backend_id));
+}
+
+static void
+CleanupCancelBackend(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->len > 0)
+		slot->message[0] = '\0';
+
+	slot->len = 0;
+	slot->pid = 0;
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns the length of the message actually created. If the returned length
+ * is less than the length of the message parameter, truncation has occurred.
+ * If the backend isn't found, -1 is returned. If no message is passed, zero is
+ * returned. If two backends collide in setting a message, the existing message
+ * will be overwritten by the last one in.
+ */
+int
+SetBackendCancelMessage(pid_t backend, char *message)
+{
+	BackendCancelShmemStruct *slot;
+	int		i;
+	int		len;
+
+	if (!message)
+		return 0;
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		slot = &BackendCancelSlots[i];
+
+		if (slot->pid != 0 && slot->pid == backend)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->pid != backend)
+			{
+				SpinLockRelease(&slot->mutex);
+				goto error;
+			}
+
+			len = pg_mbcliplen(message, strlen(message),
+							   sizeof(slot->message) - 1);
+			memset(slot->message, '\0', sizeof(slot->message));
+			memcpy(slot->message, message, len);
+			slot->len = len;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return len;
+		}
+	}
+
+error:
+
+	elog(LOG, "Cancellation message requested for missing backend %d by %d",
+		 (int) backend, MyProcPid);
+
+	return -1;
+}
+
+bool
+HasCancelMessage(void)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = (slot->len > 0);
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * Return the configured cancellation message and its length. If the returned
+ * length is greater than the size of the passed buffer, truncation has been
+ * performed. The message is cleared on reading.
+ */
+int
+GetCancelMessage(char **buffer, size_t buf_len)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->len > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(*buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->len;
+		slot->len = 0;
+		slot->message[0] = '\0';
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 0c86a581c0..156df36234 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -33,6 +33,7 @@
 #include "replication/walreceiver.h"
 #include "replication/walsender.h"
 #include "replication/origin.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/dsm.h"
 #include "storage/ipc.h"
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, CancelBackendMsgShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendCancelShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 6dc2095b9a..bccea2f480 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -60,6 +60,7 @@
 #include "replication/slot.h"
 #include "replication/walsender.h"
 #include "rewrite/rewriteHandler.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
 #include "storage/proc.h"
@@ -2918,9 +2919,22 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasCancelMessage())
+			{
+				char   *buffer = palloc0(MAX_CANCEL_MSG);
+
+				GetCancelMessage(&buffer, MAX_CANCEL_MSG);
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command: \"%s\"",
+						 buffer)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3031,9 +3045,21 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasCancelMessage())
+			{
+				char   *buffer = palloc0(MAX_CANCEL_MSG);
+
+				GetCancelMessage(&buffer, MAX_CANCEL_MSG);
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request: \"%s\"",
+								buffer)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 484628987f..51cdb0d89b 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -40,6 +40,7 @@
 #include "postmaster/autovacuum.h"
 #include "postmaster/postmaster.h"
 #include "replication/walsender.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/fd.h"
 #include "storage/ipc.h"
@@ -747,6 +748,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendCancelInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index 0fdb42f639..4223cdfd8e 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -3286,8 +3286,13 @@ DESCR("is schema another session's temp schema?");
 
 DATA(insert OID = 2171 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f t f v s 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 = 3438 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_cancel_backend_msg _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 t f v s 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
 DESCR("terminate a server process");
+DATA(insert OID = 3437 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend_msg _null_ _null_ _null_ ));
+DESCR("terminate a server process");
 DATA(insert OID = 2172 ( pg_start_backup		PGNSP PGUID 12 1 0 0 0 f f f t f v r 3 0 3220 "25 16 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 t f v r 0 0 3220 "" _null_ _null_ _null_ _null_ _null_ pg_stop_backup _null_ _null_ _null_ ));
diff --git a/src/include/storage/backend_signal.h b/src/include/storage/backend_signal.h
new file mode 100644
index 0000000000..f232813995
--- /dev/null
+++ b/src/include/storage/backend_signal.h
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.h
+ *		Declarations for backend signalling
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/backend_signal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BACKEND_SIGNAL_H
+#define BACKEND_SIGNAL_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size CancelBackendMsgShmemSize(void);
+extern void BackendCancelShmemInit(void);
+extern void BackendCancelInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern bool HasCancelMessage(void);
+extern int GetCancelMessage(char **msg, size_t len);
+
+#endif /* BACKEND_SIGNAL_H */
-- 
2.14.1.145.gb3622a4ee

From e96bd355fc747d174b6633d911cc781a7da32f8a Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Mon, 5 Mar 2018 12:16:16 +0100
Subject: [PATCH 1/2] Refactor backend signalling code

This moves the system administration functions for signalling backends
from backend/utils/adt/misc.c into a separate file dedicated to backend
signalling. No new functionality is introduced in this commit.
---
 src/backend/storage/ipc/Makefile         |   6 +-
 src/backend/storage/ipc/backend_signal.c | 190 +++++++++++++++++++++++++++++++
 src/backend/utils/adt/misc.c             | 168 ---------------------------
 3 files changed, 193 insertions(+), 171 deletions(-)
 create mode 100644 src/backend/storage/ipc/backend_signal.c

diff --git a/src/backend/storage/ipc/Makefile b/src/backend/storage/ipc/Makefile
index 9dbdc26c9b..ac35c197e0 100644
--- a/src/backend/storage/ipc/Makefile
+++ b/src/backend/storage/ipc/Makefile
@@ -8,8 +8,8 @@ subdir = src/backend/storage/ipc
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o pmsignal.o procarray.o \
-	procsignal.o  shmem.o shmqueue.o shm_mq.o shm_toc.o sinval.o \
-	sinvaladt.o standby.o
+OBJS = backend_signal.o barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o \
+	pmsignal.o procarray.o procsignal.o shmem.o shmqueue.o shm_mq.o \
+	shm_toc.o sinval.o sinvaladt.o standby.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
new file mode 100644
index 0000000000..603b229149
--- /dev/null
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -0,0 +1,190 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.c
+ *	  Routines for signalling backends
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/ipc/backend_signal.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <signal.h>
+
+#include "catalog/pg_authid.h"
+#include "funcapi.h"
+#include "miscadmin.h"
+#include "postmaster/syslogger.h"
+#include "storage/pmsignal.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "utils/builtins.h"
+
+/*
+ * Send a signal to another backend.
+ *
+ * The signal is delivered if the user is either a superuser or the same
+ * role as the backend being signaled. For "dangerous" signals, an explicit
+ * check for superuser needs to be done prior to calling this function.
+ *
+ * Returns 0 on success, 1 on general failure, 2 on normal permission error
+ * and 3 if the caller needs to be a superuser.
+ *
+ * In the event of a general failure (return code 1), a warning message will
+ * be emitted. For permission errors, doing that is the responsibility of
+ * the caller.
+ */
+#define SIGNAL_BACKEND_SUCCESS 0
+#define SIGNAL_BACKEND_ERROR 1
+#define SIGNAL_BACKEND_NOPERMISSION 2
+#define SIGNAL_BACKEND_NOSUPERUSER 3
+static int
+pg_signal_backend(int pid, int sig)
+{
+	PGPROC	   *proc = BackendPidGetProc(pid);
+
+	/*
+	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
+	 * we reach kill(), a process for which we get a valid proc here might
+	 * have terminated on its own.  There's no way to acquire a lock on an
+	 * arbitrary process to prevent that. But since so far all the callers of
+	 * this mechanism involve some request for ending the process anyway, that
+	 * it might end on its own first is not a problem.
+	 */
+	if (proc == NULL)
+	{
+		/*
+		 * This is just a warning so a loop-through-resultset will not abort
+		 * if one backend terminated on its own during the run.
+		 */
+		ereport(WARNING,
+				(errmsg("PID %d is not a PostgreSQL server process", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+
+	/* Only allow superusers to signal superuser-owned backends. */
+	if (superuser_arg(proc->roleId) && !superuser())
+		return SIGNAL_BACKEND_NOSUPERUSER;
+
+	/* Users can signal backends they have role membership in. */
+	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
+		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
+		return SIGNAL_BACKEND_NOPERMISSION;
+
+	/*
+	 * Can the process we just validated above end, followed by the pid being
+	 * recycled for a new process, before reaching here?  Then we'd be trying
+	 * to kill the wrong thing.  Seems near impossible when sequential pid
+	 * assignment and wraparound is used.  Perhaps it could happen on a system
+	 * where pid re-use is randomized.  That race condition possibility seems
+	 * too unlikely to worry about.
+	 */
+
+	/* If we have setsid(), signal the backend's whole process group */
+#ifdef HAVE_SETSID
+	if (kill(-pid, sig))
+#else
+	if (kill(pid, sig))
+#endif
+	{
+		/* Again, just a warning to allow loops */
+		ereport(WARNING,
+				(errmsg("could not send signal to process %d: %m", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+	return SIGNAL_BACKEND_SUCCESS;
+}
+
+/*
+ * Signal to cancel a backend process.  This is allowed if you are a member of
+ * the role whose process is being canceled.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to cancel superuser query"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to terminate a backend process.  This is allowed if you are a member
+ * of the role whose process is being terminated.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to terminate superuser process"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to reload the database configuration
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_reload_conf(PG_FUNCTION_ARGS)
+{
+	if (kill(PostmasterPid, SIGHUP))
+	{
+		ereport(WARNING,
+				(errmsg("failed to send signal to postmaster: %m")));
+		PG_RETURN_BOOL(false);
+	}
+
+	PG_RETURN_BOOL(true);
+}
+
+
+/*
+ * Rotate log file
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_rotate_logfile(PG_FUNCTION_ARGS)
+{
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index 2e1e020c4b..5bfe789c0c 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -15,13 +15,11 @@
 #include "postgres.h"
 
 #include <sys/file.h>
-#include <signal.h>
 #include <dirent.h>
 #include <math.h>
 #include <unistd.h>
 
 #include "access/sysattr.h"
-#include "catalog/pg_authid.h"
 #include "catalog/catalog.h"
 #include "catalog/pg_tablespace.h"
 #include "catalog/pg_type.h"
@@ -35,9 +33,6 @@
 #include "postmaster/syslogger.h"
 #include "rewrite/rewriteHandler.h"
 #include "storage/fd.h"
-#include "storage/pmsignal.h"
-#include "storage/proc.h"
-#include "storage/procarray.h"
 #include "utils/lsyscache.h"
 #include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
@@ -198,169 +193,6 @@ current_query(PG_FUNCTION_ARGS)
 		PG_RETURN_NULL();
 }
 
-/*
- * Send a signal to another backend.
- *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
- *
- * Returns 0 on success, 1 on general failure, 2 on normal permission error
- * and 3 if the caller needs to be a superuser.
- *
- * In the event of a general failure (return code 1), a warning message will
- * be emitted. For permission errors, doing that is the responsibility of
- * the caller.
- */
-#define SIGNAL_BACKEND_SUCCESS 0
-#define SIGNAL_BACKEND_ERROR 1
-#define SIGNAL_BACKEND_NOPERMISSION 2
-#define SIGNAL_BACKEND_NOSUPERUSER 3
-static int
-pg_signal_backend(int pid, int sig)
-{
-	PGPROC	   *proc = BackendPidGetProc(pid);
-
-	/*
-	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
-	 * we reach kill(), a process for which we get a valid proc here might
-	 * have terminated on its own.  There's no way to acquire a lock on an
-	 * arbitrary process to prevent that. But since so far all the callers of
-	 * this mechanism involve some request for ending the process anyway, that
-	 * it might end on its own first is not a problem.
-	 */
-	if (proc == NULL)
-	{
-		/*
-		 * This is just a warning so a loop-through-resultset will not abort
-		 * if one backend terminated on its own during the run.
-		 */
-		ereport(WARNING,
-				(errmsg("PID %d is not a PostgreSQL server process", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-
-	/* Only allow superusers to signal superuser-owned backends. */
-	if (superuser_arg(proc->roleId) && !superuser())
-		return SIGNAL_BACKEND_NOSUPERUSER;
-
-	/* Users can signal backends they have role membership in. */
-	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
-		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
-		return SIGNAL_BACKEND_NOPERMISSION;
-
-	/*
-	 * Can the process we just validated above end, followed by the pid being
-	 * recycled for a new process, before reaching here?  Then we'd be trying
-	 * to kill the wrong thing.  Seems near impossible when sequential pid
-	 * assignment and wraparound is used.  Perhaps it could happen on a system
-	 * where pid re-use is randomized.  That race condition possibility seems
-	 * too unlikely to worry about.
-	 */
-
-	/* If we have setsid(), signal the backend's whole process group */
-#ifdef HAVE_SETSID
-	if (kill(-pid, sig))
-#else
-	if (kill(pid, sig))
-#endif
-	{
-		/* Again, just a warning to allow loops */
-		ereport(WARNING,
-				(errmsg("could not send signal to process %d: %m", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-	return SIGNAL_BACKEND_SUCCESS;
-}
-
-/*
- * Signal to cancel a backend process.  This is allowed if you are a member of
- * the role whose process is being canceled.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to cancel superuser query"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to terminate a backend process.  This is allowed if you are a member
- * of the role whose process is being terminated.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to terminate superuser process"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to reload the database configuration
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_reload_conf(PG_FUNCTION_ARGS)
-{
-	if (kill(PostmasterPid, SIGHUP))
-	{
-		ereport(WARNING,
-				(errmsg("failed to send signal to postmaster: %m")));
-		PG_RETURN_BOOL(false);
-	}
-
-	PG_RETURN_BOOL(true);
-}
-
-
-/*
- * Rotate log file
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_rotate_logfile(PG_FUNCTION_ARGS)
-{
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
 /* Function to find out which databases make use of a tablespace */
 
 typedef struct
-- 
2.14.1.145.gb3622a4ee

From f0797c1c52781de98e6d1aa69005a006e2be076b Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Thu, 25 Jan 2018 23:49:37 +0100
Subject: [PATCH 2/2] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend() or
pg_cancel_backend() to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
overloaded the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);
---
 doc/src/sgml/func.sgml                    |  12 +-
 src/backend/storage/ipc/backend_signal.c  | 275 ++++++++++++++++++++++++++++--
 src/backend/storage/ipc/ipci.c            |   3 +
 src/backend/tcop/postgres.c               |  38 ++++-
 src/backend/utils/init/postinit.c         |   2 +
 src/include/catalog/pg_proc.h             |   5 +
 src/include/storage/backend_signal.h      |  25 +++
 src/test/regress/expected/admin_funcs.out |  29 ++++
 src/test/regress/parallel_schedule        |   2 +-
 src/test/regress/sql/admin_funcs.sql      |   7 +
 10 files changed, 378 insertions(+), 20 deletions(-)
 create mode 100644 src/include/storage/backend_signal.h
 create mode 100644 src/test/regress/expected/admin_funcs.out
 create mode 100644 src/test/regress/sql/admin_funcs.sql

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 2f59af25a6..bb7dbe264f 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18453,7 +18453,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18478,7 +18478,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18509,6 +18509,14 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, the text
+    will be appended to the error message returned to the signalled backend.
+    <literal>message</literal> is limited to 128 bytes, any longer text
+    will be truncated. An example where we cancel our own backend:
+<programlisting>
+postgres=# SELECT pg_cancel_backend(pg_backend_pid(), 'Cancellation message text');
+ERROR:  canceling statement due to user request: "Cancellation message text"
+</programlisting>
    </para>
 
    <para>
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
index 603b229149..1728fe22df 100644
--- a/src/backend/storage/ipc/backend_signal.c
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -18,19 +18,42 @@
 
 #include "catalog/pg_authid.h"
 #include "funcapi.h"
+#include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "postmaster/syslogger.h"
+#include "storage/backend_signal.h"
+#include "storage/ipc.h"
 #include "storage/pmsignal.h"
 #include "storage/proc.h"
 #include "storage/procarray.h"
 #include "utils/builtins.h"
 
+/*
+ * Structure for registering a message to be sent to a cancelled, or terminated
+ * backend. Each backend is registered per pid in the array which is indexed by
+ * Backend ID. Reading and writing the message is protected by a per-slot
+ * spinlock.
+ */
+typedef struct
+{
+	pid_t	pid;
+	slock_t	mutex;
+	char	message[MAX_CANCEL_MSG];
+	int		len;
+} BackendCancelShmemStruct;
+
+static BackendCancelShmemStruct	*BackendCancelSlots = NULL;
+static volatile BackendCancelShmemStruct *MyCancelSlot = NULL;
+static void CleanupCancelBackend(int status, Datum argument);
+
 /*
  * Send a signal to another backend.
  *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
+ * The signal is delivered if the user is either a superuser or the same role
+ * as the backend being signaled. For "dangerous" signals, an explicit check
+ * for superuser needs to be done prior to calling this function. If msg is
+ * set, the contents will be passed as a message to the backend in the error
+ * message.
  *
  * Returns 0 on success, 1 on general failure, 2 on normal permission error
  * and 3 if the caller needs to be a superuser.
@@ -44,7 +67,7 @@
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -76,6 +99,10 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+		SetBackendCancelMessage(pid, msg);
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -106,10 +133,10 @@ pg_signal_backend(int pid, int sig)
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
+static bool
+pg_cancel_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -124,16 +151,39 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
 }
 
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_cancel_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_cancel_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_cancel_backend_internal(pid, msg));
+}
+
 /*
  * Signal to terminate a backend process.  This is allowed if you are a member
  * of the role whose process is being terminated.
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
+static bool
+pg_terminate_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int		r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -145,7 +195,31 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
+}
+
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_terminate_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_terminate_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid;
+	char 	   *msg = NULL;
+	
+	if (PG_ARGISNULL(0))
+		ereport(ERROR,
+				(errmsg("pid cannot be NULL")));
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_terminate_backend_internal(pid, msg));
 }
 
 /*
@@ -188,3 +262,182 @@ pg_rotate_logfile(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(true);
 }
 
+/*
+ * The following routines handle registering an optional message when
+ * cancelling, or terminating a backend. The message will be stored in
+ * shared memory and is limited to MAX_CANCEL_MSG characters including
+ * the NULL terminator.
+ *
+ * Access to the message slots is protected by spinlocks.
+ */
+
+/*
+ * Return the required size for the cancelation message Shmem area.
+ */
+Size
+CancelBackendMsgShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendCancelShmemStruct);
+}
+
+/*
+ * Create and initialize the Shmem structure for holding the messages, the
+ * bookkeeping for them and the spinlocks associated.
+ */
+void
+BackendCancelMessageShmemInit(void)
+{
+	Size	size = CancelBackendMsgShmemSize();
+	bool	found;
+	int		i;
+
+	BackendCancelSlots = (BackendCancelShmemStruct *)
+		ShmemInitStruct("BackendCancelSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendCancelSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendCancelSlots[i].mutex));
+	}
+}
+
+/*
+ * Set up the slot for the current backend_id
+ */
+void
+BackendCancelMessageInit(int backend_id)
+{
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->len = 0;
+	slot->pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupCancelBackend, Int32GetDatum(backend_id));
+}
+
+/*
+ * Ensure that the slot is purged and emptied at exit. Any message gets
+ * overwritten with null chars to avoid risking exposing a message intended for
+ * another backend to a new backend.
+ */
+static void
+CleanupCancelBackend(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->len > 0)
+		MemSet(slot->message, '\0', sizeof(slot->message));
+
+	slot->len = 0;
+	slot->pid = 0;
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns the length of the message actually created. If the returned length
+ * is less than the length of the message parameter, truncation has occurred.
+ * If the backend isn't found, -1 is returned. If no message is passed, zero is
+ * returned. If two backends collide in setting a message, the existing message
+ * will be overwritten by the last one in.
+ */
+int
+SetBackendCancelMessage(pid_t backend_pid, char *message)
+{
+	int		i;
+	int		len;
+
+	if (!message)
+		return 0;
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		BackendCancelShmemStruct *slot = &BackendCancelSlots[i];
+
+		if (slot->pid != 0 && slot->pid == backend_pid)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->pid != backend_pid)
+			{
+				SpinLockRelease(&slot->mutex);
+				goto error;
+			}
+
+			len = pg_mbcliplen(message, strlen(message),
+							   sizeof(slot->message) - 1);
+			MemSet(slot->message, '\0', sizeof(slot->message));
+			memcpy(slot->message, message, len);
+			slot->len = len;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return len;
+		}
+	}
+
+error:
+
+	elog(LOG, "Cancellation message requested for missing backend %d by %d",
+		 (int) backend_pid, MyProcPid);
+
+	return -1;
+}
+
+/*
+ * Test whether there is a cancelation message for the current backend that
+ * can be consumed and presented to the user.
+ */
+bool
+HasCancelMessage(void)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = (slot->len > 0);
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * Return the configured cancellation message and its length. If the returned
+ * length is greater than the size of the passed buffer, truncation has been
+ * performed. The message is cleared on reading.
+ */
+int
+ConsumeCancelMessage(char *buffer, size_t buf_len)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->len > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->len;
+		slot->len = 0;
+		slot->message[0] = '\0';
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 0c86a581c0..e4b5d3a45b 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -33,6 +33,7 @@
 #include "replication/walreceiver.h"
 #include "replication/walsender.h"
 #include "replication/origin.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/dsm.h"
 #include "storage/ipc.h"
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, CancelBackendMsgShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendCancelMessageShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 6dc2095b9a..d43fa2d66e 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -60,6 +60,7 @@
 #include "replication/slot.h"
 #include "replication/walsender.h"
 #include "rewrite/rewriteHandler.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
 #include "storage/proc.h"
@@ -2918,9 +2919,22 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasCancelMessage())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+
+				ConsumeCancelMessage(buffer, MAX_CANCEL_MSG);
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command: \"%s\"",
+						 buffer)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3031,9 +3045,21 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasCancelMessage())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+
+				ConsumeCancelMessage(buffer, MAX_CANCEL_MSG);
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request: \"%s\"",
+								buffer)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index d8f45b3c43..616580be71 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -40,6 +40,7 @@
 #include "postmaster/autovacuum.h"
 #include "postmaster/postmaster.h"
 #include "replication/walsender.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/fd.h"
 #include "storage/ipc.h"
@@ -747,6 +748,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendCancelMessageInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index 0fdb42f639..4223cdfd8e 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -3286,8 +3286,13 @@ DESCR("is schema another session's temp schema?");
 
 DATA(insert OID = 2171 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f t f v s 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 = 3438 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_cancel_backend_msg _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 t f v s 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
 DESCR("terminate a server process");
+DATA(insert OID = 3437 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend_msg _null_ _null_ _null_ ));
+DESCR("terminate a server process");
 DATA(insert OID = 2172 ( pg_start_backup		PGNSP PGUID 12 1 0 0 0 f f f t f v r 3 0 3220 "25 16 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 t f v r 0 0 3220 "" _null_ _null_ _null_ _null_ _null_ pg_stop_backup _null_ _null_ _null_ ));
diff --git a/src/include/storage/backend_signal.h b/src/include/storage/backend_signal.h
new file mode 100644
index 0000000000..5bb04615fd
--- /dev/null
+++ b/src/include/storage/backend_signal.h
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.h
+ *		Declarations for backend signalling
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/backend_signal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BACKEND_SIGNAL_H
+#define BACKEND_SIGNAL_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size CancelBackendMsgShmemSize(void);
+extern void BackendCancelMessageShmemInit(void);
+extern void BackendCancelMessageInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern bool HasCancelMessage(void);
+extern int ConsumeCancelMessage(char *msg, size_t len);
+
+#endif /* BACKEND_SIGNAL_H */
diff --git a/src/test/regress/expected/admin_funcs.out b/src/test/regress/expected/admin_funcs.out
new file mode 100644
index 0000000000..5bf5b6bc1e
--- /dev/null
+++ b/src/test/regress/expected/admin_funcs.out
@@ -0,0 +1,29 @@
+select pg_cancel_backend();
+ERROR:  function pg_cancel_backend() does not exist
+LINE 1: select pg_cancel_backend();
+               ^
+HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
+select pg_cancel_backend(NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(pg_backend_pid());
+ERROR:  canceling statement due to user request
+select pg_cancel_backend(NULL, NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(NULL, 'suicide is painless');
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(pg_backend_pid(), 'it brings on many changes');
+ERROR:  canceling statement due to user request: "it brings on many changes"
+select pg_cancel_backend(pg_backend_pid(), NULL);
+ERROR:  canceling statement due to user request
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index ad9434fb87..f1f9eef56d 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -84,7 +84,7 @@ test: select_into select_distinct select_distinct_on select_implicit select_havi
 # ----------
 # Another group of parallel tests
 # ----------
-test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password
+test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password admin_funcs
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/admin_funcs.sql b/src/test/regress/sql/admin_funcs.sql
new file mode 100644
index 0000000000..420d782b80
--- /dev/null
+++ b/src/test/regress/sql/admin_funcs.sql
@@ -0,0 +1,7 @@
+select pg_cancel_backend();
+select pg_cancel_backend(NULL);
+select pg_cancel_backend(pg_backend_pid());
+select pg_cancel_backend(NULL, NULL);
+select pg_cancel_backend(NULL, 'suicide is painless');
+select pg_cancel_backend(pg_backend_pid(), 'it brings on many changes');
+select pg_cancel_backend(pg_backend_pid(), NULL);
-- 
2.14.1.145.gb3622a4ee

From 86ea7bc27cbcdc111eea479a50704e941a82683a Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Mon, 5 Mar 2018 12:16:16 +0100
Subject: [PATCH 1/2] Refactor backend signalling code

This moves the system administration functions for signalling backends
from backend/utils/adt/misc.c into a separate file dedicated to backend
signalling. No new functionality is introduced in this commit.
---
 src/backend/storage/ipc/Makefile         |   6 +-
 src/backend/storage/ipc/backend_signal.c | 190 +++++++++++++++++++++++++++++++
 src/backend/utils/adt/misc.c             | 168 ---------------------------
 3 files changed, 193 insertions(+), 171 deletions(-)
 create mode 100644 src/backend/storage/ipc/backend_signal.c

diff --git a/src/backend/storage/ipc/Makefile b/src/backend/storage/ipc/Makefile
index 9dbdc26c9b..ac35c197e0 100644
--- a/src/backend/storage/ipc/Makefile
+++ b/src/backend/storage/ipc/Makefile
@@ -8,8 +8,8 @@ subdir = src/backend/storage/ipc
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o pmsignal.o procarray.o \
-	procsignal.o  shmem.o shmqueue.o shm_mq.o shm_toc.o sinval.o \
-	sinvaladt.o standby.o
+OBJS = backend_signal.o barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o \
+	pmsignal.o procarray.o procsignal.o shmem.o shmqueue.o shm_mq.o \
+	shm_toc.o sinval.o sinvaladt.o standby.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
new file mode 100644
index 0000000000..603b229149
--- /dev/null
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -0,0 +1,190 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.c
+ *	  Routines for signalling backends
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/ipc/backend_signal.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <signal.h>
+
+#include "catalog/pg_authid.h"
+#include "funcapi.h"
+#include "miscadmin.h"
+#include "postmaster/syslogger.h"
+#include "storage/pmsignal.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "utils/builtins.h"
+
+/*
+ * Send a signal to another backend.
+ *
+ * The signal is delivered if the user is either a superuser or the same
+ * role as the backend being signaled. For "dangerous" signals, an explicit
+ * check for superuser needs to be done prior to calling this function.
+ *
+ * Returns 0 on success, 1 on general failure, 2 on normal permission error
+ * and 3 if the caller needs to be a superuser.
+ *
+ * In the event of a general failure (return code 1), a warning message will
+ * be emitted. For permission errors, doing that is the responsibility of
+ * the caller.
+ */
+#define SIGNAL_BACKEND_SUCCESS 0
+#define SIGNAL_BACKEND_ERROR 1
+#define SIGNAL_BACKEND_NOPERMISSION 2
+#define SIGNAL_BACKEND_NOSUPERUSER 3
+static int
+pg_signal_backend(int pid, int sig)
+{
+	PGPROC	   *proc = BackendPidGetProc(pid);
+
+	/*
+	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
+	 * we reach kill(), a process for which we get a valid proc here might
+	 * have terminated on its own.  There's no way to acquire a lock on an
+	 * arbitrary process to prevent that. But since so far all the callers of
+	 * this mechanism involve some request for ending the process anyway, that
+	 * it might end on its own first is not a problem.
+	 */
+	if (proc == NULL)
+	{
+		/*
+		 * This is just a warning so a loop-through-resultset will not abort
+		 * if one backend terminated on its own during the run.
+		 */
+		ereport(WARNING,
+				(errmsg("PID %d is not a PostgreSQL server process", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+
+	/* Only allow superusers to signal superuser-owned backends. */
+	if (superuser_arg(proc->roleId) && !superuser())
+		return SIGNAL_BACKEND_NOSUPERUSER;
+
+	/* Users can signal backends they have role membership in. */
+	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
+		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
+		return SIGNAL_BACKEND_NOPERMISSION;
+
+	/*
+	 * Can the process we just validated above end, followed by the pid being
+	 * recycled for a new process, before reaching here?  Then we'd be trying
+	 * to kill the wrong thing.  Seems near impossible when sequential pid
+	 * assignment and wraparound is used.  Perhaps it could happen on a system
+	 * where pid re-use is randomized.  That race condition possibility seems
+	 * too unlikely to worry about.
+	 */
+
+	/* If we have setsid(), signal the backend's whole process group */
+#ifdef HAVE_SETSID
+	if (kill(-pid, sig))
+#else
+	if (kill(pid, sig))
+#endif
+	{
+		/* Again, just a warning to allow loops */
+		ereport(WARNING,
+				(errmsg("could not send signal to process %d: %m", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+	return SIGNAL_BACKEND_SUCCESS;
+}
+
+/*
+ * Signal to cancel a backend process.  This is allowed if you are a member of
+ * the role whose process is being canceled.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to cancel superuser query"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to terminate a backend process.  This is allowed if you are a member
+ * of the role whose process is being terminated.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to terminate superuser process"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to reload the database configuration
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_reload_conf(PG_FUNCTION_ARGS)
+{
+	if (kill(PostmasterPid, SIGHUP))
+	{
+		ereport(WARNING,
+				(errmsg("failed to send signal to postmaster: %m")));
+		PG_RETURN_BOOL(false);
+	}
+
+	PG_RETURN_BOOL(true);
+}
+
+
+/*
+ * Rotate log file
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_rotate_logfile(PG_FUNCTION_ARGS)
+{
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index 2e1e020c4b..5bfe789c0c 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -15,13 +15,11 @@
 #include "postgres.h"
 
 #include <sys/file.h>
-#include <signal.h>
 #include <dirent.h>
 #include <math.h>
 #include <unistd.h>
 
 #include "access/sysattr.h"
-#include "catalog/pg_authid.h"
 #include "catalog/catalog.h"
 #include "catalog/pg_tablespace.h"
 #include "catalog/pg_type.h"
@@ -35,9 +33,6 @@
 #include "postmaster/syslogger.h"
 #include "rewrite/rewriteHandler.h"
 #include "storage/fd.h"
-#include "storage/pmsignal.h"
-#include "storage/proc.h"
-#include "storage/procarray.h"
 #include "utils/lsyscache.h"
 #include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
@@ -198,169 +193,6 @@ current_query(PG_FUNCTION_ARGS)
 		PG_RETURN_NULL();
 }
 
-/*
- * Send a signal to another backend.
- *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
- *
- * Returns 0 on success, 1 on general failure, 2 on normal permission error
- * and 3 if the caller needs to be a superuser.
- *
- * In the event of a general failure (return code 1), a warning message will
- * be emitted. For permission errors, doing that is the responsibility of
- * the caller.
- */
-#define SIGNAL_BACKEND_SUCCESS 0
-#define SIGNAL_BACKEND_ERROR 1
-#define SIGNAL_BACKEND_NOPERMISSION 2
-#define SIGNAL_BACKEND_NOSUPERUSER 3
-static int
-pg_signal_backend(int pid, int sig)
-{
-	PGPROC	   *proc = BackendPidGetProc(pid);
-
-	/*
-	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
-	 * we reach kill(), a process for which we get a valid proc here might
-	 * have terminated on its own.  There's no way to acquire a lock on an
-	 * arbitrary process to prevent that. But since so far all the callers of
-	 * this mechanism involve some request for ending the process anyway, that
-	 * it might end on its own first is not a problem.
-	 */
-	if (proc == NULL)
-	{
-		/*
-		 * This is just a warning so a loop-through-resultset will not abort
-		 * if one backend terminated on its own during the run.
-		 */
-		ereport(WARNING,
-				(errmsg("PID %d is not a PostgreSQL server process", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-
-	/* Only allow superusers to signal superuser-owned backends. */
-	if (superuser_arg(proc->roleId) && !superuser())
-		return SIGNAL_BACKEND_NOSUPERUSER;
-
-	/* Users can signal backends they have role membership in. */
-	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
-		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
-		return SIGNAL_BACKEND_NOPERMISSION;
-
-	/*
-	 * Can the process we just validated above end, followed by the pid being
-	 * recycled for a new process, before reaching here?  Then we'd be trying
-	 * to kill the wrong thing.  Seems near impossible when sequential pid
-	 * assignment and wraparound is used.  Perhaps it could happen on a system
-	 * where pid re-use is randomized.  That race condition possibility seems
-	 * too unlikely to worry about.
-	 */
-
-	/* If we have setsid(), signal the backend's whole process group */
-#ifdef HAVE_SETSID
-	if (kill(-pid, sig))
-#else
-	if (kill(pid, sig))
-#endif
-	{
-		/* Again, just a warning to allow loops */
-		ereport(WARNING,
-				(errmsg("could not send signal to process %d: %m", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-	return SIGNAL_BACKEND_SUCCESS;
-}
-
-/*
- * Signal to cancel a backend process.  This is allowed if you are a member of
- * the role whose process is being canceled.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to cancel superuser query"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to terminate a backend process.  This is allowed if you are a member
- * of the role whose process is being terminated.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to terminate superuser process"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to reload the database configuration
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_reload_conf(PG_FUNCTION_ARGS)
-{
-	if (kill(PostmasterPid, SIGHUP))
-	{
-		ereport(WARNING,
-				(errmsg("failed to send signal to postmaster: %m")));
-		PG_RETURN_BOOL(false);
-	}
-
-	PG_RETURN_BOOL(true);
-}
-
-
-/*
- * Rotate log file
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_rotate_logfile(PG_FUNCTION_ARGS)
-{
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
 /* Function to find out which databases make use of a tablespace */
 
 typedef struct
-- 
2.14.1.145.gb3622a4ee

From 3bebd9717cfd18c7649084a89928dfa1c43b8a25 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Thu, 25 Jan 2018 23:49:37 +0100
Subject: [PATCH 2/2] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend() or
pg_cancel_backend() to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
overloaded the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);
---
 doc/src/sgml/func.sgml                    |  12 +-
 src/backend/storage/ipc/backend_signal.c  | 275 ++++++++++++++++++++++++++++--
 src/backend/storage/ipc/ipci.c            |   3 +
 src/backend/tcop/postgres.c               |  38 ++++-
 src/backend/utils/init/postinit.c         |   2 +
 src/include/catalog/pg_proc.h             |   5 +
 src/include/storage/backend_signal.h      |  25 +++
 src/test/regress/expected/admin_funcs.out |  29 ++++
 src/test/regress/parallel_schedule        |   2 +-
 src/test/regress/sql/admin_funcs.sql      |   7 +
 10 files changed, 377 insertions(+), 21 deletions(-)
 create mode 100644 src/include/storage/backend_signal.h
 create mode 100644 src/test/regress/expected/admin_funcs.out
 create mode 100644 src/test/regress/sql/admin_funcs.sql

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 9d1772f349..7702049b5e 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18461,7 +18461,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18486,7 +18486,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18517,6 +18517,14 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, the text
+    will be appended to the error message returned to the signalled backend.
+    <literal>message</literal> is limited to 128 bytes, any longer text
+    will be truncated. An example where we cancel our own backend:
+<programlisting>
+postgres=# SELECT pg_cancel_backend(pg_backend_pid(), 'Cancellation message text');
+ERROR:  canceling statement due to user request: "Cancellation message text"
+</programlisting>
    </para>
 
    <para>
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
index 603b229149..895e1be775 100644
--- a/src/backend/storage/ipc/backend_signal.c
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -18,19 +18,42 @@
 
 #include "catalog/pg_authid.h"
 #include "funcapi.h"
+#include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "postmaster/syslogger.h"
+#include "storage/backend_signal.h"
+#include "storage/ipc.h"
 #include "storage/pmsignal.h"
 #include "storage/proc.h"
 #include "storage/procarray.h"
 #include "utils/builtins.h"
 
+/*
+ * Structure for registering a message to be sent to a cancelled, or terminated
+ * backend. Each backend is registered per pid in the array which is indexed by
+ * Backend ID. Reading and writing the message is protected by a per-slot
+ * spinlock.
+ */
+typedef struct
+{
+	pid_t	pid;
+	slock_t	mutex;
+	char	message[MAX_CANCEL_MSG];
+	int		len;
+} BackendCancelShmemStruct;
+
+static BackendCancelShmemStruct	*BackendCancelSlots = NULL;
+static volatile BackendCancelShmemStruct *MyCancelSlot = NULL;
+static void CleanupCancelBackend(int status, Datum argument);
+
 /*
  * Send a signal to another backend.
  *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
+ * The signal is delivered if the user is either a superuser or the same role
+ * as the backend being signaled. For "dangerous" signals, an explicit check
+ * for superuser needs to be done prior to calling this function. If msg is
+ * set, the contents will be passed as a message to the backend in the error
+ * message.
  *
  * Returns 0 on success, 1 on general failure, 2 on normal permission error
  * and 3 if the caller needs to be a superuser.
@@ -44,7 +67,7 @@
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -76,6 +99,10 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+		SetBackendCancelMessage(pid, msg);
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -106,10 +133,10 @@ pg_signal_backend(int pid, int sig)
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
+static bool
+pg_cancel_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -124,16 +151,39 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
 }
 
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_cancel_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_cancel_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_cancel_backend_internal(pid, msg));
+}
+
 /*
  * Signal to terminate a backend process.  This is allowed if you are a member
  * of the role whose process is being terminated.
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
+static bool
+pg_terminate_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int		r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -145,7 +195,30 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
+}
+
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_terminate_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_terminate_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_terminate_backend_internal(pid, msg));
 }
 
 /*
@@ -167,7 +240,6 @@ pg_reload_conf(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(true);
 }
 
-
 /*
  * Rotate log file
  *
@@ -188,3 +260,182 @@ pg_rotate_logfile(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(true);
 }
 
+/*
+ * The following routines handle registering an optional message when
+ * cancelling, or terminating a backend. The message will be stored in
+ * shared memory and is limited to MAX_CANCEL_MSG characters including
+ * the NULL terminator.
+ *
+ * Access to the message slots is protected by spinlocks.
+ */
+
+/*
+ * Return the required size for the cancelation message Shmem area.
+ */
+Size
+CancelBackendMsgShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendCancelShmemStruct);
+}
+
+/*
+ * Create and initialize the Shmem structure for holding the messages, the
+ * bookkeeping for them and the spinlocks associated.
+ */
+void
+BackendCancelMessageShmemInit(void)
+{
+	Size	size = CancelBackendMsgShmemSize();
+	bool	found;
+	int		i;
+
+	BackendCancelSlots = (BackendCancelShmemStruct *)
+		ShmemInitStruct("BackendCancelSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendCancelSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendCancelSlots[i].mutex));
+	}
+}
+
+/*
+ * Set up the slot for the current backend_id
+ */
+void
+BackendCancelMessageInit(int backend_id)
+{
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->len = 0;
+	slot->pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupCancelBackend, Int32GetDatum(backend_id));
+}
+
+/*
+ * Ensure that the slot is purged and emptied at exit. Any message gets
+ * overwritten with null chars to avoid risking exposing a message intended for
+ * another backend to a new backend.
+ */
+static void
+CleanupCancelBackend(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->len > 0)
+		MemSet(slot->message, '\0', sizeof(slot->message));
+
+	slot->len = 0;
+	slot->pid = 0;
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns the length of the message actually created. If the returned length
+ * is less than the length of the message parameter, truncation has occurred.
+ * If the backend isn't found, -1 is returned. If no message is passed, zero is
+ * returned. If two backends collide in setting a message, the existing message
+ * will be overwritten by the last one in.
+ */
+int
+SetBackendCancelMessage(pid_t backend_pid, char *message)
+{
+	int		i;
+	int		len;
+
+	if (!message)
+		return 0;
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		BackendCancelShmemStruct *slot = &BackendCancelSlots[i];
+
+		if (slot->pid != 0 && slot->pid == backend_pid)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->pid != backend_pid)
+			{
+				SpinLockRelease(&slot->mutex);
+				goto error;
+			}
+
+			len = pg_mbcliplen(message, strlen(message),
+							   sizeof(slot->message) - 1);
+			MemSet(slot->message, '\0', sizeof(slot->message));
+			memcpy(slot->message, message, len);
+			slot->len = len;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return len;
+		}
+	}
+
+error:
+
+	elog(LOG, "Cancellation message requested for missing backend %d by %d",
+		 (int) backend_pid, MyProcPid);
+
+	return -1;
+}
+
+/*
+ * Test whether there is a cancelation message for the current backend that
+ * can be consumed and presented to the user.
+ */
+bool
+HasCancelMessage(void)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = (slot->len > 0);
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * Return the configured cancellation message and its length. If the returned
+ * length is greater than the size of the passed buffer, truncation has been
+ * performed. The message is cleared on reading.
+ */
+int
+ConsumeCancelMessage(char *buffer, size_t buf_len)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->len > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->len;
+		slot->len = 0;
+		slot->message[0] = '\0';
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 0c86a581c0..e4b5d3a45b 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -33,6 +33,7 @@
 #include "replication/walreceiver.h"
 #include "replication/walsender.h"
 #include "replication/origin.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/dsm.h"
 #include "storage/ipc.h"
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, CancelBackendMsgShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendCancelMessageShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 6fc1cc272b..9aee117234 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -61,6 +61,7 @@
 #include "replication/slot.h"
 #include "replication/walsender.h"
 #include "rewrite/rewriteHandler.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
 #include "storage/proc.h"
@@ -2919,9 +2920,22 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasCancelMessage())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+
+				ConsumeCancelMessage(buffer, MAX_CANCEL_MSG);
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command: \"%s\"",
+						 buffer)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3032,9 +3046,21 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasCancelMessage())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+
+				ConsumeCancelMessage(buffer, MAX_CANCEL_MSG);
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request: \"%s\"",
+								buffer)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index d8f45b3c43..616580be71 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -40,6 +40,7 @@
 #include "postmaster/autovacuum.h"
 #include "postmaster/postmaster.h"
 #include "replication/walsender.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/fd.h"
 #include "storage/ipc.h"
@@ -747,6 +748,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendCancelMessageInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index ec50afcdf0..5a084e44db 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -3302,8 +3302,13 @@ DESCR("is schema another session's temp schema?");
 
 DATA(insert OID = 2171 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f t f v s 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 = 3438 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_cancel_backend_msg _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 t f v s 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
 DESCR("terminate a server process");
+DATA(insert OID = 3437 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend_msg _null_ _null_ _null_ ));
+DESCR("terminate a server process");
 DATA(insert OID = 2172 ( pg_start_backup		PGNSP PGUID 12 1 0 0 0 f f f t f v r 3 0 3220 "25 16 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 t f v r 0 0 3220 "" _null_ _null_ _null_ _null_ _null_ pg_stop_backup _null_ _null_ _null_ ));
diff --git a/src/include/storage/backend_signal.h b/src/include/storage/backend_signal.h
new file mode 100644
index 0000000000..5bb04615fd
--- /dev/null
+++ b/src/include/storage/backend_signal.h
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.h
+ *		Declarations for backend signalling
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/backend_signal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BACKEND_SIGNAL_H
+#define BACKEND_SIGNAL_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size CancelBackendMsgShmemSize(void);
+extern void BackendCancelMessageShmemInit(void);
+extern void BackendCancelMessageInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern bool HasCancelMessage(void);
+extern int ConsumeCancelMessage(char *msg, size_t len);
+
+#endif /* BACKEND_SIGNAL_H */
diff --git a/src/test/regress/expected/admin_funcs.out b/src/test/regress/expected/admin_funcs.out
new file mode 100644
index 0000000000..5bf5b6bc1e
--- /dev/null
+++ b/src/test/regress/expected/admin_funcs.out
@@ -0,0 +1,29 @@
+select pg_cancel_backend();
+ERROR:  function pg_cancel_backend() does not exist
+LINE 1: select pg_cancel_backend();
+               ^
+HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
+select pg_cancel_backend(NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(pg_backend_pid());
+ERROR:  canceling statement due to user request
+select pg_cancel_backend(NULL, NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(NULL, 'suicide is painless');
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(pg_backend_pid(), 'it brings on many changes');
+ERROR:  canceling statement due to user request: "it brings on many changes"
+select pg_cancel_backend(pg_backend_pid(), NULL);
+ERROR:  canceling statement due to user request
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index d858a0e7db..ee644cc0b5 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -84,7 +84,7 @@ test: select_into select_distinct select_distinct_on select_implicit select_havi
 # ----------
 # Another group of parallel tests
 # ----------
-test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index
+test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index admin_funcs
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/admin_funcs.sql b/src/test/regress/sql/admin_funcs.sql
new file mode 100644
index 0000000000..420d782b80
--- /dev/null
+++ b/src/test/regress/sql/admin_funcs.sql
@@ -0,0 +1,7 @@
+select pg_cancel_backend();
+select pg_cancel_backend(NULL);
+select pg_cancel_backend(pg_backend_pid());
+select pg_cancel_backend(NULL, NULL);
+select pg_cancel_backend(NULL, 'suicide is painless');
+select pg_cancel_backend(pg_backend_pid(), 'it brings on many changes');
+select pg_cancel_backend(pg_backend_pid(), NULL);
-- 
2.14.1.145.gb3622a4ee

From b7f45fb74361e94e97991493951aad73897647db Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Mon, 5 Mar 2018 12:16:16 +0100
Subject: [PATCH 1/2] Refactor backend signalling code

This moves the system administration functions for signalling backends
from backend/utils/adt/misc.c into a separate file dedicated to backend
signalling. No new functionality is introduced in this commit.
---
 src/backend/storage/ipc/Makefile         |   6 +-
 src/backend/storage/ipc/backend_signal.c | 190 +++++++++++++++++++++++++++++++
 src/backend/utils/adt/misc.c             | 168 ---------------------------
 3 files changed, 193 insertions(+), 171 deletions(-)
 create mode 100644 src/backend/storage/ipc/backend_signal.c

diff --git a/src/backend/storage/ipc/Makefile b/src/backend/storage/ipc/Makefile
index 9dbdc26c9b..ac35c197e0 100644
--- a/src/backend/storage/ipc/Makefile
+++ b/src/backend/storage/ipc/Makefile
@@ -8,8 +8,8 @@ subdir = src/backend/storage/ipc
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o pmsignal.o procarray.o \
-	procsignal.o  shmem.o shmqueue.o shm_mq.o shm_toc.o sinval.o \
-	sinvaladt.o standby.o
+OBJS = backend_signal.o barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o \
+	pmsignal.o procarray.o procsignal.o shmem.o shmqueue.o shm_mq.o \
+	shm_toc.o sinval.o sinvaladt.o standby.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
new file mode 100644
index 0000000000..603b229149
--- /dev/null
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -0,0 +1,190 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.c
+ *	  Routines for signalling backends
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/ipc/backend_signal.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <signal.h>
+
+#include "catalog/pg_authid.h"
+#include "funcapi.h"
+#include "miscadmin.h"
+#include "postmaster/syslogger.h"
+#include "storage/pmsignal.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "utils/builtins.h"
+
+/*
+ * Send a signal to another backend.
+ *
+ * The signal is delivered if the user is either a superuser or the same
+ * role as the backend being signaled. For "dangerous" signals, an explicit
+ * check for superuser needs to be done prior to calling this function.
+ *
+ * Returns 0 on success, 1 on general failure, 2 on normal permission error
+ * and 3 if the caller needs to be a superuser.
+ *
+ * In the event of a general failure (return code 1), a warning message will
+ * be emitted. For permission errors, doing that is the responsibility of
+ * the caller.
+ */
+#define SIGNAL_BACKEND_SUCCESS 0
+#define SIGNAL_BACKEND_ERROR 1
+#define SIGNAL_BACKEND_NOPERMISSION 2
+#define SIGNAL_BACKEND_NOSUPERUSER 3
+static int
+pg_signal_backend(int pid, int sig)
+{
+	PGPROC	   *proc = BackendPidGetProc(pid);
+
+	/*
+	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
+	 * we reach kill(), a process for which we get a valid proc here might
+	 * have terminated on its own.  There's no way to acquire a lock on an
+	 * arbitrary process to prevent that. But since so far all the callers of
+	 * this mechanism involve some request for ending the process anyway, that
+	 * it might end on its own first is not a problem.
+	 */
+	if (proc == NULL)
+	{
+		/*
+		 * This is just a warning so a loop-through-resultset will not abort
+		 * if one backend terminated on its own during the run.
+		 */
+		ereport(WARNING,
+				(errmsg("PID %d is not a PostgreSQL server process", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+
+	/* Only allow superusers to signal superuser-owned backends. */
+	if (superuser_arg(proc->roleId) && !superuser())
+		return SIGNAL_BACKEND_NOSUPERUSER;
+
+	/* Users can signal backends they have role membership in. */
+	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
+		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
+		return SIGNAL_BACKEND_NOPERMISSION;
+
+	/*
+	 * Can the process we just validated above end, followed by the pid being
+	 * recycled for a new process, before reaching here?  Then we'd be trying
+	 * to kill the wrong thing.  Seems near impossible when sequential pid
+	 * assignment and wraparound is used.  Perhaps it could happen on a system
+	 * where pid re-use is randomized.  That race condition possibility seems
+	 * too unlikely to worry about.
+	 */
+
+	/* If we have setsid(), signal the backend's whole process group */
+#ifdef HAVE_SETSID
+	if (kill(-pid, sig))
+#else
+	if (kill(pid, sig))
+#endif
+	{
+		/* Again, just a warning to allow loops */
+		ereport(WARNING,
+				(errmsg("could not send signal to process %d: %m", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+	return SIGNAL_BACKEND_SUCCESS;
+}
+
+/*
+ * Signal to cancel a backend process.  This is allowed if you are a member of
+ * the role whose process is being canceled.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to cancel superuser query"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to terminate a backend process.  This is allowed if you are a member
+ * of the role whose process is being terminated.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to terminate superuser process"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to reload the database configuration
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_reload_conf(PG_FUNCTION_ARGS)
+{
+	if (kill(PostmasterPid, SIGHUP))
+	{
+		ereport(WARNING,
+				(errmsg("failed to send signal to postmaster: %m")));
+		PG_RETURN_BOOL(false);
+	}
+
+	PG_RETURN_BOOL(true);
+}
+
+
+/*
+ * Rotate log file
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_rotate_logfile(PG_FUNCTION_ARGS)
+{
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index 2e1e020c4b..5bfe789c0c 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -15,13 +15,11 @@
 #include "postgres.h"
 
 #include <sys/file.h>
-#include <signal.h>
 #include <dirent.h>
 #include <math.h>
 #include <unistd.h>
 
 #include "access/sysattr.h"
-#include "catalog/pg_authid.h"
 #include "catalog/catalog.h"
 #include "catalog/pg_tablespace.h"
 #include "catalog/pg_type.h"
@@ -35,9 +33,6 @@
 #include "postmaster/syslogger.h"
 #include "rewrite/rewriteHandler.h"
 #include "storage/fd.h"
-#include "storage/pmsignal.h"
-#include "storage/proc.h"
-#include "storage/procarray.h"
 #include "utils/lsyscache.h"
 #include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
@@ -198,169 +193,6 @@ current_query(PG_FUNCTION_ARGS)
 		PG_RETURN_NULL();
 }
 
-/*
- * Send a signal to another backend.
- *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
- *
- * Returns 0 on success, 1 on general failure, 2 on normal permission error
- * and 3 if the caller needs to be a superuser.
- *
- * In the event of a general failure (return code 1), a warning message will
- * be emitted. For permission errors, doing that is the responsibility of
- * the caller.
- */
-#define SIGNAL_BACKEND_SUCCESS 0
-#define SIGNAL_BACKEND_ERROR 1
-#define SIGNAL_BACKEND_NOPERMISSION 2
-#define SIGNAL_BACKEND_NOSUPERUSER 3
-static int
-pg_signal_backend(int pid, int sig)
-{
-	PGPROC	   *proc = BackendPidGetProc(pid);
-
-	/*
-	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
-	 * we reach kill(), a process for which we get a valid proc here might
-	 * have terminated on its own.  There's no way to acquire a lock on an
-	 * arbitrary process to prevent that. But since so far all the callers of
-	 * this mechanism involve some request for ending the process anyway, that
-	 * it might end on its own first is not a problem.
-	 */
-	if (proc == NULL)
-	{
-		/*
-		 * This is just a warning so a loop-through-resultset will not abort
-		 * if one backend terminated on its own during the run.
-		 */
-		ereport(WARNING,
-				(errmsg("PID %d is not a PostgreSQL server process", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-
-	/* Only allow superusers to signal superuser-owned backends. */
-	if (superuser_arg(proc->roleId) && !superuser())
-		return SIGNAL_BACKEND_NOSUPERUSER;
-
-	/* Users can signal backends they have role membership in. */
-	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
-		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
-		return SIGNAL_BACKEND_NOPERMISSION;
-
-	/*
-	 * Can the process we just validated above end, followed by the pid being
-	 * recycled for a new process, before reaching here?  Then we'd be trying
-	 * to kill the wrong thing.  Seems near impossible when sequential pid
-	 * assignment and wraparound is used.  Perhaps it could happen on a system
-	 * where pid re-use is randomized.  That race condition possibility seems
-	 * too unlikely to worry about.
-	 */
-
-	/* If we have setsid(), signal the backend's whole process group */
-#ifdef HAVE_SETSID
-	if (kill(-pid, sig))
-#else
-	if (kill(pid, sig))
-#endif
-	{
-		/* Again, just a warning to allow loops */
-		ereport(WARNING,
-				(errmsg("could not send signal to process %d: %m", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-	return SIGNAL_BACKEND_SUCCESS;
-}
-
-/*
- * Signal to cancel a backend process.  This is allowed if you are a member of
- * the role whose process is being canceled.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to cancel superuser query"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to terminate a backend process.  This is allowed if you are a member
- * of the role whose process is being terminated.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to terminate superuser process"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to reload the database configuration
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_reload_conf(PG_FUNCTION_ARGS)
-{
-	if (kill(PostmasterPid, SIGHUP))
-	{
-		ereport(WARNING,
-				(errmsg("failed to send signal to postmaster: %m")));
-		PG_RETURN_BOOL(false);
-	}
-
-	PG_RETURN_BOOL(true);
-}
-
-
-/*
- * Rotate log file
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_rotate_logfile(PG_FUNCTION_ARGS)
-{
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
 /* Function to find out which databases make use of a tablespace */
 
 typedef struct
-- 
2.14.1.145.gb3622a4ee

From a8519a37d0937091b8e179a75bc7867067ec4162 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Thu, 25 Jan 2018 23:49:37 +0100
Subject: [PATCH 2/2] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend() or
pg_cancel_backend() to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
overloaded the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);
---
 doc/src/sgml/func.sgml                    |  12 +-
 src/backend/storage/ipc/backend_signal.c  | 275 ++++++++++++++++++++++++++++--
 src/backend/storage/ipc/ipci.c            |   3 +
 src/backend/tcop/postgres.c               |  38 ++++-
 src/backend/utils/init/postinit.c         |   2 +
 src/include/catalog/pg_proc.h             |   5 +
 src/include/storage/backend_signal.h      |  25 +++
 src/test/regress/expected/admin_funcs.out |  29 ++++
 src/test/regress/parallel_schedule        |   2 +-
 src/test/regress/sql/admin_funcs.sql      |   7 +
 10 files changed, 377 insertions(+), 21 deletions(-)
 create mode 100644 src/include/storage/backend_signal.h
 create mode 100644 src/test/regress/expected/admin_funcs.out
 create mode 100644 src/test/regress/sql/admin_funcs.sql

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 6257563eaa..0b7b49a635 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18512,7 +18512,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18537,7 +18537,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18568,6 +18568,14 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, the text
+    will be appended to the error message returned to the signalled backend.
+    <literal>message</literal> is limited to 128 bytes, any longer text
+    will be truncated. An example where we cancel our own backend:
+<programlisting>
+postgres=# SELECT pg_cancel_backend(pg_backend_pid(), 'Cancellation message text');
+ERROR:  canceling statement due to user request: Cancellation message text
+</programlisting>
    </para>
 
    <para>
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
index 603b229149..895e1be775 100644
--- a/src/backend/storage/ipc/backend_signal.c
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -18,19 +18,42 @@
 
 #include "catalog/pg_authid.h"
 #include "funcapi.h"
+#include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "postmaster/syslogger.h"
+#include "storage/backend_signal.h"
+#include "storage/ipc.h"
 #include "storage/pmsignal.h"
 #include "storage/proc.h"
 #include "storage/procarray.h"
 #include "utils/builtins.h"
 
+/*
+ * Structure for registering a message to be sent to a cancelled, or terminated
+ * backend. Each backend is registered per pid in the array which is indexed by
+ * Backend ID. Reading and writing the message is protected by a per-slot
+ * spinlock.
+ */
+typedef struct
+{
+	pid_t	pid;
+	slock_t	mutex;
+	char	message[MAX_CANCEL_MSG];
+	int		len;
+} BackendCancelShmemStruct;
+
+static BackendCancelShmemStruct	*BackendCancelSlots = NULL;
+static volatile BackendCancelShmemStruct *MyCancelSlot = NULL;
+static void CleanupCancelBackend(int status, Datum argument);
+
 /*
  * Send a signal to another backend.
  *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
+ * The signal is delivered if the user is either a superuser or the same role
+ * as the backend being signaled. For "dangerous" signals, an explicit check
+ * for superuser needs to be done prior to calling this function. If msg is
+ * set, the contents will be passed as a message to the backend in the error
+ * message.
  *
  * Returns 0 on success, 1 on general failure, 2 on normal permission error
  * and 3 if the caller needs to be a superuser.
@@ -44,7 +67,7 @@
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -76,6 +99,10 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+		SetBackendCancelMessage(pid, msg);
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -106,10 +133,10 @@ pg_signal_backend(int pid, int sig)
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
+static bool
+pg_cancel_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -124,16 +151,39 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
 }
 
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_cancel_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_cancel_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_cancel_backend_internal(pid, msg));
+}
+
 /*
  * Signal to terminate a backend process.  This is allowed if you are a member
  * of the role whose process is being terminated.
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
+static bool
+pg_terminate_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int		r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -145,7 +195,30 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
+}
+
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_terminate_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_terminate_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_terminate_backend_internal(pid, msg));
 }
 
 /*
@@ -167,7 +240,6 @@ pg_reload_conf(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(true);
 }
 
-
 /*
  * Rotate log file
  *
@@ -188,3 +260,182 @@ pg_rotate_logfile(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(true);
 }
 
+/*
+ * The following routines handle registering an optional message when
+ * cancelling, or terminating a backend. The message will be stored in
+ * shared memory and is limited to MAX_CANCEL_MSG characters including
+ * the NULL terminator.
+ *
+ * Access to the message slots is protected by spinlocks.
+ */
+
+/*
+ * Return the required size for the cancelation message Shmem area.
+ */
+Size
+CancelBackendMsgShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendCancelShmemStruct);
+}
+
+/*
+ * Create and initialize the Shmem structure for holding the messages, the
+ * bookkeeping for them and the spinlocks associated.
+ */
+void
+BackendCancelMessageShmemInit(void)
+{
+	Size	size = CancelBackendMsgShmemSize();
+	bool	found;
+	int		i;
+
+	BackendCancelSlots = (BackendCancelShmemStruct *)
+		ShmemInitStruct("BackendCancelSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendCancelSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendCancelSlots[i].mutex));
+	}
+}
+
+/*
+ * Set up the slot for the current backend_id
+ */
+void
+BackendCancelMessageInit(int backend_id)
+{
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->len = 0;
+	slot->pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupCancelBackend, Int32GetDatum(backend_id));
+}
+
+/*
+ * Ensure that the slot is purged and emptied at exit. Any message gets
+ * overwritten with null chars to avoid risking exposing a message intended for
+ * another backend to a new backend.
+ */
+static void
+CleanupCancelBackend(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendCancelShmemStruct *slot;
+
+	slot = &BackendCancelSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->len > 0)
+		MemSet(slot->message, '\0', sizeof(slot->message));
+
+	slot->len = 0;
+	slot->pid = 0;
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns the length of the message actually created. If the returned length
+ * is less than the length of the message parameter, truncation has occurred.
+ * If the backend isn't found, -1 is returned. If no message is passed, zero is
+ * returned. If two backends collide in setting a message, the existing message
+ * will be overwritten by the last one in.
+ */
+int
+SetBackendCancelMessage(pid_t backend_pid, char *message)
+{
+	int		i;
+	int		len;
+
+	if (!message)
+		return 0;
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		BackendCancelShmemStruct *slot = &BackendCancelSlots[i];
+
+		if (slot->pid != 0 && slot->pid == backend_pid)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->pid != backend_pid)
+			{
+				SpinLockRelease(&slot->mutex);
+				goto error;
+			}
+
+			len = pg_mbcliplen(message, strlen(message),
+							   sizeof(slot->message) - 1);
+			MemSet(slot->message, '\0', sizeof(slot->message));
+			memcpy(slot->message, message, len);
+			slot->len = len;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return len;
+		}
+	}
+
+error:
+
+	elog(LOG, "Cancellation message requested for missing backend %d by %d",
+		 (int) backend_pid, MyProcPid);
+
+	return -1;
+}
+
+/*
+ * Test whether there is a cancelation message for the current backend that
+ * can be consumed and presented to the user.
+ */
+bool
+HasCancelMessage(void)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = (slot->len > 0);
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * Return the configured cancellation message and its length. If the returned
+ * length is greater than the size of the passed buffer, truncation has been
+ * performed. The message is cleared on reading.
+ */
+int
+ConsumeCancelMessage(char *buffer, size_t buf_len)
+{
+	volatile BackendCancelShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->len > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->len;
+		slot->len = 0;
+		slot->message[0] = '\0';
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 853e1e472f..fa178c766b 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -34,6 +34,7 @@
 #include "replication/walreceiver.h"
 #include "replication/walsender.h"
 #include "replication/origin.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/dsm.h"
 #include "storage/ipc.h"
@@ -151,6 +152,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, CancelBackendMsgShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -272,6 +274,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendCancelMessageShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 7bdecc32ec..fca6d450ac 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -61,6 +61,7 @@
 #include "replication/slot.h"
 #include "replication/walsender.h"
 #include "rewrite/rewriteHandler.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
 #include "storage/proc.h"
@@ -2919,9 +2920,22 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasCancelMessage())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+
+				ConsumeCancelMessage(buffer, MAX_CANCEL_MSG);
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command: %s",
+						 buffer)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3032,9 +3046,21 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasCancelMessage())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+
+				ConsumeCancelMessage(buffer, MAX_CANCEL_MSG);
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request: %s",
+								buffer)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 09e0df290d..87948f4a19 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -40,6 +40,7 @@
 #include "postmaster/autovacuum.h"
 #include "postmaster/postmaster.h"
 #include "replication/walsender.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/fd.h"
 #include "storage/ipc.h"
@@ -747,6 +748,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendCancelMessageInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h
index 02be8a5fbd..43aacaa299 100644
--- a/src/include/catalog/pg_proc.h
+++ b/src/include/catalog/pg_proc.h
@@ -3307,8 +3307,13 @@ DESCR("is schema another session's temp schema?");
 
 DATA(insert OID = 2171 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f t f v s 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 = 6108 ( pg_cancel_backend		PGNSP PGUID 12 1 0 0 0 f f f f f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_cancel_backend_msg _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 t f v s 1 0 16 "23" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ ));
 DESCR("terminate a server process");
+DATA(insert OID = 6107 ( pg_terminate_backend		PGNSP PGUID 12 1 0 0 0 f f f f f v s 2 0 16 "23 25" _null_ _null_ _null_ _null_ _null_ pg_terminate_backend_msg _null_ _null_ _null_ ));
+DESCR("terminate a server process");
 DATA(insert OID = 2172 ( pg_start_backup		PGNSP PGUID 12 1 0 0 0 f f f t f v r 3 0 3220 "25 16 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 t f v r 0 0 3220 "" _null_ _null_ _null_ _null_ _null_ pg_stop_backup _null_ _null_ _null_ ));
diff --git a/src/include/storage/backend_signal.h b/src/include/storage/backend_signal.h
new file mode 100644
index 0000000000..5bb04615fd
--- /dev/null
+++ b/src/include/storage/backend_signal.h
@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.h
+ *		Declarations for backend signalling
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/backend_signal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BACKEND_SIGNAL_H
+#define BACKEND_SIGNAL_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size CancelBackendMsgShmemSize(void);
+extern void BackendCancelMessageShmemInit(void);
+extern void BackendCancelMessageInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern bool HasCancelMessage(void);
+extern int ConsumeCancelMessage(char *msg, size_t len);
+
+#endif /* BACKEND_SIGNAL_H */
diff --git a/src/test/regress/expected/admin_funcs.out b/src/test/regress/expected/admin_funcs.out
new file mode 100644
index 0000000000..4661cdbc75
--- /dev/null
+++ b/src/test/regress/expected/admin_funcs.out
@@ -0,0 +1,29 @@
+select pg_cancel_backend();
+ERROR:  function pg_cancel_backend() does not exist
+LINE 1: select pg_cancel_backend();
+               ^
+HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
+select pg_cancel_backend(NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(pg_backend_pid());
+ERROR:  canceling statement due to user request
+select pg_cancel_backend(NULL, NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(NULL, 'suicide is painless');
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(pg_backend_pid(), 'it brings on many changes');
+ERROR:  canceling statement due to user request: it brings on many changes
+select pg_cancel_backend(pg_backend_pid(), NULL);
+ERROR:  canceling statement due to user request
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 20d6745730..c4872e3d58 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -84,7 +84,7 @@ test: select_into select_distinct select_distinct_on select_implicit select_havi
 # ----------
 # Another group of parallel tests
 # ----------
-test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index merge
+test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index merge admin_funcs
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/admin_funcs.sql b/src/test/regress/sql/admin_funcs.sql
new file mode 100644
index 0000000000..420d782b80
--- /dev/null
+++ b/src/test/regress/sql/admin_funcs.sql
@@ -0,0 +1,7 @@
+select pg_cancel_backend();
+select pg_cancel_backend(NULL);
+select pg_cancel_backend(pg_backend_pid());
+select pg_cancel_backend(NULL, NULL);
+select pg_cancel_backend(NULL, 'suicide is painless');
+select pg_cancel_backend(pg_backend_pid(), 'it brings on many changes');
+select pg_cancel_backend(pg_backend_pid(), NULL);
-- 
2.14.1.145.gb3622a4ee

From 86159f2d40bf44bf4ae55a1cb71dbd986c440419 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Wed, 13 Jun 2018 10:23:04 +0200
Subject: [PATCH 1/2] Refactor backend signalling code

This moves the system administration functions for signalling backends
from backend/utils/adt/misc.c into a separate file dedicated to backend
signalling. No new functionality is introduced in this commit.
---
 src/backend/storage/ipc/Makefile         |   6 +-
 src/backend/storage/ipc/backend_signal.c | 216 +++++++++++++++++++++++++++++++
 src/backend/utils/adt/misc.c             | 194 ---------------------------
 3 files changed, 219 insertions(+), 197 deletions(-)
 create mode 100644 src/backend/storage/ipc/backend_signal.c

diff --git a/src/backend/storage/ipc/Makefile b/src/backend/storage/ipc/Makefile
index 9dbdc26c9b..ac35c197e0 100644
--- a/src/backend/storage/ipc/Makefile
+++ b/src/backend/storage/ipc/Makefile
@@ -8,8 +8,8 @@ subdir = src/backend/storage/ipc
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o pmsignal.o procarray.o \
-	procsignal.o  shmem.o shmqueue.o shm_mq.o shm_toc.o sinval.o \
-	sinvaladt.o standby.o
+OBJS = backend_signal.o barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o \
+	pmsignal.o procarray.o procsignal.o shmem.o shmqueue.o shm_mq.o \
+	shm_toc.o sinval.o sinvaladt.o standby.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
new file mode 100644
index 0000000000..2b81c161d9
--- /dev/null
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -0,0 +1,216 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.c
+ *	  Routines for signalling backends
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/ipc/backend_signal.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <signal.h>
+
+#include "catalog/pg_authid.h"
+#include "funcapi.h"
+#include "miscadmin.h"
+#include "postmaster/syslogger.h"
+#include "storage/pmsignal.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "utils/acl.h"
+#include "utils/builtins.h"
+
+/*
+ * Send a signal to another backend.
+ *
+ * The signal is delivered if the user is either a superuser or the same
+ * role as the backend being signaled. For "dangerous" signals, an explicit
+ * check for superuser needs to be done prior to calling this function.
+ *
+ * Returns 0 on success, 1 on general failure, 2 on normal permission error
+ * and 3 if the caller needs to be a superuser.
+ *
+ * In the event of a general failure (return code 1), a warning message will
+ * be emitted. For permission errors, doing that is the responsibility of
+ * the caller.
+ */
+#define SIGNAL_BACKEND_SUCCESS 0
+#define SIGNAL_BACKEND_ERROR 1
+#define SIGNAL_BACKEND_NOPERMISSION 2
+#define SIGNAL_BACKEND_NOSUPERUSER 3
+static int
+pg_signal_backend(int pid, int sig)
+{
+	PGPROC	   *proc = BackendPidGetProc(pid);
+
+	/*
+	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
+	 * we reach kill(), a process for which we get a valid proc here might
+	 * have terminated on its own.  There's no way to acquire a lock on an
+	 * arbitrary process to prevent that. But since so far all the callers of
+	 * this mechanism involve some request for ending the process anyway, that
+	 * it might end on its own first is not a problem.
+	 */
+	if (proc == NULL)
+	{
+		/*
+		 * This is just a warning so a loop-through-resultset will not abort
+		 * if one backend terminated on its own during the run.
+		 */
+		ereport(WARNING,
+				(errmsg("PID %d is not a PostgreSQL server process", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+
+	/* Only allow superusers to signal superuser-owned backends. */
+	if (superuser_arg(proc->roleId) && !superuser())
+		return SIGNAL_BACKEND_NOSUPERUSER;
+
+	/* Users can signal backends they have role membership in. */
+	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
+		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
+		return SIGNAL_BACKEND_NOPERMISSION;
+
+	/*
+	 * Can the process we just validated above end, followed by the pid being
+	 * recycled for a new process, before reaching here?  Then we'd be trying
+	 * to kill the wrong thing.  Seems near impossible when sequential pid
+	 * assignment and wraparound is used.  Perhaps it could happen on a system
+	 * where pid re-use is randomized.  That race condition possibility seems
+	 * too unlikely to worry about.
+	 */
+
+	/* If we have setsid(), signal the backend's whole process group */
+#ifdef HAVE_SETSID
+	if (kill(-pid, sig))
+#else
+	if (kill(pid, sig))
+#endif
+	{
+		/* Again, just a warning to allow loops */
+		ereport(WARNING,
+				(errmsg("could not send signal to process %d: %m", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+	return SIGNAL_BACKEND_SUCCESS;
+}
+
+/*
+ * Signal to cancel a backend process.  This is allowed if you are a member of
+ * the role whose process is being canceled.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to cancel superuser query"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to terminate a backend process.  This is allowed if you are a member
+ * of the role whose process is being terminated.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to terminate superuser process"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to reload the database configuration
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_reload_conf(PG_FUNCTION_ARGS)
+{
+	if (kill(PostmasterPid, SIGHUP))
+	{
+		ereport(WARNING,
+				(errmsg("failed to send signal to postmaster: %m")));
+		PG_RETURN_BOOL(false);
+	}
+
+	PG_RETURN_BOOL(true);
+}
+
+
+/*
+ * Rotate log file
+ *
+ * This function is kept to support adminpack 1.0.
+ */
+Datum
+pg_rotate_logfile(PG_FUNCTION_ARGS)
+{
+	if (!superuser())
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be superuser to rotate log files with adminpack 1.0"),
+				  errhint("Consider using pg_logfile_rotate(), which is part of core, instead."))));
+
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
+/*
+ * Rotate log file
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
+{
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index b24dece23f..6ea3679835 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -15,13 +15,11 @@
 #include "postgres.h"
 
 #include <sys/file.h>
-#include <signal.h>
 #include <dirent.h>
 #include <math.h>
 #include <unistd.h>
 
 #include "access/sysattr.h"
-#include "catalog/pg_authid.h"
 #include "catalog/catalog.h"
 #include "catalog/pg_tablespace.h"
 #include "catalog/pg_type.h"
@@ -35,13 +33,9 @@
 #include "postmaster/syslogger.h"
 #include "rewrite/rewriteHandler.h"
 #include "storage/fd.h"
-#include "storage/pmsignal.h"
-#include "storage/proc.h"
-#include "storage/procarray.h"
 #include "utils/lsyscache.h"
 #include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
-#include "utils/acl.h"
 #include "utils/builtins.h"
 #include "utils/timestamp.h"
 
@@ -198,194 +192,6 @@ current_query(PG_FUNCTION_ARGS)
 		PG_RETURN_NULL();
 }
 
-/*
- * Send a signal to another backend.
- *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
- *
- * Returns 0 on success, 1 on general failure, 2 on normal permission error
- * and 3 if the caller needs to be a superuser.
- *
- * In the event of a general failure (return code 1), a warning message will
- * be emitted. For permission errors, doing that is the responsibility of
- * the caller.
- */
-#define SIGNAL_BACKEND_SUCCESS 0
-#define SIGNAL_BACKEND_ERROR 1
-#define SIGNAL_BACKEND_NOPERMISSION 2
-#define SIGNAL_BACKEND_NOSUPERUSER 3
-static int
-pg_signal_backend(int pid, int sig)
-{
-	PGPROC	   *proc = BackendPidGetProc(pid);
-
-	/*
-	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
-	 * we reach kill(), a process for which we get a valid proc here might
-	 * have terminated on its own.  There's no way to acquire a lock on an
-	 * arbitrary process to prevent that. But since so far all the callers of
-	 * this mechanism involve some request for ending the process anyway, that
-	 * it might end on its own first is not a problem.
-	 */
-	if (proc == NULL)
-	{
-		/*
-		 * This is just a warning so a loop-through-resultset will not abort
-		 * if one backend terminated on its own during the run.
-		 */
-		ereport(WARNING,
-				(errmsg("PID %d is not a PostgreSQL server process", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-
-	/* Only allow superusers to signal superuser-owned backends. */
-	if (superuser_arg(proc->roleId) && !superuser())
-		return SIGNAL_BACKEND_NOSUPERUSER;
-
-	/* Users can signal backends they have role membership in. */
-	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
-		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
-		return SIGNAL_BACKEND_NOPERMISSION;
-
-	/*
-	 * Can the process we just validated above end, followed by the pid being
-	 * recycled for a new process, before reaching here?  Then we'd be trying
-	 * to kill the wrong thing.  Seems near impossible when sequential pid
-	 * assignment and wraparound is used.  Perhaps it could happen on a system
-	 * where pid re-use is randomized.  That race condition possibility seems
-	 * too unlikely to worry about.
-	 */
-
-	/* If we have setsid(), signal the backend's whole process group */
-#ifdef HAVE_SETSID
-	if (kill(-pid, sig))
-#else
-	if (kill(pid, sig))
-#endif
-	{
-		/* Again, just a warning to allow loops */
-		ereport(WARNING,
-				(errmsg("could not send signal to process %d: %m", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-	return SIGNAL_BACKEND_SUCCESS;
-}
-
-/*
- * Signal to cancel a backend process.  This is allowed if you are a member of
- * the role whose process is being canceled.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to cancel superuser query"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to terminate a backend process.  This is allowed if you are a member
- * of the role whose process is being terminated.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to terminate superuser process"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to reload the database configuration
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_reload_conf(PG_FUNCTION_ARGS)
-{
-	if (kill(PostmasterPid, SIGHUP))
-	{
-		ereport(WARNING,
-				(errmsg("failed to send signal to postmaster: %m")));
-		PG_RETURN_BOOL(false);
-	}
-
-	PG_RETURN_BOOL(true);
-}
-
-
-/*
- * Rotate log file
- *
- * This function is kept to support adminpack 1.0.
- */
-Datum
-pg_rotate_logfile(PG_FUNCTION_ARGS)
-{
-	if (!superuser())
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be superuser to rotate log files with adminpack 1.0"),
-				  errhint("Consider using pg_logfile_rotate(), which is part of core, instead."))));
-
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
-/*
- * Rotate log file
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
-{
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
 /* Function to find out which databases make use of a tablespace */
 
 typedef struct
-- 
2.14.1.145.gb3622a4ee

From 67790ed15f6afeea8890f17407af87dd3d5347ef Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Wed, 13 Jun 2018 10:23:07 +0200
Subject: [PATCH 2/2] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend() or
pg_cancel_backend() to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
overloaded the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);

The backend API also expose functionality for altering the errcode
used when terminating or canceling the backend.
---
 doc/src/sgml/func.sgml                    |  12 +-
 src/backend/storage/ipc/backend_signal.c  | 320 ++++++++++++++++++++++++++++--
 src/backend/storage/ipc/ipci.c            |   3 +
 src/backend/tcop/postgres.c               |  55 ++++-
 src/backend/utils/init/postinit.c         |   2 +
 src/include/catalog/pg_proc.dat           |   6 +
 src/include/storage/backend_signal.h      |  27 +++
 src/test/regress/expected/admin_funcs.out |  29 +++
 src/test/regress/parallel_schedule        |   2 +-
 src/test/regress/sql/admin_funcs.sql      |   7 +
 10 files changed, 442 insertions(+), 21 deletions(-)
 create mode 100644 src/include/storage/backend_signal.h
 create mode 100644 src/test/regress/expected/admin_funcs.out
 create mode 100644 src/test/regress/sql/admin_funcs.sql

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index b851fe023a..ad9763698f 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18540,7 +18540,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18565,7 +18565,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18596,6 +18596,14 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, the text
+    will be appended to the error message returned to the signalled backend.
+    <literal>message</literal> is limited to 128 bytes, any longer text
+    will be truncated. An example where we cancel our own backend:
+<programlisting>
+postgres=# SELECT pg_cancel_backend(pg_backend_pid(), 'Cancellation message text');
+ERROR:  canceling statement due to user request: Cancellation message text
+</programlisting>
    </para>
 
    <para>
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
index 2b81c161d9..69a7f106d4 100644
--- a/src/backend/storage/ipc/backend_signal.c
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -18,20 +18,45 @@
 
 #include "catalog/pg_authid.h"
 #include "funcapi.h"
+#include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "postmaster/syslogger.h"
+#include "storage/backend_signal.h"
+#include "storage/ipc.h"
 #include "storage/pmsignal.h"
 #include "storage/proc.h"
 #include "storage/procarray.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
 
+/*
+ * Structure for registering a feedback payload to be sent to a cancelled, or
+ * terminated backend. Each backend is registered per pid in the array which is
+ * indexed by Backend ID. Reading and writing the message is protected by a
+ * per-slot spinlock.
+ */
+typedef struct
+{
+	pid_t	pid;
+	slock_t	mutex;
+	char	message[MAX_CANCEL_MSG];
+	int		len;
+	int		sqlerrcode;
+} BackendSignalFeedbackShmemStruct;
+
+static BackendSignalFeedbackShmemStruct	*BackendSignalFeedbackSlots = NULL;
+static volatile BackendSignalFeedbackShmemStruct *MyCancelSlot = NULL;
+static void CleanupBackendSignalFeedback(int status, Datum argument);
+static int backend_feedback(pid_t backend_pid, char *message, int sqlerrcode);
+
 /*
  * Send a signal to another backend.
  *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
+ * The signal is delivered if the user is either a superuser or the same role
+ * as the backend being signaled. For "dangerous" signals, an explicit check
+ * for superuser needs to be done prior to calling this function. If msg is
+ * set, the contents will be passed as a message to the backend in the error
+ * message.
  *
  * Returns 0 on success, 1 on general failure, 2 on normal permission error
  * and 3 if the caller needs to be a superuser.
@@ -45,7 +70,7 @@
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -77,6 +102,15 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+	{
+		if (sig == SIGINT)
+			SetBackendCancelMessage(pid, msg);
+		else
+			SetBackendTerminationMessage(pid, msg);
+	}
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -107,10 +141,10 @@ pg_signal_backend(int pid, int sig)
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
+static bool
+pg_cancel_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -125,16 +159,39 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
 }
 
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_cancel_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_cancel_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_cancel_backend_internal(pid, msg));
+}
+
 /*
  * Signal to terminate a backend process.  This is allowed if you are a member
  * of the role whose process is being terminated.
  *
  * Note that only superusers can signal superuser-owned processes.
  */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
+static bool
+pg_terminate_backend_internal(pid_t pid, char *msg)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int		r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -146,7 +203,30 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
+}
+
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_BOOL(pg_terminate_backend_internal(PG_GETARG_INT32(0), NULL));
+}
+
+Datum
+pg_terminate_backend_msg(PG_FUNCTION_ARGS)
+{
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	PG_RETURN_BOOL(pg_terminate_backend_internal(pid, msg));
 }
 
 /*
@@ -168,7 +248,6 @@ pg_reload_conf(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(true);
 }
 
-
 /*
  * Rotate log file
  *
@@ -214,3 +293,220 @@ pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(true);
 }
 
+/*
+ * The following routines handle registering an optional message when
+ * cancelling, or terminating, a backend as well changing the sqlerrcode used.
+ * The combined payload of message/errcode is referred to as feedback.  The
+ * message will be stored in shared memory and is limited to MAX_CANCEL_MSG
+ * characters including the NULL terminator.
+ *
+ * Access to the feedback slots is protected by spinlocks.
+ */
+
+/*
+ * Return the required size for the cancelation feedback Shmem area.
+ */
+Size
+BackendSignalFeedbackShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendSignalFeedbackShmemStruct);
+}
+
+/*
+ * Create and initialize the Shmem structure for holding the feedback, the
+ * bookkeeping for them and the spinlocks associated.
+ */
+void
+BackendSignalFeedbackShmemInit(void)
+{
+	Size	size = BackendSignalFeedbackShmemSize();
+	bool	found;
+	int		i;
+
+	BackendSignalFeedbackSlots = (BackendSignalFeedbackShmemStruct *)
+		ShmemInitStruct("BackendSignalFeedbackSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendSignalFeedbackSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendSignalFeedbackSlots[i].mutex));
+	}
+}
+
+/*
+ * Set up the slot for the current backend_id
+ */
+void
+BackendSignalFeedbackInit(int backend_id)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->len = 0;
+	slot->sqlerrcode = 0;
+	slot->pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupBackendSignalFeedback, Int32GetDatum(backend_id));
+}
+
+/*
+ * Ensure that the slot is purged and emptied at exit. Any message gets
+ * overwritten with null chars to avoid risking exposing a message intended for
+ * another backend to a new backend.
+ */
+static void
+CleanupBackendSignalFeedback(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->len > 0)
+		MemSet(slot->message, '\0', sizeof(slot->message));
+
+	slot->len = 0;
+	slot->sqlerrcode = 0;
+	slot->pid = 0;
+}
+
+/*
+ * Set a message for the cancellation of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendCancelMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_QUERY_CANCELED);
+}
+
+/*
+ * Set a message for the termination of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendTerminationMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_ADMIN_SHUTDOWN);
+}
+
+/*
+ * Set both a message and a sqlerrcode for use when signalling the backend
+ * with the specified pid.
+ */
+int
+SetBackendSignalFeedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	return backend_feedback(backend_pid, message, sqlerrcode);
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns the length of the message actually created. If the returned length
+ * is less than the length of the message parameter, truncation has occurred.
+ * If the backend isn't found, -1 is returned. If no message is passed, zero is
+ * returned. If two backends collide in setting a message, the existing message
+ * will be overwritten by the last one in.
+ */
+static int
+backend_feedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	int		i;
+	int		len;
+
+	if (!message)
+		return 1;
+
+	len = pg_mbcliplen(message, strlen(message), MAX_CANCEL_MSG - 1);
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		BackendSignalFeedbackShmemStruct *slot = &BackendSignalFeedbackSlots[i];
+
+		if (slot->pid != 0 && slot->pid == backend_pid)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->pid != backend_pid)
+			{
+				SpinLockRelease(&slot->mutex);
+				goto error;
+			}
+
+			MemSet(slot->message, '\0', sizeof(slot->message));
+			memcpy(slot->message, message, len);
+			slot->len = len;
+			slot->sqlerrcode = sqlerrcode;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return 0;
+		}
+	}
+
+error:
+
+	elog(LOG, "Cancellation message requested for missing backend %d by %d",
+		 (int) backend_pid, MyProcPid);
+
+	return 1;
+}
+
+/*
+ * Test whether there is feedback registered for the current backend that can
+ * be consumed and presented to the user.
+ */
+bool
+HasBackendSignalFeedback(void)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = ((slot->len > 0) && (slot->sqlerrcode != 0));
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * Return the configured signal feedback. The length of the message is returned
+ * in buf_len. The original length of the message is returned, or zero in case
+ * no message was found. If the returned length is greater than the size of the passed
+ * buffer, truncation has been performed. The feedback (message and errcode) is
+ * cleared on reading.
+ */
+int
+ConsumeBackendSignalFeedback(char *buffer, size_t buf_len, int *sqlerrcode)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->len > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->len;
+		*sqlerrcode = slot->sqlerrcode;
+		slot->len = 0;
+		slot->message[0] = '\0';
+		slot->sqlerrcode = 0;
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 0c86a581c0..5d91450887 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -33,6 +33,7 @@
 #include "replication/walreceiver.h"
 #include "replication/walsender.h"
 #include "replication/origin.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/dsm.h"
 #include "storage/ipc.h"
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, BackendSignalFeedbackShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendSignalFeedbackShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index f4133953be..e9e41c738b 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -62,6 +62,7 @@
 #include "replication/slot.h"
 #include "replication/walsender.h"
 #include "rewrite/rewriteHandler.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
 #include "storage/proc.h"
@@ -2923,9 +2924,30 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_ADMIN_SHUTDOWN;
+					buffer[0] = '\0';
+				}
+				ereport(FATAL,
+						(errcode(sqlerrcode),
+						 errmsg("terminating connection due to administrator command: %s%s",
+						 buffer, (len > sizeof(buffer) ? "..." : ""))));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3036,9 +3058,30 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_QUERY_CANCELED;
+					buffer[0] = '\0';
+				}
+
+				ereport(ERROR,
+						(errcode(sqlerrcode),
+						 errmsg("canceling statement due to user request: %s%s",
+								buffer, (len > sizeof(buffer) ? "..." : ""))));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 09e0df290d..65ae347f8d 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -40,6 +40,7 @@
 #include "postmaster/autovacuum.h"
 #include "postmaster/postmaster.h"
 #include "replication/walsender.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/fd.h"
 #include "storage/ipc.h"
@@ -747,6 +748,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendSignalFeedbackInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 66c6c224a8..354fa302fd 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5973,9 +5973,15 @@
 { oid => '2171', descr => 'cancel a server process\' current query',
   proname => 'pg_cancel_backend', provolatile => 'v', prorettype => 'bool',
   proargtypes => 'int4', prosrc => 'pg_cancel_backend' },
+{ oid => '3423', descr => 'cancel a server process\' current query and send message',
+  proname => 'pg_cancel_backend', provolatile => 'v', prorettype => 'bool',
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_cancel_backend_msg' },
 { oid => '2096', descr => 'terminate a server process',
   proname => 'pg_terminate_backend', provolatile => 'v', prorettype => 'bool',
   proargtypes => 'int4', prosrc => 'pg_terminate_backend' },
+{ oid => '3424', descr => 'terminate a server process and send message',
+  proname => 'pg_terminate_backend', provolatile => 'v', prorettype => 'bool',
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_terminate_backend_msg' },
 { oid => '2172', descr => 'prepare for taking an online backup',
   proname => 'pg_start_backup', provolatile => 'v', proparallel => 'r',
   prorettype => 'pg_lsn', proargtypes => 'text bool bool',
diff --git a/src/include/storage/backend_signal.h b/src/include/storage/backend_signal.h
new file mode 100644
index 0000000000..e6431eba9c
--- /dev/null
+++ b/src/include/storage/backend_signal.h
@@ -0,0 +1,27 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.h
+ *		Declarations for backend signalling
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/backend_signal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BACKEND_SIGNAL_H
+#define BACKEND_SIGNAL_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size BackendSignalFeedbackShmemSize(void);
+extern void BackendSignalFeedbackShmemInit(void);
+extern void BackendSignalFeedbackInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern int SetBackendTerminationMessage(pid_t backend, char *message);
+extern int SetBackendSignalFeedback(pid_t backend, char *message, int sqlerrcode);
+extern bool HasBackendSignalFeedback(void);
+extern int ConsumeBackendSignalFeedback(char *msg, size_t len, int *sqlerrcode);
+
+#endif /* BACKEND_SIGNAL_H */
diff --git a/src/test/regress/expected/admin_funcs.out b/src/test/regress/expected/admin_funcs.out
new file mode 100644
index 0000000000..4661cdbc75
--- /dev/null
+++ b/src/test/regress/expected/admin_funcs.out
@@ -0,0 +1,29 @@
+select pg_cancel_backend();
+ERROR:  function pg_cancel_backend() does not exist
+LINE 1: select pg_cancel_backend();
+               ^
+HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
+select pg_cancel_backend(NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(pg_backend_pid());
+ERROR:  canceling statement due to user request
+select pg_cancel_backend(NULL, NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(NULL, 'suicide is painless');
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(pg_backend_pid(), 'it brings on many changes');
+ERROR:  canceling statement due to user request: it brings on many changes
+select pg_cancel_backend(pg_backend_pid(), NULL);
+ERROR:  canceling statement due to user request
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 16f979c8d9..cdba9235b6 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -84,7 +84,7 @@ test: select_into select_distinct select_distinct_on select_implicit select_havi
 # ----------
 # Another group of parallel tests
 # ----------
-test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index
+test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index admin_funcs
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/admin_funcs.sql b/src/test/regress/sql/admin_funcs.sql
new file mode 100644
index 0000000000..420d782b80
--- /dev/null
+++ b/src/test/regress/sql/admin_funcs.sql
@@ -0,0 +1,7 @@
+select pg_cancel_backend();
+select pg_cancel_backend(NULL);
+select pg_cancel_backend(pg_backend_pid());
+select pg_cancel_backend(NULL, NULL);
+select pg_cancel_backend(NULL, 'suicide is painless');
+select pg_cancel_backend(pg_backend_pid(), 'it brings on many changes');
+select pg_cancel_backend(pg_backend_pid(), NULL);
-- 
2.14.1.145.gb3622a4ee

From 188089a36eeab66d390f2db16140b146e308d77b Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Wed, 13 Jun 2018 10:23:04 +0200
Subject: [PATCH 1/2] Refactor backend signalling code

This moves the system administration functions for signalling backends
from backend/utils/adt/misc.c into a separate file dedicated to backend
signalling. No new functionality is introduced in this commit.
---
 src/backend/storage/ipc/Makefile         |   6 +-
 src/backend/storage/ipc/backend_signal.c | 216 +++++++++++++++++++++++++++++++
 src/backend/utils/adt/misc.c             | 194 ---------------------------
 3 files changed, 219 insertions(+), 197 deletions(-)
 create mode 100644 src/backend/storage/ipc/backend_signal.c

diff --git a/src/backend/storage/ipc/Makefile b/src/backend/storage/ipc/Makefile
index 9dbdc26c9b..ac35c197e0 100644
--- a/src/backend/storage/ipc/Makefile
+++ b/src/backend/storage/ipc/Makefile
@@ -8,8 +8,8 @@ subdir = src/backend/storage/ipc
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o pmsignal.o procarray.o \
-	procsignal.o  shmem.o shmqueue.o shm_mq.o shm_toc.o sinval.o \
-	sinvaladt.o standby.o
+OBJS = backend_signal.o barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o \
+	pmsignal.o procarray.o procsignal.o shmem.o shmqueue.o shm_mq.o \
+	shm_toc.o sinval.o sinvaladt.o standby.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
new file mode 100644
index 0000000000..2b81c161d9
--- /dev/null
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -0,0 +1,216 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.c
+ *	  Routines for signalling backends
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/ipc/backend_signal.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <signal.h>
+
+#include "catalog/pg_authid.h"
+#include "funcapi.h"
+#include "miscadmin.h"
+#include "postmaster/syslogger.h"
+#include "storage/pmsignal.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "utils/acl.h"
+#include "utils/builtins.h"
+
+/*
+ * Send a signal to another backend.
+ *
+ * The signal is delivered if the user is either a superuser or the same
+ * role as the backend being signaled. For "dangerous" signals, an explicit
+ * check for superuser needs to be done prior to calling this function.
+ *
+ * Returns 0 on success, 1 on general failure, 2 on normal permission error
+ * and 3 if the caller needs to be a superuser.
+ *
+ * In the event of a general failure (return code 1), a warning message will
+ * be emitted. For permission errors, doing that is the responsibility of
+ * the caller.
+ */
+#define SIGNAL_BACKEND_SUCCESS 0
+#define SIGNAL_BACKEND_ERROR 1
+#define SIGNAL_BACKEND_NOPERMISSION 2
+#define SIGNAL_BACKEND_NOSUPERUSER 3
+static int
+pg_signal_backend(int pid, int sig)
+{
+	PGPROC	   *proc = BackendPidGetProc(pid);
+
+	/*
+	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
+	 * we reach kill(), a process for which we get a valid proc here might
+	 * have terminated on its own.  There's no way to acquire a lock on an
+	 * arbitrary process to prevent that. But since so far all the callers of
+	 * this mechanism involve some request for ending the process anyway, that
+	 * it might end on its own first is not a problem.
+	 */
+	if (proc == NULL)
+	{
+		/*
+		 * This is just a warning so a loop-through-resultset will not abort
+		 * if one backend terminated on its own during the run.
+		 */
+		ereport(WARNING,
+				(errmsg("PID %d is not a PostgreSQL server process", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+
+	/* Only allow superusers to signal superuser-owned backends. */
+	if (superuser_arg(proc->roleId) && !superuser())
+		return SIGNAL_BACKEND_NOSUPERUSER;
+
+	/* Users can signal backends they have role membership in. */
+	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
+		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
+		return SIGNAL_BACKEND_NOPERMISSION;
+
+	/*
+	 * Can the process we just validated above end, followed by the pid being
+	 * recycled for a new process, before reaching here?  Then we'd be trying
+	 * to kill the wrong thing.  Seems near impossible when sequential pid
+	 * assignment and wraparound is used.  Perhaps it could happen on a system
+	 * where pid re-use is randomized.  That race condition possibility seems
+	 * too unlikely to worry about.
+	 */
+
+	/* If we have setsid(), signal the backend's whole process group */
+#ifdef HAVE_SETSID
+	if (kill(-pid, sig))
+#else
+	if (kill(pid, sig))
+#endif
+	{
+		/* Again, just a warning to allow loops */
+		ereport(WARNING,
+				(errmsg("could not send signal to process %d: %m", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+	return SIGNAL_BACKEND_SUCCESS;
+}
+
+/*
+ * Signal to cancel a backend process.  This is allowed if you are a member of
+ * the role whose process is being canceled.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to cancel superuser query"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to terminate a backend process.  This is allowed if you are a member
+ * of the role whose process is being terminated.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to terminate superuser process"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to reload the database configuration
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_reload_conf(PG_FUNCTION_ARGS)
+{
+	if (kill(PostmasterPid, SIGHUP))
+	{
+		ereport(WARNING,
+				(errmsg("failed to send signal to postmaster: %m")));
+		PG_RETURN_BOOL(false);
+	}
+
+	PG_RETURN_BOOL(true);
+}
+
+
+/*
+ * Rotate log file
+ *
+ * This function is kept to support adminpack 1.0.
+ */
+Datum
+pg_rotate_logfile(PG_FUNCTION_ARGS)
+{
+	if (!superuser())
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be superuser to rotate log files with adminpack 1.0"),
+				  errhint("Consider using pg_logfile_rotate(), which is part of core, instead."))));
+
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
+/*
+ * Rotate log file
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
+{
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index b24dece23f..6ea3679835 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -15,13 +15,11 @@
 #include "postgres.h"
 
 #include <sys/file.h>
-#include <signal.h>
 #include <dirent.h>
 #include <math.h>
 #include <unistd.h>
 
 #include "access/sysattr.h"
-#include "catalog/pg_authid.h"
 #include "catalog/catalog.h"
 #include "catalog/pg_tablespace.h"
 #include "catalog/pg_type.h"
@@ -35,13 +33,9 @@
 #include "postmaster/syslogger.h"
 #include "rewrite/rewriteHandler.h"
 #include "storage/fd.h"
-#include "storage/pmsignal.h"
-#include "storage/proc.h"
-#include "storage/procarray.h"
 #include "utils/lsyscache.h"
 #include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
-#include "utils/acl.h"
 #include "utils/builtins.h"
 #include "utils/timestamp.h"
 
@@ -198,194 +192,6 @@ current_query(PG_FUNCTION_ARGS)
 		PG_RETURN_NULL();
 }
 
-/*
- * Send a signal to another backend.
- *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
- *
- * Returns 0 on success, 1 on general failure, 2 on normal permission error
- * and 3 if the caller needs to be a superuser.
- *
- * In the event of a general failure (return code 1), a warning message will
- * be emitted. For permission errors, doing that is the responsibility of
- * the caller.
- */
-#define SIGNAL_BACKEND_SUCCESS 0
-#define SIGNAL_BACKEND_ERROR 1
-#define SIGNAL_BACKEND_NOPERMISSION 2
-#define SIGNAL_BACKEND_NOSUPERUSER 3
-static int
-pg_signal_backend(int pid, int sig)
-{
-	PGPROC	   *proc = BackendPidGetProc(pid);
-
-	/*
-	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
-	 * we reach kill(), a process for which we get a valid proc here might
-	 * have terminated on its own.  There's no way to acquire a lock on an
-	 * arbitrary process to prevent that. But since so far all the callers of
-	 * this mechanism involve some request for ending the process anyway, that
-	 * it might end on its own first is not a problem.
-	 */
-	if (proc == NULL)
-	{
-		/*
-		 * This is just a warning so a loop-through-resultset will not abort
-		 * if one backend terminated on its own during the run.
-		 */
-		ereport(WARNING,
-				(errmsg("PID %d is not a PostgreSQL server process", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-
-	/* Only allow superusers to signal superuser-owned backends. */
-	if (superuser_arg(proc->roleId) && !superuser())
-		return SIGNAL_BACKEND_NOSUPERUSER;
-
-	/* Users can signal backends they have role membership in. */
-	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
-		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
-		return SIGNAL_BACKEND_NOPERMISSION;
-
-	/*
-	 * Can the process we just validated above end, followed by the pid being
-	 * recycled for a new process, before reaching here?  Then we'd be trying
-	 * to kill the wrong thing.  Seems near impossible when sequential pid
-	 * assignment and wraparound is used.  Perhaps it could happen on a system
-	 * where pid re-use is randomized.  That race condition possibility seems
-	 * too unlikely to worry about.
-	 */
-
-	/* If we have setsid(), signal the backend's whole process group */
-#ifdef HAVE_SETSID
-	if (kill(-pid, sig))
-#else
-	if (kill(pid, sig))
-#endif
-	{
-		/* Again, just a warning to allow loops */
-		ereport(WARNING,
-				(errmsg("could not send signal to process %d: %m", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-	return SIGNAL_BACKEND_SUCCESS;
-}
-
-/*
- * Signal to cancel a backend process.  This is allowed if you are a member of
- * the role whose process is being canceled.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to cancel superuser query"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to terminate a backend process.  This is allowed if you are a member
- * of the role whose process is being terminated.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to terminate superuser process"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to reload the database configuration
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_reload_conf(PG_FUNCTION_ARGS)
-{
-	if (kill(PostmasterPid, SIGHUP))
-	{
-		ereport(WARNING,
-				(errmsg("failed to send signal to postmaster: %m")));
-		PG_RETURN_BOOL(false);
-	}
-
-	PG_RETURN_BOOL(true);
-}
-
-
-/*
- * Rotate log file
- *
- * This function is kept to support adminpack 1.0.
- */
-Datum
-pg_rotate_logfile(PG_FUNCTION_ARGS)
-{
-	if (!superuser())
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be superuser to rotate log files with adminpack 1.0"),
-				  errhint("Consider using pg_logfile_rotate(), which is part of core, instead."))));
-
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
-/*
- * Rotate log file
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
-{
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
 /* Function to find out which databases make use of a tablespace */
 
 typedef struct
-- 
2.14.1.145.gb3622a4ee

From 287084f3800337ad8d29c1d6bbc7a63a9d131d63 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Wed, 13 Jun 2018 10:23:07 +0200
Subject: [PATCH 2/2] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend() or
pg_cancel_backend() to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
overloaded the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);

The backend API also expose functionality for altering the errcode
used when terminating or canceling the backend.
---
 doc/src/sgml/func.sgml                    |  12 +-
 src/backend/catalog/system_views.sql      |   8 +
 src/backend/storage/ipc/backend_signal.c  | 287 +++++++++++++++++++++++++++++-
 src/backend/storage/ipc/ipci.c            |   3 +
 src/backend/tcop/postgres.c               |  61 ++++++-
 src/backend/utils/init/postinit.c         |   2 +
 src/include/catalog/pg_proc.dat           |   4 +-
 src/include/storage/backend_signal.h      |  27 +++
 src/test/regress/expected/admin_funcs.out |  28 +++
 src/test/regress/parallel_schedule        |   2 +-
 src/test/regress/sql/admin_funcs.sql      |   7 +
 11 files changed, 423 insertions(+), 18 deletions(-)
 create mode 100644 src/include/storage/backend_signal.h
 create mode 100644 src/test/regress/expected/admin_funcs.out
 create mode 100644 src/test/regress/sql/admin_funcs.sql

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index b851fe023a..ad9763698f 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18540,7 +18540,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18565,7 +18565,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18596,6 +18596,14 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, the text
+    will be appended to the error message returned to the signalled backend.
+    <literal>message</literal> is limited to 128 bytes, any longer text
+    will be truncated. An example where we cancel our own backend:
+<programlisting>
+postgres=# SELECT pg_cancel_backend(pg_backend_pid(), 'Cancellation message text');
+ERROR:  canceling statement due to user request: Cancellation message text
+</programlisting>
    </para>
 
    <para>
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 8cd8bf40ac..f0e5bf90b0 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -1027,6 +1027,14 @@ CREATE OR REPLACE FUNCTION pg_stop_backup (
   RETURNS SETOF record STRICT VOLATILE LANGUAGE internal as 'pg_stop_backup_v2'
   PARALLEL RESTRICTED;
 
+CREATE OR REPLACE FUNCTION
+  pg_cancel_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_cancel_backend' PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION
+  pg_terminate_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_terminate_backend' PARALLEL SAFE;
+
 -- legacy definition for compatibility with 9.3
 CREATE OR REPLACE FUNCTION
   json_populate_record(base anyelement, from_json json, use_json_as_text boolean DEFAULT false)
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
index 2b81c161d9..298cf1a390 100644
--- a/src/backend/storage/ipc/backend_signal.c
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -18,20 +18,46 @@
 
 #include "catalog/pg_authid.h"
 #include "funcapi.h"
+#include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "postmaster/syslogger.h"
+#include "storage/backend_signal.h"
+#include "storage/ipc.h"
 #include "storage/pmsignal.h"
 #include "storage/proc.h"
 #include "storage/procarray.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
 
+/*
+ * Structure for registering a feedback payload to be sent to a cancelled, or
+ * terminated backend. Each backend is registered per pid in the array which is
+ * indexed by Backend ID. Reading and writing the message is protected by a
+ * per-slot spinlock.
+ */
+typedef struct
+{
+	pid_t	dest_pid;		/* The pid of the process being signalled */
+	pid_t	src_pid;		/* The pid of the processing signalling */
+	slock_t	mutex;			/* Per-slot protection */
+	char	message[MAX_CANCEL_MSG]; /* Message to send to signalled backend */
+	int		len;			/* Length of the message */
+	int		sqlerrcode;		/* errcode to use when signalling backend */
+} BackendSignalFeedbackShmemStruct;
+
+static BackendSignalFeedbackShmemStruct	*BackendSignalFeedbackSlots = NULL;
+static volatile BackendSignalFeedbackShmemStruct *MyCancelSlot = NULL;
+static void CleanupBackendSignalFeedback(int status, Datum argument);
+static int backend_feedback(pid_t backend_pid, char *message, int sqlerrcode);
+
 /*
  * Send a signal to another backend.
  *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
+ * The signal is delivered if the user is either a superuser or the same role
+ * as the backend being signaled. For "dangerous" signals, an explicit check
+ * for superuser needs to be done prior to calling this function. If msg is
+ * set, the contents will be passed as a message to the backend in the error
+ * message.
  *
  * Returns 0 on success, 1 on general failure, 2 on normal permission error
  * and 3 if the caller needs to be a superuser.
@@ -45,7 +71,7 @@
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -77,6 +103,15 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+	{
+		if (sig == SIGINT)
+			SetBackendCancelMessage(pid, msg);
+		else
+			SetBackendTerminationMessage(pid, msg);
+	}
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -110,7 +145,19 @@ pg_signal_backend(int pid, int sig)
 Datum
 pg_cancel_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -134,7 +181,19 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 Datum
 pg_terminate_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -146,7 +205,7 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
 }
 
 /*
@@ -214,3 +273,217 @@ pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(true);
 }
 
+/*
+ * The following routines handle registering an optional message when
+ * cancelling, or terminating, a backend as well changing the sqlerrcode used.
+ * The combined payload of message/errcode is referred to as feedback.  The
+ * message will be stored in shared memory and is limited to MAX_CANCEL_MSG
+ * characters including the NULL terminator.
+ *
+ * Access to the feedback slots is protected by spinlocks.
+ */
+
+/*
+ * Return the required size for the cancelation feedback Shmem area.
+ */
+Size
+BackendSignalFeedbackShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendSignalFeedbackShmemStruct);
+}
+
+/*
+ * Create and initialize the Shmem structure for holding the feedback, the
+ * bookkeeping for them and the spinlocks associated.
+ */
+void
+BackendSignalFeedbackShmemInit(void)
+{
+	Size	size = BackendSignalFeedbackShmemSize();
+	bool	found;
+	int		i;
+
+	BackendSignalFeedbackSlots = (BackendSignalFeedbackShmemStruct *)
+		ShmemInitStruct("BackendSignalFeedbackSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendSignalFeedbackSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendSignalFeedbackSlots[i].mutex));
+	}
+}
+
+/*
+ * Set up the slot for the current backend_id
+ */
+void
+BackendSignalFeedbackInit(int backend_id)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->len = 0;
+	slot->sqlerrcode = 0;
+	slot->dest_pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupBackendSignalFeedback, Int32GetDatum(backend_id));
+}
+
+/*
+ * Ensure that the slot is purged and emptied at exit. Any message gets
+ * overwritten with null chars to avoid risking exposing a message intended for
+ * another backend to a new backend.
+ */
+static void
+CleanupBackendSignalFeedback(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->len > 0)
+		MemSet(slot->message, '\0', sizeof(slot->message));
+
+	slot->len = 0;
+	slot->sqlerrcode = 0;
+	slot->dest_pid = 0;
+	slot->src_pid = 0;
+}
+
+/*
+ * Set a message for the cancellation of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendCancelMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_QUERY_CANCELED);
+}
+
+/*
+ * Set a message for the termination of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendTerminationMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_ADMIN_SHUTDOWN);
+}
+
+/*
+ * Set both a message and a sqlerrcode for use when signalling the backend
+ * with the specified pid.
+ */
+int
+SetBackendSignalFeedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	return backend_feedback(backend_pid, message, sqlerrcode);
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns zero on success. If the backend isn't found, or no message is
+ * passed, 1 is returned.  If two backends collide in setting a message, the
+ * existing message will be overwritten by the last one in.
+ */
+static int
+backend_feedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	int		i;
+	int		len;
+
+	if (!message)
+		return 1;
+
+	len = pg_mbcliplen(message, strlen(message), MAX_CANCEL_MSG - 1);
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		BackendSignalFeedbackShmemStruct *slot = &BackendSignalFeedbackSlots[i];
+
+		if (slot->dest_pid != 0 && slot->dest_pid == backend_pid)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->dest_pid != backend_pid)
+			{
+				SpinLockRelease(&slot->mutex);
+				return 1;
+			}
+
+			MemSet(slot->message, '\0', sizeof(slot->message));
+			memcpy(slot->message, message, len);
+			slot->len = len;
+			slot->sqlerrcode = sqlerrcode;
+			slot->src_pid = MyProcPid;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+/*
+ * Test whether there is feedback registered for the current backend that can
+ * be consumed and presented to the user.
+ */
+bool
+HasBackendSignalFeedback(void)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = ((slot->len > 0) && (slot->sqlerrcode != 0));
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * Return the configured signal feedback. The length of the message is returned
+ * in buf_len. The original length of the message is returned, or zero in case
+ * no message was found. If the returned length is greater than the size of the
+ * passed buffer, truncation has been performed. The feedback (message and
+ * errcode) is cleared on reading.
+ */
+int
+ConsumeBackendSignalFeedback(char *buffer, size_t buf_len, int *sqlerrcode,
+							 pid_t *pid)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->len > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->len;
+		*sqlerrcode = slot->sqlerrcode;
+		*pid = slot->src_pid;
+		slot->len = 0;
+		slot->message[0] = '\0';
+		slot->sqlerrcode = 0;
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 0c86a581c0..5d91450887 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -33,6 +33,7 @@
 #include "replication/walreceiver.h"
 #include "replication/walsender.h"
 #include "replication/origin.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/dsm.h"
 #include "storage/ipc.h"
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, BackendSignalFeedbackShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendSignalFeedbackShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index f4133953be..ebe3ac8b50 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -62,6 +62,7 @@
 #include "replication/slot.h"
 #include "replication/walsender.h"
 #include "rewrite/rewriteHandler.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
 #include "storage/proc.h"
@@ -2923,9 +2924,33 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_ADMIN_SHUTDOWN;
+					buffer[0] = '\0';
+				}
+				ereport(FATAL,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("terminating connection due to administrator command by process %d",
+								   pid)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3036,9 +3061,33 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_QUERY_CANCELED;
+					buffer[0] = '\0';
+				}
+
+				ereport(ERROR,
+						(errcode(sqlerrcode),
+						 errmsg(" %s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("canceling statement due to user request by process %d",
+								   pid)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 09e0df290d..65ae347f8d 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -40,6 +40,7 @@
 #include "postmaster/autovacuum.h"
 #include "postmaster/postmaster.h"
 #include "replication/walsender.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/fd.h"
 #include "storage/ipc.h"
@@ -747,6 +748,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendSignalFeedbackInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 66c6c224a8..53f6766f0f 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5972,10 +5972,10 @@
 
 { oid => '2171', descr => 'cancel a server process\' current query',
   proname => 'pg_cancel_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_cancel_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_cancel_backend' },
 { oid => '2096', descr => 'terminate a server process',
   proname => 'pg_terminate_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_terminate_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_terminate_backend' },
 { oid => '2172', descr => 'prepare for taking an online backup',
   proname => 'pg_start_backup', provolatile => 'v', proparallel => 'r',
   prorettype => 'pg_lsn', proargtypes => 'text bool bool',
diff --git a/src/include/storage/backend_signal.h b/src/include/storage/backend_signal.h
new file mode 100644
index 0000000000..86b46b3cc4
--- /dev/null
+++ b/src/include/storage/backend_signal.h
@@ -0,0 +1,27 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.h
+ *		Declarations for backend signalling
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/backend_signal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BACKEND_SIGNAL_H
+#define BACKEND_SIGNAL_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size BackendSignalFeedbackShmemSize(void);
+extern void BackendSignalFeedbackShmemInit(void);
+extern void BackendSignalFeedbackInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern int SetBackendTerminationMessage(pid_t backend, char *message);
+extern int SetBackendSignalFeedback(pid_t backend, char *message, int sqlerrcode);
+extern bool HasBackendSignalFeedback(void);
+extern int ConsumeBackendSignalFeedback(char *msg, size_t len, int *sqlerrcode, pid_t *pid);
+
+#endif /* BACKEND_SIGNAL_H */
diff --git a/src/test/regress/expected/admin_funcs.out b/src/test/regress/expected/admin_funcs.out
new file mode 100644
index 0000000000..c6edab2537
--- /dev/null
+++ b/src/test/regress/expected/admin_funcs.out
@@ -0,0 +1,28 @@
+select pg_cancel_backend();
+ERROR:  function pg_cancel_backend() does not exist
+LINE 1: select pg_cancel_backend();
+               ^
+HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
+select pg_cancel_backend(NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(pg_backend_pid());
+ERROR:  canceling statement due to user request
+select pg_cancel_backend(NULL, NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(NULL, 'suicide is painless');
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+--select pg_cancel_backend(pg_backend_pid(), 'it brings on many changes');
+select pg_cancel_backend(pg_backend_pid(), NULL);
+ERROR:  canceling statement due to user request
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 16f979c8d9..cdba9235b6 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -84,7 +84,7 @@ test: select_into select_distinct select_distinct_on select_implicit select_havi
 # ----------
 # Another group of parallel tests
 # ----------
-test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index
+test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index admin_funcs
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/admin_funcs.sql b/src/test/regress/sql/admin_funcs.sql
new file mode 100644
index 0000000000..9dc01ac49d
--- /dev/null
+++ b/src/test/regress/sql/admin_funcs.sql
@@ -0,0 +1,7 @@
+select pg_cancel_backend();
+select pg_cancel_backend(NULL);
+select pg_cancel_backend(pg_backend_pid());
+select pg_cancel_backend(NULL, NULL);
+select pg_cancel_backend(NULL, 'suicide is painless');
+--select pg_cancel_backend(pg_backend_pid(), 'it brings on many changes');
+select pg_cancel_backend(pg_backend_pid(), NULL);
-- 
2.14.1.145.gb3622a4ee

From 7cc3b81011e461a24463bc47c50f92a82ce51f78 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Wed, 13 Jun 2018 10:23:04 +0200
Subject: [PATCH 1/2] Refactor backend signalling code

This moves the system administration functions for signalling backends
from backend/utils/adt/misc.c into a separate file dedicated to backend
signalling. No new functionality is introduced in this commit.
---
 src/backend/storage/ipc/Makefile         |   6 +-
 src/backend/storage/ipc/backend_signal.c | 216 +++++++++++++++++++++++++++++++
 src/backend/utils/adt/misc.c             | 194 ---------------------------
 3 files changed, 219 insertions(+), 197 deletions(-)
 create mode 100644 src/backend/storage/ipc/backend_signal.c

diff --git a/src/backend/storage/ipc/Makefile b/src/backend/storage/ipc/Makefile
index 9dbdc26c9b..ac35c197e0 100644
--- a/src/backend/storage/ipc/Makefile
+++ b/src/backend/storage/ipc/Makefile
@@ -8,8 +8,8 @@ subdir = src/backend/storage/ipc
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o pmsignal.o procarray.o \
-	procsignal.o  shmem.o shmqueue.o shm_mq.o shm_toc.o sinval.o \
-	sinvaladt.o standby.o
+OBJS = backend_signal.o barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o \
+	pmsignal.o procarray.o procsignal.o shmem.o shmqueue.o shm_mq.o \
+	shm_toc.o sinval.o sinvaladt.o standby.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
new file mode 100644
index 0000000000..2b81c161d9
--- /dev/null
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -0,0 +1,216 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.c
+ *	  Routines for signalling backends
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/ipc/backend_signal.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <signal.h>
+
+#include "catalog/pg_authid.h"
+#include "funcapi.h"
+#include "miscadmin.h"
+#include "postmaster/syslogger.h"
+#include "storage/pmsignal.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "utils/acl.h"
+#include "utils/builtins.h"
+
+/*
+ * Send a signal to another backend.
+ *
+ * The signal is delivered if the user is either a superuser or the same
+ * role as the backend being signaled. For "dangerous" signals, an explicit
+ * check for superuser needs to be done prior to calling this function.
+ *
+ * Returns 0 on success, 1 on general failure, 2 on normal permission error
+ * and 3 if the caller needs to be a superuser.
+ *
+ * In the event of a general failure (return code 1), a warning message will
+ * be emitted. For permission errors, doing that is the responsibility of
+ * the caller.
+ */
+#define SIGNAL_BACKEND_SUCCESS 0
+#define SIGNAL_BACKEND_ERROR 1
+#define SIGNAL_BACKEND_NOPERMISSION 2
+#define SIGNAL_BACKEND_NOSUPERUSER 3
+static int
+pg_signal_backend(int pid, int sig)
+{
+	PGPROC	   *proc = BackendPidGetProc(pid);
+
+	/*
+	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
+	 * we reach kill(), a process for which we get a valid proc here might
+	 * have terminated on its own.  There's no way to acquire a lock on an
+	 * arbitrary process to prevent that. But since so far all the callers of
+	 * this mechanism involve some request for ending the process anyway, that
+	 * it might end on its own first is not a problem.
+	 */
+	if (proc == NULL)
+	{
+		/*
+		 * This is just a warning so a loop-through-resultset will not abort
+		 * if one backend terminated on its own during the run.
+		 */
+		ereport(WARNING,
+				(errmsg("PID %d is not a PostgreSQL server process", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+
+	/* Only allow superusers to signal superuser-owned backends. */
+	if (superuser_arg(proc->roleId) && !superuser())
+		return SIGNAL_BACKEND_NOSUPERUSER;
+
+	/* Users can signal backends they have role membership in. */
+	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
+		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
+		return SIGNAL_BACKEND_NOPERMISSION;
+
+	/*
+	 * Can the process we just validated above end, followed by the pid being
+	 * recycled for a new process, before reaching here?  Then we'd be trying
+	 * to kill the wrong thing.  Seems near impossible when sequential pid
+	 * assignment and wraparound is used.  Perhaps it could happen on a system
+	 * where pid re-use is randomized.  That race condition possibility seems
+	 * too unlikely to worry about.
+	 */
+
+	/* If we have setsid(), signal the backend's whole process group */
+#ifdef HAVE_SETSID
+	if (kill(-pid, sig))
+#else
+	if (kill(pid, sig))
+#endif
+	{
+		/* Again, just a warning to allow loops */
+		ereport(WARNING,
+				(errmsg("could not send signal to process %d: %m", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+	return SIGNAL_BACKEND_SUCCESS;
+}
+
+/*
+ * Signal to cancel a backend process.  This is allowed if you are a member of
+ * the role whose process is being canceled.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to cancel superuser query"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to terminate a backend process.  This is allowed if you are a member
+ * of the role whose process is being terminated.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to terminate superuser process"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to reload the database configuration
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_reload_conf(PG_FUNCTION_ARGS)
+{
+	if (kill(PostmasterPid, SIGHUP))
+	{
+		ereport(WARNING,
+				(errmsg("failed to send signal to postmaster: %m")));
+		PG_RETURN_BOOL(false);
+	}
+
+	PG_RETURN_BOOL(true);
+}
+
+
+/*
+ * Rotate log file
+ *
+ * This function is kept to support adminpack 1.0.
+ */
+Datum
+pg_rotate_logfile(PG_FUNCTION_ARGS)
+{
+	if (!superuser())
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be superuser to rotate log files with adminpack 1.0"),
+				  errhint("Consider using pg_logfile_rotate(), which is part of core, instead."))));
+
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
+/*
+ * Rotate log file
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
+{
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index b24dece23f..6ea3679835 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -15,13 +15,11 @@
 #include "postgres.h"
 
 #include <sys/file.h>
-#include <signal.h>
 #include <dirent.h>
 #include <math.h>
 #include <unistd.h>
 
 #include "access/sysattr.h"
-#include "catalog/pg_authid.h"
 #include "catalog/catalog.h"
 #include "catalog/pg_tablespace.h"
 #include "catalog/pg_type.h"
@@ -35,13 +33,9 @@
 #include "postmaster/syslogger.h"
 #include "rewrite/rewriteHandler.h"
 #include "storage/fd.h"
-#include "storage/pmsignal.h"
-#include "storage/proc.h"
-#include "storage/procarray.h"
 #include "utils/lsyscache.h"
 #include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
-#include "utils/acl.h"
 #include "utils/builtins.h"
 #include "utils/timestamp.h"
 
@@ -198,194 +192,6 @@ current_query(PG_FUNCTION_ARGS)
 		PG_RETURN_NULL();
 }
 
-/*
- * Send a signal to another backend.
- *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
- *
- * Returns 0 on success, 1 on general failure, 2 on normal permission error
- * and 3 if the caller needs to be a superuser.
- *
- * In the event of a general failure (return code 1), a warning message will
- * be emitted. For permission errors, doing that is the responsibility of
- * the caller.
- */
-#define SIGNAL_BACKEND_SUCCESS 0
-#define SIGNAL_BACKEND_ERROR 1
-#define SIGNAL_BACKEND_NOPERMISSION 2
-#define SIGNAL_BACKEND_NOSUPERUSER 3
-static int
-pg_signal_backend(int pid, int sig)
-{
-	PGPROC	   *proc = BackendPidGetProc(pid);
-
-	/*
-	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
-	 * we reach kill(), a process for which we get a valid proc here might
-	 * have terminated on its own.  There's no way to acquire a lock on an
-	 * arbitrary process to prevent that. But since so far all the callers of
-	 * this mechanism involve some request for ending the process anyway, that
-	 * it might end on its own first is not a problem.
-	 */
-	if (proc == NULL)
-	{
-		/*
-		 * This is just a warning so a loop-through-resultset will not abort
-		 * if one backend terminated on its own during the run.
-		 */
-		ereport(WARNING,
-				(errmsg("PID %d is not a PostgreSQL server process", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-
-	/* Only allow superusers to signal superuser-owned backends. */
-	if (superuser_arg(proc->roleId) && !superuser())
-		return SIGNAL_BACKEND_NOSUPERUSER;
-
-	/* Users can signal backends they have role membership in. */
-	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
-		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
-		return SIGNAL_BACKEND_NOPERMISSION;
-
-	/*
-	 * Can the process we just validated above end, followed by the pid being
-	 * recycled for a new process, before reaching here?  Then we'd be trying
-	 * to kill the wrong thing.  Seems near impossible when sequential pid
-	 * assignment and wraparound is used.  Perhaps it could happen on a system
-	 * where pid re-use is randomized.  That race condition possibility seems
-	 * too unlikely to worry about.
-	 */
-
-	/* If we have setsid(), signal the backend's whole process group */
-#ifdef HAVE_SETSID
-	if (kill(-pid, sig))
-#else
-	if (kill(pid, sig))
-#endif
-	{
-		/* Again, just a warning to allow loops */
-		ereport(WARNING,
-				(errmsg("could not send signal to process %d: %m", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-	return SIGNAL_BACKEND_SUCCESS;
-}
-
-/*
- * Signal to cancel a backend process.  This is allowed if you are a member of
- * the role whose process is being canceled.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to cancel superuser query"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to terminate a backend process.  This is allowed if you are a member
- * of the role whose process is being terminated.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to terminate superuser process"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to reload the database configuration
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_reload_conf(PG_FUNCTION_ARGS)
-{
-	if (kill(PostmasterPid, SIGHUP))
-	{
-		ereport(WARNING,
-				(errmsg("failed to send signal to postmaster: %m")));
-		PG_RETURN_BOOL(false);
-	}
-
-	PG_RETURN_BOOL(true);
-}
-
-
-/*
- * Rotate log file
- *
- * This function is kept to support adminpack 1.0.
- */
-Datum
-pg_rotate_logfile(PG_FUNCTION_ARGS)
-{
-	if (!superuser())
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be superuser to rotate log files with adminpack 1.0"),
-				  errhint("Consider using pg_logfile_rotate(), which is part of core, instead."))));
-
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
-/*
- * Rotate log file
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
-{
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
 /* Function to find out which databases make use of a tablespace */
 
 typedef struct
-- 
2.14.1.145.gb3622a4ee

From 9621919433dffd006e2c216e915394be1cc011ee Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Wed, 13 Jun 2018 10:23:07 +0200
Subject: [PATCH 2/2] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend() or
pg_cancel_backend() to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
overloaded the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);

The backend API also expose functionality for altering the errcode
used when terminating or canceling the backend.
---
 doc/src/sgml/func.sgml                    |  13 +-
 src/backend/catalog/system_views.sql      |   8 +
 src/backend/storage/ipc/backend_signal.c  | 303 +++++++++++++++++++++++++++++-
 src/backend/storage/ipc/ipci.c            |   3 +
 src/backend/tcop/postgres.c               |  61 +++++-
 src/backend/utils/init/postinit.c         |   2 +
 src/include/catalog/pg_proc.dat           |   4 +-
 src/include/storage/backend_signal.h      |  27 +++
 src/test/regress/expected/admin_funcs.out |  22 +++
 src/test/regress/parallel_schedule        |   2 +-
 src/test/regress/sql/admin_funcs.sql      |   5 +
 11 files changed, 432 insertions(+), 18 deletions(-)
 create mode 100644 src/include/storage/backend_signal.h
 create mode 100644 src/test/regress/expected/admin_funcs.out
 create mode 100644 src/test/regress/sql/admin_funcs.sql

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index edc9be92a6..5215e3eb60 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18554,7 +18554,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18579,7 +18579,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18610,6 +18610,15 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, it will
+    replace the default error message, which in turn will be the error
+    detail. <literal>message</literal> is limited to 128 bytes, a longer
+    text will be truncated. An example where we cancel our own backend:
+<programlisting>
+postgres=# SELECT pg_cancel_backend(pg_backend_pid(), 'cancellation message text');
+ERROR:  cancellation message text
+DETAIL:  canceling statement due to user request by process 12345
+</programlisting>
    </para>
 
    <para>
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 7251552419..21ab9592a2 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -1027,6 +1027,14 @@ CREATE OR REPLACE FUNCTION pg_stop_backup (
   RETURNS SETOF record STRICT VOLATILE LANGUAGE internal as 'pg_stop_backup_v2'
   PARALLEL RESTRICTED;
 
+CREATE OR REPLACE FUNCTION
+  pg_cancel_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_cancel_backend' PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION
+  pg_terminate_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_terminate_backend' PARALLEL SAFE;
+
 -- legacy definition for compatibility with 9.3
 CREATE OR REPLACE FUNCTION
   json_populate_record(base anyelement, from_json json, use_json_as_text boolean DEFAULT false)
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
index 2b81c161d9..4855ad8e32 100644
--- a/src/backend/storage/ipc/backend_signal.c
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -18,20 +18,49 @@
 
 #include "catalog/pg_authid.h"
 #include "funcapi.h"
+#include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "postmaster/syslogger.h"
+#include "storage/backend_signal.h"
+#include "storage/ipc.h"
 #include "storage/pmsignal.h"
 #include "storage/proc.h"
 #include "storage/procarray.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
 
+/*
+ * Structure for registering a feedback payload to be sent to a cancelled, or
+ * terminated backend. Each backend is registered per pid in the array which is
+ * indexed by Backend ID. Reading and writing the message is protected by a
+ * per-slot spinlock.
+ */
+typedef struct
+{
+	pid_t	dest_pid;		/* The pid of the process being signalled */
+	pid_t	src_pid;		/* The pid of the processing signalling */
+	slock_t	mutex;			/* Per-slot protection */
+	char	message[MAX_CANCEL_MSG]; /* Message to send to signalled backend */
+	int		orig_length;	/* Length of the message as passed by the user,
+							 * if this length exceeds MAX_CANCEL_MSG it will
+							 * be truncated but we store the original length
+							 * in order to be able to convey truncation */
+	int		sqlerrcode;		/* errcode to use when signalling backend */
+} BackendSignalFeedbackShmemStruct;
+
+static BackendSignalFeedbackShmemStruct	*BackendSignalFeedbackSlots = NULL;
+static volatile BackendSignalFeedbackShmemStruct *MyCancelSlot = NULL;
+static void CleanupBackendSignalFeedback(int status, Datum argument);
+static int backend_feedback(pid_t backend_pid, char *message, int sqlerrcode);
+
 /*
  * Send a signal to another backend.
  *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
+ * The signal is delivered if the user is either a superuser or the same role
+ * as the backend being signaled. For "dangerous" signals, an explicit check
+ * for superuser needs to be done prior to calling this function. If msg is
+ * set, the contents will be passed as a message to the backend in the error
+ * message.
  *
  * Returns 0 on success, 1 on general failure, 2 on normal permission error
  * and 3 if the caller needs to be a superuser.
@@ -45,7 +74,7 @@
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -77,6 +106,15 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+	{
+		if (sig == SIGINT)
+			SetBackendCancelMessage(pid, msg);
+		else
+			SetBackendTerminationMessage(pid, msg);
+	}
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -110,7 +148,19 @@ pg_signal_backend(int pid, int sig)
 Datum
 pg_cancel_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -134,7 +184,19 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 Datum
 pg_terminate_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -146,7 +208,7 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
 }
 
 /*
@@ -214,3 +276,230 @@ pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(true);
 }
 
+/*
+ * The following routines handle registering an optional message when
+ * cancelling, or terminating, a backend as well changing the sqlerrcode used.
+ * The combined payload of message/errcode is referred to as feedback.  The
+ * message will be stored in shared memory and is limited to MAX_CANCEL_MSG
+ * characters including the NULL terminator.
+ *
+ * Access to the feedback slots is protected by spinlocks.
+ */
+
+/*
+ * Return the required size for the cancelation feedback Shmem area.
+ */
+Size
+BackendSignalFeedbackShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendSignalFeedbackShmemStruct);
+}
+
+/*
+ * Create and initialize the Shmem structure for holding the feedback, the
+ * bookkeeping for them and the spinlocks associated.
+ */
+void
+BackendSignalFeedbackShmemInit(void)
+{
+	Size	size = BackendSignalFeedbackShmemSize();
+	bool	found;
+	int		i;
+
+	BackendSignalFeedbackSlots = (BackendSignalFeedbackShmemStruct *)
+		ShmemInitStruct("BackendSignalFeedbackSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendSignalFeedbackSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendSignalFeedbackSlots[i].mutex));
+	}
+}
+
+/*
+ * Set up the slot for the current backend_id
+ */
+void
+BackendSignalFeedbackInit(int backend_id)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->dest_pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupBackendSignalFeedback, Int32GetDatum(backend_id));
+}
+
+/*
+ * Ensure that the slot is purged and emptied at exit. Any message gets
+ * overwritten with null chars to avoid risking exposing a message intended for
+ * another backend to a new backend.
+ */
+static void
+CleanupBackendSignalFeedback(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->orig_length > 0)
+		MemSet(slot->message, '\0', sizeof(slot->message));
+
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->dest_pid = 0;
+	slot->src_pid = 0;
+}
+
+/*
+ * Set a message for the cancellation of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendCancelMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_QUERY_CANCELED);
+}
+
+/*
+ * Set a message for the termination of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendTerminationMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_ADMIN_SHUTDOWN);
+}
+
+/*
+ * Set both a message and a sqlerrcode for use when signalling the backend
+ * with the specified pid.
+ */
+int
+SetBackendSignalFeedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	return backend_feedback(backend_pid, message, sqlerrcode);
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns zero on success. If the backend isn't found, or no message is
+ * passed, 1 is returned.  If two backends collide in setting a message, the
+ * existing message will be overwritten by the last one in. The message will
+ * be truncated to fit within MAX_CANCEL_MSG bytes.
+ */
+static int
+backend_feedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	int		i;
+	int		len;
+
+	if (!message)
+		return 1;
+
+	len = pg_mbcliplen(message, strlen(message), MAX_CANCEL_MSG - 1);
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		BackendSignalFeedbackShmemStruct *slot = &BackendSignalFeedbackSlots[i];
+
+		if (slot->dest_pid != 0 && slot->dest_pid == backend_pid)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->dest_pid != backend_pid)
+			{
+				SpinLockRelease(&slot->mutex);
+				return 1;
+			}
+
+			/* Avoid risking to leak any part of a previously set message */
+			MemSet(slot->message, '\0', sizeof(slot->message));
+
+			memcpy(slot->message, message, len);
+			slot->orig_length = pg_mbstrlen(message);
+			slot->sqlerrcode = sqlerrcode;
+			slot->src_pid = MyProcPid;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+/*
+ * HasBackendSignalFeedback
+ *		Test if there is a backend signalling feedback to consume
+ *
+ * Test whether there is feedback registered for the current backend that can
+ * be consumed and presented to the user. It isn't strictly required to call
+ * this function prior to consuming a potential message, but since consuming it
+ * will clear it there can be cases where one would like to peek first.
+ */
+bool
+HasBackendSignalFeedback(void)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = ((slot->orig_length > 0) && (slot->sqlerrcode != 0));
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * ConsumeBackendSignalFeedback
+ *		Read anc clear backend signalling feedback
+ *
+ * Return the configured signal feedback in buffer, which is buf_len bytes in
+ * size.  The original length of the message is returned, or zero in case no
+ * message was found. If the returned length exceeds that of Min(buf_len,
+ * MAX_CANCEL_MSG), then truncation has been performed. The feedback (message
+ * and errcode) is cleared on consumption. There is no point in passing a
+ * buffer larger than MAX_CANCEL_NSG as that is the upper bound on what will be
+ * stored in the slot.
+ */
+int
+ConsumeBackendSignalFeedback(char *buffer, size_t buf_len, int *sqlerrcode,
+							 pid_t *pid)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->orig_length > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->orig_length;
+		*sqlerrcode = slot->sqlerrcode;
+		*pid = slot->src_pid;
+		slot->orig_length = 0;
+		slot->message[0] = '\0';
+		slot->sqlerrcode = 0;
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 0c86a581c0..5d91450887 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -33,6 +33,7 @@
 #include "replication/walreceiver.h"
 #include "replication/walsender.h"
 #include "replication/origin.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/dsm.h"
 #include "storage/ipc.h"
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, BackendSignalFeedbackShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendSignalFeedbackShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index f4133953be..478c968338 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -62,6 +62,7 @@
 #include "replication/slot.h"
 #include "replication/walsender.h"
 #include "rewrite/rewriteHandler.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
 #include "storage/proc.h"
@@ -2923,9 +2924,33 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_ADMIN_SHUTDOWN;
+					buffer[0] = '\0';
+				}
+				ereport(FATAL,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("terminating connection due to administrator command by process %d",
+								   pid)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3036,9 +3061,33 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_QUERY_CANCELED;
+					buffer[0] = '\0';
+				}
+
+				ereport(ERROR,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("canceling statement due to user request by process %d",
+								   pid)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 5ef6315d20..8bbfdde93c 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -40,6 +40,7 @@
 #include "postmaster/autovacuum.h"
 #include "postmaster/postmaster.h"
 #include "replication/walsender.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/fd.h"
 #include "storage/ipc.h"
@@ -758,6 +759,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendSignalFeedbackInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index a14651010f..bd4831f639 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5972,10 +5972,10 @@
 
 { oid => '2171', descr => 'cancel a server process\' current query',
   proname => 'pg_cancel_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_cancel_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_cancel_backend' },
 { oid => '2096', descr => 'terminate a server process',
   proname => 'pg_terminate_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_terminate_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_terminate_backend' },
 { oid => '2172', descr => 'prepare for taking an online backup',
   proname => 'pg_start_backup', provolatile => 'v', proparallel => 'r',
   prorettype => 'pg_lsn', proargtypes => 'text bool bool',
diff --git a/src/include/storage/backend_signal.h b/src/include/storage/backend_signal.h
new file mode 100644
index 0000000000..86b46b3cc4
--- /dev/null
+++ b/src/include/storage/backend_signal.h
@@ -0,0 +1,27 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.h
+ *		Declarations for backend signalling
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/backend_signal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BACKEND_SIGNAL_H
+#define BACKEND_SIGNAL_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size BackendSignalFeedbackShmemSize(void);
+extern void BackendSignalFeedbackShmemInit(void);
+extern void BackendSignalFeedbackInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern int SetBackendTerminationMessage(pid_t backend, char *message);
+extern int SetBackendSignalFeedback(pid_t backend, char *message, int sqlerrcode);
+extern bool HasBackendSignalFeedback(void);
+extern int ConsumeBackendSignalFeedback(char *msg, size_t len, int *sqlerrcode, pid_t *pid);
+
+#endif /* BACKEND_SIGNAL_H */
diff --git a/src/test/regress/expected/admin_funcs.out b/src/test/regress/expected/admin_funcs.out
new file mode 100644
index 0000000000..e1489e7717
--- /dev/null
+++ b/src/test/regress/expected/admin_funcs.out
@@ -0,0 +1,22 @@
+select pg_cancel_backend(NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(pg_backend_pid());
+ERROR:  canceling statement due to user request
+select pg_cancel_backend(NULL, NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(NULL, 'suicide is painless');
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(pg_backend_pid(), NULL);
+ERROR:  canceling statement due to user request
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 16f979c8d9..cdba9235b6 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -84,7 +84,7 @@ test: select_into select_distinct select_distinct_on select_implicit select_havi
 # ----------
 # Another group of parallel tests
 # ----------
-test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index
+test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index admin_funcs
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/admin_funcs.sql b/src/test/regress/sql/admin_funcs.sql
new file mode 100644
index 0000000000..8288ab0e11
--- /dev/null
+++ b/src/test/regress/sql/admin_funcs.sql
@@ -0,0 +1,5 @@
+select pg_cancel_backend(NULL);
+select pg_cancel_backend(pg_backend_pid());
+select pg_cancel_backend(NULL, NULL);
+select pg_cancel_backend(NULL, 'suicide is painless');
+select pg_cancel_backend(pg_backend_pid(), NULL);
-- 
2.14.1.145.gb3622a4ee

From 81d82f7394c145745d0f20ab1f6cc25290ec757c Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Wed, 13 Jun 2018 10:23:04 +0200
Subject: [PATCH 1/2] Refactor backend signalling code

This moves the system administration functions for signalling backends
from backend/utils/adt/misc.c into a separate file dedicated to backend
signalling. No new functionality is introduced in this commit.
---
 src/backend/storage/ipc/Makefile         |   6 +-
 src/backend/storage/ipc/backend_signal.c | 216 +++++++++++++++++++++++++++++++
 src/backend/utils/adt/misc.c             | 194 ---------------------------
 3 files changed, 219 insertions(+), 197 deletions(-)
 create mode 100644 src/backend/storage/ipc/backend_signal.c

diff --git a/src/backend/storage/ipc/Makefile b/src/backend/storage/ipc/Makefile
index 9dbdc26c9b..ac35c197e0 100644
--- a/src/backend/storage/ipc/Makefile
+++ b/src/backend/storage/ipc/Makefile
@@ -8,8 +8,8 @@ subdir = src/backend/storage/ipc
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o pmsignal.o procarray.o \
-	procsignal.o  shmem.o shmqueue.o shm_mq.o shm_toc.o sinval.o \
-	sinvaladt.o standby.o
+OBJS = backend_signal.o barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o \
+	pmsignal.o procarray.o procsignal.o shmem.o shmqueue.o shm_mq.o \
+	shm_toc.o sinval.o sinvaladt.o standby.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
new file mode 100644
index 0000000000..2b81c161d9
--- /dev/null
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -0,0 +1,216 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.c
+ *	  Routines for signalling backends
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/ipc/backend_signal.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <signal.h>
+
+#include "catalog/pg_authid.h"
+#include "funcapi.h"
+#include "miscadmin.h"
+#include "postmaster/syslogger.h"
+#include "storage/pmsignal.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "utils/acl.h"
+#include "utils/builtins.h"
+
+/*
+ * Send a signal to another backend.
+ *
+ * The signal is delivered if the user is either a superuser or the same
+ * role as the backend being signaled. For "dangerous" signals, an explicit
+ * check for superuser needs to be done prior to calling this function.
+ *
+ * Returns 0 on success, 1 on general failure, 2 on normal permission error
+ * and 3 if the caller needs to be a superuser.
+ *
+ * In the event of a general failure (return code 1), a warning message will
+ * be emitted. For permission errors, doing that is the responsibility of
+ * the caller.
+ */
+#define SIGNAL_BACKEND_SUCCESS 0
+#define SIGNAL_BACKEND_ERROR 1
+#define SIGNAL_BACKEND_NOPERMISSION 2
+#define SIGNAL_BACKEND_NOSUPERUSER 3
+static int
+pg_signal_backend(int pid, int sig)
+{
+	PGPROC	   *proc = BackendPidGetProc(pid);
+
+	/*
+	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
+	 * we reach kill(), a process for which we get a valid proc here might
+	 * have terminated on its own.  There's no way to acquire a lock on an
+	 * arbitrary process to prevent that. But since so far all the callers of
+	 * this mechanism involve some request for ending the process anyway, that
+	 * it might end on its own first is not a problem.
+	 */
+	if (proc == NULL)
+	{
+		/*
+		 * This is just a warning so a loop-through-resultset will not abort
+		 * if one backend terminated on its own during the run.
+		 */
+		ereport(WARNING,
+				(errmsg("PID %d is not a PostgreSQL server process", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+
+	/* Only allow superusers to signal superuser-owned backends. */
+	if (superuser_arg(proc->roleId) && !superuser())
+		return SIGNAL_BACKEND_NOSUPERUSER;
+
+	/* Users can signal backends they have role membership in. */
+	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
+		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
+		return SIGNAL_BACKEND_NOPERMISSION;
+
+	/*
+	 * Can the process we just validated above end, followed by the pid being
+	 * recycled for a new process, before reaching here?  Then we'd be trying
+	 * to kill the wrong thing.  Seems near impossible when sequential pid
+	 * assignment and wraparound is used.  Perhaps it could happen on a system
+	 * where pid re-use is randomized.  That race condition possibility seems
+	 * too unlikely to worry about.
+	 */
+
+	/* If we have setsid(), signal the backend's whole process group */
+#ifdef HAVE_SETSID
+	if (kill(-pid, sig))
+#else
+	if (kill(pid, sig))
+#endif
+	{
+		/* Again, just a warning to allow loops */
+		ereport(WARNING,
+				(errmsg("could not send signal to process %d: %m", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+	return SIGNAL_BACKEND_SUCCESS;
+}
+
+/*
+ * Signal to cancel a backend process.  This is allowed if you are a member of
+ * the role whose process is being canceled.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to cancel superuser query"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to terminate a backend process.  This is allowed if you are a member
+ * of the role whose process is being terminated.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to terminate superuser process"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to reload the database configuration
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_reload_conf(PG_FUNCTION_ARGS)
+{
+	if (kill(PostmasterPid, SIGHUP))
+	{
+		ereport(WARNING,
+				(errmsg("failed to send signal to postmaster: %m")));
+		PG_RETURN_BOOL(false);
+	}
+
+	PG_RETURN_BOOL(true);
+}
+
+
+/*
+ * Rotate log file
+ *
+ * This function is kept to support adminpack 1.0.
+ */
+Datum
+pg_rotate_logfile(PG_FUNCTION_ARGS)
+{
+	if (!superuser())
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be superuser to rotate log files with adminpack 1.0"),
+				  errhint("Consider using pg_logfile_rotate(), which is part of core, instead."))));
+
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
+/*
+ * Rotate log file
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
+{
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index b24dece23f..6ea3679835 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -15,13 +15,11 @@
 #include "postgres.h"
 
 #include <sys/file.h>
-#include <signal.h>
 #include <dirent.h>
 #include <math.h>
 #include <unistd.h>
 
 #include "access/sysattr.h"
-#include "catalog/pg_authid.h"
 #include "catalog/catalog.h"
 #include "catalog/pg_tablespace.h"
 #include "catalog/pg_type.h"
@@ -35,13 +33,9 @@
 #include "postmaster/syslogger.h"
 #include "rewrite/rewriteHandler.h"
 #include "storage/fd.h"
-#include "storage/pmsignal.h"
-#include "storage/proc.h"
-#include "storage/procarray.h"
 #include "utils/lsyscache.h"
 #include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
-#include "utils/acl.h"
 #include "utils/builtins.h"
 #include "utils/timestamp.h"
 
@@ -198,194 +192,6 @@ current_query(PG_FUNCTION_ARGS)
 		PG_RETURN_NULL();
 }
 
-/*
- * Send a signal to another backend.
- *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
- *
- * Returns 0 on success, 1 on general failure, 2 on normal permission error
- * and 3 if the caller needs to be a superuser.
- *
- * In the event of a general failure (return code 1), a warning message will
- * be emitted. For permission errors, doing that is the responsibility of
- * the caller.
- */
-#define SIGNAL_BACKEND_SUCCESS 0
-#define SIGNAL_BACKEND_ERROR 1
-#define SIGNAL_BACKEND_NOPERMISSION 2
-#define SIGNAL_BACKEND_NOSUPERUSER 3
-static int
-pg_signal_backend(int pid, int sig)
-{
-	PGPROC	   *proc = BackendPidGetProc(pid);
-
-	/*
-	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
-	 * we reach kill(), a process for which we get a valid proc here might
-	 * have terminated on its own.  There's no way to acquire a lock on an
-	 * arbitrary process to prevent that. But since so far all the callers of
-	 * this mechanism involve some request for ending the process anyway, that
-	 * it might end on its own first is not a problem.
-	 */
-	if (proc == NULL)
-	{
-		/*
-		 * This is just a warning so a loop-through-resultset will not abort
-		 * if one backend terminated on its own during the run.
-		 */
-		ereport(WARNING,
-				(errmsg("PID %d is not a PostgreSQL server process", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-
-	/* Only allow superusers to signal superuser-owned backends. */
-	if (superuser_arg(proc->roleId) && !superuser())
-		return SIGNAL_BACKEND_NOSUPERUSER;
-
-	/* Users can signal backends they have role membership in. */
-	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
-		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
-		return SIGNAL_BACKEND_NOPERMISSION;
-
-	/*
-	 * Can the process we just validated above end, followed by the pid being
-	 * recycled for a new process, before reaching here?  Then we'd be trying
-	 * to kill the wrong thing.  Seems near impossible when sequential pid
-	 * assignment and wraparound is used.  Perhaps it could happen on a system
-	 * where pid re-use is randomized.  That race condition possibility seems
-	 * too unlikely to worry about.
-	 */
-
-	/* If we have setsid(), signal the backend's whole process group */
-#ifdef HAVE_SETSID
-	if (kill(-pid, sig))
-#else
-	if (kill(pid, sig))
-#endif
-	{
-		/* Again, just a warning to allow loops */
-		ereport(WARNING,
-				(errmsg("could not send signal to process %d: %m", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-	return SIGNAL_BACKEND_SUCCESS;
-}
-
-/*
- * Signal to cancel a backend process.  This is allowed if you are a member of
- * the role whose process is being canceled.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to cancel superuser query"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to terminate a backend process.  This is allowed if you are a member
- * of the role whose process is being terminated.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to terminate superuser process"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to reload the database configuration
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_reload_conf(PG_FUNCTION_ARGS)
-{
-	if (kill(PostmasterPid, SIGHUP))
-	{
-		ereport(WARNING,
-				(errmsg("failed to send signal to postmaster: %m")));
-		PG_RETURN_BOOL(false);
-	}
-
-	PG_RETURN_BOOL(true);
-}
-
-
-/*
- * Rotate log file
- *
- * This function is kept to support adminpack 1.0.
- */
-Datum
-pg_rotate_logfile(PG_FUNCTION_ARGS)
-{
-	if (!superuser())
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be superuser to rotate log files with adminpack 1.0"),
-				  errhint("Consider using pg_logfile_rotate(), which is part of core, instead."))));
-
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
-/*
- * Rotate log file
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
-{
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
 /* Function to find out which databases make use of a tablespace */
 
 typedef struct
-- 
2.14.1.145.gb3622a4ee

From 0ebdcca3d545c2367d4f40407ccacab09e887e48 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Wed, 13 Jun 2018 10:23:07 +0200
Subject: [PATCH 2/2] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend() or
pg_cancel_backend() to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
overloaded the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);

The backend API also expose functionality for altering the errcode
used when terminating or canceling the backend.
---
 doc/src/sgml/func.sgml                    |  13 +-
 src/backend/catalog/system_views.sql      |   8 +
 src/backend/storage/ipc/backend_signal.c  | 318 +++++++++++++++++++++++++++++-
 src/backend/storage/ipc/ipci.c            |   3 +
 src/backend/tcop/postgres.c               |  61 +++++-
 src/backend/utils/init/postinit.c         |   2 +
 src/include/catalog/pg_proc.dat           |   4 +-
 src/include/storage/backend_signal.h      |  27 +++
 src/test/regress/expected/admin_funcs.out |  24 +++
 src/test/regress/parallel_schedule        |   2 +-
 src/test/regress/sql/admin_funcs.sql      |   6 +
 11 files changed, 450 insertions(+), 18 deletions(-)
 create mode 100644 src/include/storage/backend_signal.h
 create mode 100644 src/test/regress/expected/admin_funcs.out
 create mode 100644 src/test/regress/sql/admin_funcs.sql

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index edc9be92a6..004359181e 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18554,7 +18554,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18579,7 +18579,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18610,6 +18610,15 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, it will
+    replace the default error message, which in turn will be the error
+    detail. <literal>message</literal> is limited to 128 ASCII characters, a
+    longer text will be truncated. An example where we cancel our own backend:
+<programlisting>
+postgres=# SELECT pg_cancel_backend(pg_backend_pid(), 'cancellation message text');
+ERROR:  cancellation message text
+DETAIL:  canceling statement due to user request by process 12345
+</programlisting>
    </para>
 
    <para>
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 7251552419..21ab9592a2 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -1027,6 +1027,14 @@ CREATE OR REPLACE FUNCTION pg_stop_backup (
   RETURNS SETOF record STRICT VOLATILE LANGUAGE internal as 'pg_stop_backup_v2'
   PARALLEL RESTRICTED;
 
+CREATE OR REPLACE FUNCTION
+  pg_cancel_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_cancel_backend' PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION
+  pg_terminate_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_terminate_backend' PARALLEL SAFE;
+
 -- legacy definition for compatibility with 9.3
 CREATE OR REPLACE FUNCTION
   json_populate_record(base anyelement, from_json json, use_json_as_text boolean DEFAULT false)
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
index 2b81c161d9..c3c1198c45 100644
--- a/src/backend/storage/ipc/backend_signal.c
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -18,20 +18,49 @@
 
 #include "catalog/pg_authid.h"
 #include "funcapi.h"
+#include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "postmaster/syslogger.h"
+#include "storage/backend_signal.h"
+#include "storage/ipc.h"
 #include "storage/pmsignal.h"
 #include "storage/proc.h"
 #include "storage/procarray.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
 
+/*
+ * Structure for registering a feedback payload to be sent to a cancelled, or
+ * terminated backend. Each backend is registered per pid in the array which is
+ * indexed by Backend ID. Reading and writing the message is protected by a
+ * per-slot spinlock.
+ */
+typedef struct
+{
+	pid_t	dest_pid;		/* The pid of the process being signalled */
+	pid_t	src_pid;		/* The pid of the processing signalling */
+	slock_t	mutex;			/* Per-slot protection */
+	char	message[MAX_CANCEL_MSG]; /* Message to send to signalled backend */
+	int		orig_length;	/* Length of the message as passed by the user,
+							 * if this length exceeds MAX_CANCEL_MSG it will
+							 * be truncated but we store the original length
+							 * in order to be able to convey truncation */
+	int		sqlerrcode;		/* errcode to use when signalling backend */
+} BackendSignalFeedbackShmemStruct;
+
+static BackendSignalFeedbackShmemStruct	*BackendSignalFeedbackSlots = NULL;
+static volatile BackendSignalFeedbackShmemStruct *MyCancelSlot = NULL;
+static void CleanupBackendSignalFeedback(int status, Datum argument);
+static int backend_feedback(pid_t backend_pid, char *message, int sqlerrcode);
+
 /*
  * Send a signal to another backend.
  *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
+ * The signal is delivered if the user is either a superuser or the same role
+ * as the backend being signaled. For "dangerous" signals, an explicit check
+ * for superuser needs to be done prior to calling this function. If msg is
+ * set, the contents will be passed as a message to the backend in the error
+ * message.
  *
  * Returns 0 on success, 1 on general failure, 2 on normal permission error
  * and 3 if the caller needs to be a superuser.
@@ -45,7 +74,7 @@
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -77,6 +106,30 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+	{
+		char *tmp = msg;
+
+		/*
+		 * The message to pass to the signalled backend is currently restricted
+		 * to ASCII only, since the sending backend might use an encoding which
+		 * is incompatible with the receiving with regards to conversion.
+		 */
+		while (*tmp != '\0')
+		{
+			if (!isascii(*tmp))
+				ereport(ERROR,
+						(errmsg("message is restricted to ASCII only")));
+			tmp++;
+		}
+
+		if (sig == SIGINT)
+			SetBackendCancelMessage(pid, msg);
+		else
+			SetBackendTerminationMessage(pid, msg);
+	}
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -110,7 +163,19 @@ pg_signal_backend(int pid, int sig)
 Datum
 pg_cancel_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -134,7 +199,19 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 Datum
 pg_terminate_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -146,7 +223,7 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
 }
 
 /*
@@ -214,3 +291,230 @@ pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(true);
 }
 
+/*
+ * The following routines handle registering an optional message when
+ * cancelling, or terminating, a backend as well changing the sqlerrcode used.
+ * The combined payload of message/errcode is referred to as feedback.  The
+ * message will be stored in shared memory and is limited to MAX_CANCEL_MSG
+ * characters including the NULL terminator.
+ *
+ * Access to the feedback slots is protected by spinlocks.
+ */
+
+/*
+ * Return the required size for the cancelation feedback Shmem area.
+ */
+Size
+BackendSignalFeedbackShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendSignalFeedbackShmemStruct);
+}
+
+/*
+ * Create and initialize the Shmem structure for holding the feedback, the
+ * bookkeeping for them and the spinlocks associated.
+ */
+void
+BackendSignalFeedbackShmemInit(void)
+{
+	Size	size = BackendSignalFeedbackShmemSize();
+	bool	found;
+	int		i;
+
+	BackendSignalFeedbackSlots = (BackendSignalFeedbackShmemStruct *)
+		ShmemInitStruct("BackendSignalFeedbackSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendSignalFeedbackSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendSignalFeedbackSlots[i].mutex));
+	}
+}
+
+/*
+ * Set up the slot for the current backend_id
+ */
+void
+BackendSignalFeedbackInit(int backend_id)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->dest_pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupBackendSignalFeedback, Int32GetDatum(backend_id));
+}
+
+/*
+ * Ensure that the slot is purged and emptied at exit. Any message gets
+ * overwritten with null chars to avoid risking exposing a message intended for
+ * another backend to a new backend.
+ */
+static void
+CleanupBackendSignalFeedback(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->orig_length > 0)
+		MemSet(slot->message, '\0', sizeof(slot->message));
+
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->dest_pid = 0;
+	slot->src_pid = 0;
+}
+
+/*
+ * Set a message for the cancellation of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendCancelMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_QUERY_CANCELED);
+}
+
+/*
+ * Set a message for the termination of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendTerminationMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_ADMIN_SHUTDOWN);
+}
+
+/*
+ * Set both a message and a sqlerrcode for use when signalling the backend
+ * with the specified pid.
+ */
+int
+SetBackendSignalFeedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	return backend_feedback(backend_pid, message, sqlerrcode);
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns zero on success. If the backend isn't found, or no message is
+ * passed, 1 is returned.  If two backends collide in setting a message, the
+ * existing message will be overwritten by the last one in. The message will
+ * be truncated to fit within MAX_CANCEL_MSG bytes.
+ */
+static int
+backend_feedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	int		i;
+	int		len;
+
+	if (!message)
+		return 1;
+
+	len = pg_mbcliplen(message, strlen(message), MAX_CANCEL_MSG - 1);
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		BackendSignalFeedbackShmemStruct *slot = &BackendSignalFeedbackSlots[i];
+
+		if (slot->dest_pid != 0 && slot->dest_pid == backend_pid)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->dest_pid != backend_pid)
+			{
+				SpinLockRelease(&slot->mutex);
+				return 1;
+			}
+
+			/* Avoid risking to leak any part of a previously set message */
+			MemSet(slot->message, '\0', sizeof(slot->message));
+
+			memcpy(slot->message, message, len);
+			slot->orig_length = pg_mbstrlen(message);
+			slot->sqlerrcode = sqlerrcode;
+			slot->src_pid = MyProcPid;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+/*
+ * HasBackendSignalFeedback
+ *		Test if there is a backend signalling feedback to consume
+ *
+ * Test whether there is feedback registered for the current backend that can
+ * be consumed and presented to the user. It isn't strictly required to call
+ * this function prior to consuming a potential message, but since consuming it
+ * will clear it there can be cases where one would like to peek first.
+ */
+bool
+HasBackendSignalFeedback(void)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = ((slot->orig_length > 0) && (slot->sqlerrcode != 0));
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * ConsumeBackendSignalFeedback
+ *		Read anc clear backend signalling feedback
+ *
+ * Return the configured signal feedback in buffer, which is buf_len bytes in
+ * size.  The original length of the message is returned, or zero in case no
+ * message was found. If the returned length exceeds that of Min(buf_len,
+ * MAX_CANCEL_MSG), then truncation has been performed. The feedback (message
+ * and errcode) is cleared on consumption. There is no point in passing a
+ * buffer larger than MAX_CANCEL_NSG as that is the upper bound on what will be
+ * stored in the slot.
+ */
+int
+ConsumeBackendSignalFeedback(char *buffer, size_t buf_len, int *sqlerrcode,
+							 pid_t *pid)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->orig_length > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->orig_length;
+		*sqlerrcode = slot->sqlerrcode;
+		*pid = slot->src_pid;
+		slot->orig_length = 0;
+		slot->message[0] = '\0';
+		slot->sqlerrcode = 0;
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 0c86a581c0..5d91450887 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -33,6 +33,7 @@
 #include "replication/walreceiver.h"
 #include "replication/walsender.h"
 #include "replication/origin.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/dsm.h"
 #include "storage/ipc.h"
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, BackendSignalFeedbackShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendSignalFeedbackShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 07b956553a..d67f964985 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -62,6 +62,7 @@
 #include "replication/slot.h"
 #include "replication/walsender.h"
 #include "rewrite/rewriteHandler.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
 #include "storage/proc.h"
@@ -2929,9 +2930,33 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_ADMIN_SHUTDOWN;
+					buffer[0] = '\0';
+				}
+				ereport(FATAL,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("terminating connection due to administrator command by process %d",
+								   pid)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3042,9 +3067,33 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_QUERY_CANCELED;
+					buffer[0] = '\0';
+				}
+
+				ereport(ERROR,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("canceling statement due to user request by process %d",
+								   pid)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 5ef6315d20..8bbfdde93c 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -40,6 +40,7 @@
 #include "postmaster/autovacuum.h"
 #include "postmaster/postmaster.h"
 #include "replication/walsender.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/fd.h"
 #include "storage/ipc.h"
@@ -758,6 +759,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendSignalFeedbackInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index a14651010f..bd4831f639 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5972,10 +5972,10 @@
 
 { oid => '2171', descr => 'cancel a server process\' current query',
   proname => 'pg_cancel_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_cancel_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_cancel_backend' },
 { oid => '2096', descr => 'terminate a server process',
   proname => 'pg_terminate_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_terminate_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_terminate_backend' },
 { oid => '2172', descr => 'prepare for taking an online backup',
   proname => 'pg_start_backup', provolatile => 'v', proparallel => 'r',
   prorettype => 'pg_lsn', proargtypes => 'text bool bool',
diff --git a/src/include/storage/backend_signal.h b/src/include/storage/backend_signal.h
new file mode 100644
index 0000000000..86b46b3cc4
--- /dev/null
+++ b/src/include/storage/backend_signal.h
@@ -0,0 +1,27 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.h
+ *		Declarations for backend signalling
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/backend_signal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BACKEND_SIGNAL_H
+#define BACKEND_SIGNAL_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size BackendSignalFeedbackShmemSize(void);
+extern void BackendSignalFeedbackShmemInit(void);
+extern void BackendSignalFeedbackInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern int SetBackendTerminationMessage(pid_t backend, char *message);
+extern int SetBackendSignalFeedback(pid_t backend, char *message, int sqlerrcode);
+extern bool HasBackendSignalFeedback(void);
+extern int ConsumeBackendSignalFeedback(char *msg, size_t len, int *sqlerrcode, pid_t *pid);
+
+#endif /* BACKEND_SIGNAL_H */
diff --git a/src/test/regress/expected/admin_funcs.out b/src/test/regress/expected/admin_funcs.out
new file mode 100644
index 0000000000..99437561b1
--- /dev/null
+++ b/src/test/regress/expected/admin_funcs.out
@@ -0,0 +1,24 @@
+select pg_cancel_backend(NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(pg_backend_pid());
+ERROR:  canceling statement due to user request
+select pg_cancel_backend(NULL, NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(NULL, 'suicide is painless');
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(pg_backend_pid(), 'ソケットをブロッキングモードに設定できませんでした');
+ERROR:  message is restricted to ASCII only
+select pg_cancel_backend(pg_backend_pid(), NULL);
+ERROR:  canceling statement due to user request
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 16f979c8d9..cdba9235b6 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -84,7 +84,7 @@ test: select_into select_distinct select_distinct_on select_implicit select_havi
 # ----------
 # Another group of parallel tests
 # ----------
-test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index
+test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index admin_funcs
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/admin_funcs.sql b/src/test/regress/sql/admin_funcs.sql
new file mode 100644
index 0000000000..d904036704
--- /dev/null
+++ b/src/test/regress/sql/admin_funcs.sql
@@ -0,0 +1,6 @@
+select pg_cancel_backend(NULL);
+select pg_cancel_backend(pg_backend_pid());
+select pg_cancel_backend(NULL, NULL);
+select pg_cancel_backend(NULL, 'suicide is painless');
+select pg_cancel_backend(pg_backend_pid(), 'ソケットをブロッキングモードに設定できませんでした');
+select pg_cancel_backend(pg_backend_pid(), NULL);
-- 
2.14.1.145.gb3622a4ee

From 5f629a0342729cd82b8f5dc5187c531f87ad0643 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Wed, 13 Jun 2018 10:23:04 +0200
Subject: [PATCH 1/2] Refactor backend signalling code

This moves the system administration functions for signalling backends
from backend/utils/adt/misc.c into a separate file dedicated to backend
signalling. No new functionality is introduced in this commit.
---
 src/backend/storage/ipc/Makefile         |   6 +-
 src/backend/storage/ipc/backend_signal.c | 216 +++++++++++++++++++++++++++++++
 src/backend/utils/adt/misc.c             | 194 ---------------------------
 3 files changed, 219 insertions(+), 197 deletions(-)
 create mode 100644 src/backend/storage/ipc/backend_signal.c

diff --git a/src/backend/storage/ipc/Makefile b/src/backend/storage/ipc/Makefile
index 9dbdc26c9b..ac35c197e0 100644
--- a/src/backend/storage/ipc/Makefile
+++ b/src/backend/storage/ipc/Makefile
@@ -8,8 +8,8 @@ subdir = src/backend/storage/ipc
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o pmsignal.o procarray.o \
-	procsignal.o  shmem.o shmqueue.o shm_mq.o shm_toc.o sinval.o \
-	sinvaladt.o standby.o
+OBJS = backend_signal.o barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o \
+	pmsignal.o procarray.o procsignal.o shmem.o shmqueue.o shm_mq.o \
+	shm_toc.o sinval.o sinvaladt.o standby.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
new file mode 100644
index 0000000000..2b81c161d9
--- /dev/null
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -0,0 +1,216 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.c
+ *	  Routines for signalling backends
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/ipc/backend_signal.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <signal.h>
+
+#include "catalog/pg_authid.h"
+#include "funcapi.h"
+#include "miscadmin.h"
+#include "postmaster/syslogger.h"
+#include "storage/pmsignal.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "utils/acl.h"
+#include "utils/builtins.h"
+
+/*
+ * Send a signal to another backend.
+ *
+ * The signal is delivered if the user is either a superuser or the same
+ * role as the backend being signaled. For "dangerous" signals, an explicit
+ * check for superuser needs to be done prior to calling this function.
+ *
+ * Returns 0 on success, 1 on general failure, 2 on normal permission error
+ * and 3 if the caller needs to be a superuser.
+ *
+ * In the event of a general failure (return code 1), a warning message will
+ * be emitted. For permission errors, doing that is the responsibility of
+ * the caller.
+ */
+#define SIGNAL_BACKEND_SUCCESS 0
+#define SIGNAL_BACKEND_ERROR 1
+#define SIGNAL_BACKEND_NOPERMISSION 2
+#define SIGNAL_BACKEND_NOSUPERUSER 3
+static int
+pg_signal_backend(int pid, int sig)
+{
+	PGPROC	   *proc = BackendPidGetProc(pid);
+
+	/*
+	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
+	 * we reach kill(), a process for which we get a valid proc here might
+	 * have terminated on its own.  There's no way to acquire a lock on an
+	 * arbitrary process to prevent that. But since so far all the callers of
+	 * this mechanism involve some request for ending the process anyway, that
+	 * it might end on its own first is not a problem.
+	 */
+	if (proc == NULL)
+	{
+		/*
+		 * This is just a warning so a loop-through-resultset will not abort
+		 * if one backend terminated on its own during the run.
+		 */
+		ereport(WARNING,
+				(errmsg("PID %d is not a PostgreSQL server process", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+
+	/* Only allow superusers to signal superuser-owned backends. */
+	if (superuser_arg(proc->roleId) && !superuser())
+		return SIGNAL_BACKEND_NOSUPERUSER;
+
+	/* Users can signal backends they have role membership in. */
+	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
+		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
+		return SIGNAL_BACKEND_NOPERMISSION;
+
+	/*
+	 * Can the process we just validated above end, followed by the pid being
+	 * recycled for a new process, before reaching here?  Then we'd be trying
+	 * to kill the wrong thing.  Seems near impossible when sequential pid
+	 * assignment and wraparound is used.  Perhaps it could happen on a system
+	 * where pid re-use is randomized.  That race condition possibility seems
+	 * too unlikely to worry about.
+	 */
+
+	/* If we have setsid(), signal the backend's whole process group */
+#ifdef HAVE_SETSID
+	if (kill(-pid, sig))
+#else
+	if (kill(pid, sig))
+#endif
+	{
+		/* Again, just a warning to allow loops */
+		ereport(WARNING,
+				(errmsg("could not send signal to process %d: %m", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+	return SIGNAL_BACKEND_SUCCESS;
+}
+
+/*
+ * Signal to cancel a backend process.  This is allowed if you are a member of
+ * the role whose process is being canceled.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to cancel superuser query"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to terminate a backend process.  This is allowed if you are a member
+ * of the role whose process is being terminated.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to terminate superuser process"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to reload the database configuration
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_reload_conf(PG_FUNCTION_ARGS)
+{
+	if (kill(PostmasterPid, SIGHUP))
+	{
+		ereport(WARNING,
+				(errmsg("failed to send signal to postmaster: %m")));
+		PG_RETURN_BOOL(false);
+	}
+
+	PG_RETURN_BOOL(true);
+}
+
+
+/*
+ * Rotate log file
+ *
+ * This function is kept to support adminpack 1.0.
+ */
+Datum
+pg_rotate_logfile(PG_FUNCTION_ARGS)
+{
+	if (!superuser())
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be superuser to rotate log files with adminpack 1.0"),
+				  errhint("Consider using pg_logfile_rotate(), which is part of core, instead."))));
+
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
+/*
+ * Rotate log file
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
+{
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index b24dece23f..6ea3679835 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -15,13 +15,11 @@
 #include "postgres.h"
 
 #include <sys/file.h>
-#include <signal.h>
 #include <dirent.h>
 #include <math.h>
 #include <unistd.h>
 
 #include "access/sysattr.h"
-#include "catalog/pg_authid.h"
 #include "catalog/catalog.h"
 #include "catalog/pg_tablespace.h"
 #include "catalog/pg_type.h"
@@ -35,13 +33,9 @@
 #include "postmaster/syslogger.h"
 #include "rewrite/rewriteHandler.h"
 #include "storage/fd.h"
-#include "storage/pmsignal.h"
-#include "storage/proc.h"
-#include "storage/procarray.h"
 #include "utils/lsyscache.h"
 #include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
-#include "utils/acl.h"
 #include "utils/builtins.h"
 #include "utils/timestamp.h"
 
@@ -198,194 +192,6 @@ current_query(PG_FUNCTION_ARGS)
 		PG_RETURN_NULL();
 }
 
-/*
- * Send a signal to another backend.
- *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
- *
- * Returns 0 on success, 1 on general failure, 2 on normal permission error
- * and 3 if the caller needs to be a superuser.
- *
- * In the event of a general failure (return code 1), a warning message will
- * be emitted. For permission errors, doing that is the responsibility of
- * the caller.
- */
-#define SIGNAL_BACKEND_SUCCESS 0
-#define SIGNAL_BACKEND_ERROR 1
-#define SIGNAL_BACKEND_NOPERMISSION 2
-#define SIGNAL_BACKEND_NOSUPERUSER 3
-static int
-pg_signal_backend(int pid, int sig)
-{
-	PGPROC	   *proc = BackendPidGetProc(pid);
-
-	/*
-	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
-	 * we reach kill(), a process for which we get a valid proc here might
-	 * have terminated on its own.  There's no way to acquire a lock on an
-	 * arbitrary process to prevent that. But since so far all the callers of
-	 * this mechanism involve some request for ending the process anyway, that
-	 * it might end on its own first is not a problem.
-	 */
-	if (proc == NULL)
-	{
-		/*
-		 * This is just a warning so a loop-through-resultset will not abort
-		 * if one backend terminated on its own during the run.
-		 */
-		ereport(WARNING,
-				(errmsg("PID %d is not a PostgreSQL server process", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-
-	/* Only allow superusers to signal superuser-owned backends. */
-	if (superuser_arg(proc->roleId) && !superuser())
-		return SIGNAL_BACKEND_NOSUPERUSER;
-
-	/* Users can signal backends they have role membership in. */
-	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
-		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
-		return SIGNAL_BACKEND_NOPERMISSION;
-
-	/*
-	 * Can the process we just validated above end, followed by the pid being
-	 * recycled for a new process, before reaching here?  Then we'd be trying
-	 * to kill the wrong thing.  Seems near impossible when sequential pid
-	 * assignment and wraparound is used.  Perhaps it could happen on a system
-	 * where pid re-use is randomized.  That race condition possibility seems
-	 * too unlikely to worry about.
-	 */
-
-	/* If we have setsid(), signal the backend's whole process group */
-#ifdef HAVE_SETSID
-	if (kill(-pid, sig))
-#else
-	if (kill(pid, sig))
-#endif
-	{
-		/* Again, just a warning to allow loops */
-		ereport(WARNING,
-				(errmsg("could not send signal to process %d: %m", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-	return SIGNAL_BACKEND_SUCCESS;
-}
-
-/*
- * Signal to cancel a backend process.  This is allowed if you are a member of
- * the role whose process is being canceled.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to cancel superuser query"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to terminate a backend process.  This is allowed if you are a member
- * of the role whose process is being terminated.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to terminate superuser process"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to reload the database configuration
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_reload_conf(PG_FUNCTION_ARGS)
-{
-	if (kill(PostmasterPid, SIGHUP))
-	{
-		ereport(WARNING,
-				(errmsg("failed to send signal to postmaster: %m")));
-		PG_RETURN_BOOL(false);
-	}
-
-	PG_RETURN_BOOL(true);
-}
-
-
-/*
- * Rotate log file
- *
- * This function is kept to support adminpack 1.0.
- */
-Datum
-pg_rotate_logfile(PG_FUNCTION_ARGS)
-{
-	if (!superuser())
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be superuser to rotate log files with adminpack 1.0"),
-				  errhint("Consider using pg_logfile_rotate(), which is part of core, instead."))));
-
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
-/*
- * Rotate log file
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
-{
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
 /* Function to find out which databases make use of a tablespace */
 
 typedef struct
-- 
2.14.1.145.gb3622a4ee

From 81db4811c1e01d3c4a934d0b35ecb0a2b0573649 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Wed, 13 Jun 2018 10:23:07 +0200
Subject: [PATCH 2/2] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend() or
pg_cancel_backend() to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
overloaded the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);

The backend API also expose functionality for altering the errcode
used when terminating or canceling the backend.
---
 doc/src/sgml/func.sgml                    |  13 +-
 src/backend/catalog/system_views.sql      |   8 +
 src/backend/storage/ipc/backend_signal.c  | 318 +++++++++++++++++++++++++++++-
 src/backend/storage/ipc/ipci.c            |   3 +
 src/backend/tcop/postgres.c               |  61 +++++-
 src/backend/utils/init/postinit.c         |   2 +
 src/include/catalog/pg_proc.dat           |   4 +-
 src/include/storage/backend_signal.h      |  27 +++
 src/test/regress/expected/admin_funcs.out |  30 +++
 src/test/regress/parallel_schedule        |   2 +-
 src/test/regress/sql/admin_funcs.sql      |  12 ++
 11 files changed, 462 insertions(+), 18 deletions(-)
 create mode 100644 src/include/storage/backend_signal.h
 create mode 100644 src/test/regress/expected/admin_funcs.out
 create mode 100644 src/test/regress/sql/admin_funcs.sql

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index bb794e044f..245c207ae4 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18554,7 +18554,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18579,7 +18579,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18610,6 +18610,15 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, it will
+    replace the default error message, which in turn will be the error
+    detail. <literal>message</literal> is limited to 128 ASCII characters, a
+    longer text will be truncated. An example where we cancel our own backend:
+<programlisting>
+postgres=# SELECT pg_cancel_backend(pg_backend_pid(), 'cancellation message text');
+ERROR:  cancellation message text
+DETAIL:  canceling statement due to user request by process 12345
+</programlisting>
    </para>
 
    <para>
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 7251552419..21ab9592a2 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -1027,6 +1027,14 @@ CREATE OR REPLACE FUNCTION pg_stop_backup (
   RETURNS SETOF record STRICT VOLATILE LANGUAGE internal as 'pg_stop_backup_v2'
   PARALLEL RESTRICTED;
 
+CREATE OR REPLACE FUNCTION
+  pg_cancel_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_cancel_backend' PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION
+  pg_terminate_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_terminate_backend' PARALLEL SAFE;
+
 -- legacy definition for compatibility with 9.3
 CREATE OR REPLACE FUNCTION
   json_populate_record(base anyelement, from_json json, use_json_as_text boolean DEFAULT false)
diff --git a/src/backend/storage/ipc/backend_signal.c b/src/backend/storage/ipc/backend_signal.c
index 2b81c161d9..c3c1198c45 100644
--- a/src/backend/storage/ipc/backend_signal.c
+++ b/src/backend/storage/ipc/backend_signal.c
@@ -18,20 +18,49 @@
 
 #include "catalog/pg_authid.h"
 #include "funcapi.h"
+#include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "postmaster/syslogger.h"
+#include "storage/backend_signal.h"
+#include "storage/ipc.h"
 #include "storage/pmsignal.h"
 #include "storage/proc.h"
 #include "storage/procarray.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
 
+/*
+ * Structure for registering a feedback payload to be sent to a cancelled, or
+ * terminated backend. Each backend is registered per pid in the array which is
+ * indexed by Backend ID. Reading and writing the message is protected by a
+ * per-slot spinlock.
+ */
+typedef struct
+{
+	pid_t	dest_pid;		/* The pid of the process being signalled */
+	pid_t	src_pid;		/* The pid of the processing signalling */
+	slock_t	mutex;			/* Per-slot protection */
+	char	message[MAX_CANCEL_MSG]; /* Message to send to signalled backend */
+	int		orig_length;	/* Length of the message as passed by the user,
+							 * if this length exceeds MAX_CANCEL_MSG it will
+							 * be truncated but we store the original length
+							 * in order to be able to convey truncation */
+	int		sqlerrcode;		/* errcode to use when signalling backend */
+} BackendSignalFeedbackShmemStruct;
+
+static BackendSignalFeedbackShmemStruct	*BackendSignalFeedbackSlots = NULL;
+static volatile BackendSignalFeedbackShmemStruct *MyCancelSlot = NULL;
+static void CleanupBackendSignalFeedback(int status, Datum argument);
+static int backend_feedback(pid_t backend_pid, char *message, int sqlerrcode);
+
 /*
  * Send a signal to another backend.
  *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
+ * The signal is delivered if the user is either a superuser or the same role
+ * as the backend being signaled. For "dangerous" signals, an explicit check
+ * for superuser needs to be done prior to calling this function. If msg is
+ * set, the contents will be passed as a message to the backend in the error
+ * message.
  *
  * Returns 0 on success, 1 on general failure, 2 on normal permission error
  * and 3 if the caller needs to be a superuser.
@@ -45,7 +74,7 @@
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -77,6 +106,30 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+	{
+		char *tmp = msg;
+
+		/*
+		 * The message to pass to the signalled backend is currently restricted
+		 * to ASCII only, since the sending backend might use an encoding which
+		 * is incompatible with the receiving with regards to conversion.
+		 */
+		while (*tmp != '\0')
+		{
+			if (!isascii(*tmp))
+				ereport(ERROR,
+						(errmsg("message is restricted to ASCII only")));
+			tmp++;
+		}
+
+		if (sig == SIGINT)
+			SetBackendCancelMessage(pid, msg);
+		else
+			SetBackendTerminationMessage(pid, msg);
+	}
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -110,7 +163,19 @@ pg_signal_backend(int pid, int sig)
 Datum
 pg_cancel_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -134,7 +199,19 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 Datum
 pg_terminate_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -146,7 +223,7 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
 }
 
 /*
@@ -214,3 +291,230 @@ pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(true);
 }
 
+/*
+ * The following routines handle registering an optional message when
+ * cancelling, or terminating, a backend as well changing the sqlerrcode used.
+ * The combined payload of message/errcode is referred to as feedback.  The
+ * message will be stored in shared memory and is limited to MAX_CANCEL_MSG
+ * characters including the NULL terminator.
+ *
+ * Access to the feedback slots is protected by spinlocks.
+ */
+
+/*
+ * Return the required size for the cancelation feedback Shmem area.
+ */
+Size
+BackendSignalFeedbackShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendSignalFeedbackShmemStruct);
+}
+
+/*
+ * Create and initialize the Shmem structure for holding the feedback, the
+ * bookkeeping for them and the spinlocks associated.
+ */
+void
+BackendSignalFeedbackShmemInit(void)
+{
+	Size	size = BackendSignalFeedbackShmemSize();
+	bool	found;
+	int		i;
+
+	BackendSignalFeedbackSlots = (BackendSignalFeedbackShmemStruct *)
+		ShmemInitStruct("BackendSignalFeedbackSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendSignalFeedbackSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendSignalFeedbackSlots[i].mutex));
+	}
+}
+
+/*
+ * Set up the slot for the current backend_id
+ */
+void
+BackendSignalFeedbackInit(int backend_id)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->dest_pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupBackendSignalFeedback, Int32GetDatum(backend_id));
+}
+
+/*
+ * Ensure that the slot is purged and emptied at exit. Any message gets
+ * overwritten with null chars to avoid risking exposing a message intended for
+ * another backend to a new backend.
+ */
+static void
+CleanupBackendSignalFeedback(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->orig_length > 0)
+		MemSet(slot->message, '\0', sizeof(slot->message));
+
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->dest_pid = 0;
+	slot->src_pid = 0;
+}
+
+/*
+ * Set a message for the cancellation of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendCancelMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_QUERY_CANCELED);
+}
+
+/*
+ * Set a message for the termination of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendTerminationMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_ADMIN_SHUTDOWN);
+}
+
+/*
+ * Set both a message and a sqlerrcode for use when signalling the backend
+ * with the specified pid.
+ */
+int
+SetBackendSignalFeedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	return backend_feedback(backend_pid, message, sqlerrcode);
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns zero on success. If the backend isn't found, or no message is
+ * passed, 1 is returned.  If two backends collide in setting a message, the
+ * existing message will be overwritten by the last one in. The message will
+ * be truncated to fit within MAX_CANCEL_MSG bytes.
+ */
+static int
+backend_feedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	int		i;
+	int		len;
+
+	if (!message)
+		return 1;
+
+	len = pg_mbcliplen(message, strlen(message), MAX_CANCEL_MSG - 1);
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		BackendSignalFeedbackShmemStruct *slot = &BackendSignalFeedbackSlots[i];
+
+		if (slot->dest_pid != 0 && slot->dest_pid == backend_pid)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->dest_pid != backend_pid)
+			{
+				SpinLockRelease(&slot->mutex);
+				return 1;
+			}
+
+			/* Avoid risking to leak any part of a previously set message */
+			MemSet(slot->message, '\0', sizeof(slot->message));
+
+			memcpy(slot->message, message, len);
+			slot->orig_length = pg_mbstrlen(message);
+			slot->sqlerrcode = sqlerrcode;
+			slot->src_pid = MyProcPid;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+/*
+ * HasBackendSignalFeedback
+ *		Test if there is a backend signalling feedback to consume
+ *
+ * Test whether there is feedback registered for the current backend that can
+ * be consumed and presented to the user. It isn't strictly required to call
+ * this function prior to consuming a potential message, but since consuming it
+ * will clear it there can be cases where one would like to peek first.
+ */
+bool
+HasBackendSignalFeedback(void)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = ((slot->orig_length > 0) && (slot->sqlerrcode != 0));
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * ConsumeBackendSignalFeedback
+ *		Read anc clear backend signalling feedback
+ *
+ * Return the configured signal feedback in buffer, which is buf_len bytes in
+ * size.  The original length of the message is returned, or zero in case no
+ * message was found. If the returned length exceeds that of Min(buf_len,
+ * MAX_CANCEL_MSG), then truncation has been performed. The feedback (message
+ * and errcode) is cleared on consumption. There is no point in passing a
+ * buffer larger than MAX_CANCEL_NSG as that is the upper bound on what will be
+ * stored in the slot.
+ */
+int
+ConsumeBackendSignalFeedback(char *buffer, size_t buf_len, int *sqlerrcode,
+							 pid_t *pid)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->orig_length > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->orig_length;
+		*sqlerrcode = slot->sqlerrcode;
+		*pid = slot->src_pid;
+		slot->orig_length = 0;
+		slot->message[0] = '\0';
+		slot->sqlerrcode = 0;
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 0c86a581c0..5d91450887 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -33,6 +33,7 @@
 #include "replication/walreceiver.h"
 #include "replication/walsender.h"
 #include "replication/origin.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/dsm.h"
 #include "storage/ipc.h"
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, BackendSignalFeedbackShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendSignalFeedbackShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 7a9ada2c71..a29d8bd9f6 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -62,6 +62,7 @@
 #include "replication/slot.h"
 #include "replication/walsender.h"
 #include "rewrite/rewriteHandler.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
 #include "storage/proc.h"
@@ -2920,9 +2921,33 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_ADMIN_SHUTDOWN;
+					buffer[0] = '\0';
+				}
+				ereport(FATAL,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("terminating connection due to administrator command by process %d",
+								   pid)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3033,9 +3058,33 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_QUERY_CANCELED;
+					buffer[0] = '\0';
+				}
+
+				ereport(ERROR,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("canceling statement due to user request by process %d",
+								   pid)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 5ef6315d20..8bbfdde93c 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -40,6 +40,7 @@
 #include "postmaster/autovacuum.h"
 #include "postmaster/postmaster.h"
 #include "replication/walsender.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/fd.h"
 #include "storage/ipc.h"
@@ -758,6 +759,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendSignalFeedbackInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index a14651010f..bd4831f639 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5972,10 +5972,10 @@
 
 { oid => '2171', descr => 'cancel a server process\' current query',
   proname => 'pg_cancel_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_cancel_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_cancel_backend' },
 { oid => '2096', descr => 'terminate a server process',
   proname => 'pg_terminate_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_terminate_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_terminate_backend' },
 { oid => '2172', descr => 'prepare for taking an online backup',
   proname => 'pg_start_backup', provolatile => 'v', proparallel => 'r',
   prorettype => 'pg_lsn', proargtypes => 'text bool bool',
diff --git a/src/include/storage/backend_signal.h b/src/include/storage/backend_signal.h
new file mode 100644
index 0000000000..86b46b3cc4
--- /dev/null
+++ b/src/include/storage/backend_signal.h
@@ -0,0 +1,27 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.h
+ *		Declarations for backend signalling
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/backend_signal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BACKEND_SIGNAL_H
+#define BACKEND_SIGNAL_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size BackendSignalFeedbackShmemSize(void);
+extern void BackendSignalFeedbackShmemInit(void);
+extern void BackendSignalFeedbackInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern int SetBackendTerminationMessage(pid_t backend, char *message);
+extern int SetBackendSignalFeedback(pid_t backend, char *message, int sqlerrcode);
+extern bool HasBackendSignalFeedback(void);
+extern int ConsumeBackendSignalFeedback(char *msg, size_t len, int *sqlerrcode, pid_t *pid);
+
+#endif /* BACKEND_SIGNAL_H */
diff --git a/src/test/regress/expected/admin_funcs.out b/src/test/regress/expected/admin_funcs.out
new file mode 100644
index 0000000000..d3723fddca
--- /dev/null
+++ b/src/test/regress/expected/admin_funcs.out
@@ -0,0 +1,30 @@
+select pg_cancel_backend(NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(pg_backend_pid());
+ERROR:  canceling statement due to user request
+select pg_cancel_backend(NULL, NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(NULL, 'suicide is painless');
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select case
+	when pg_cancel_backend(pg_backend_pid(), 'ソケットをブロッキングモードに設定できませんでした')
+	then pg_sleep(60)
+end;
+ERROR:  message is restricted to ASCII only
+select case
+	when pg_cancel_backend(pg_backend_pid(), NULL)
+	then pg_sleep(60)
+end;
+ERROR:  canceling statement due to user request
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 16f979c8d9..cdba9235b6 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -84,7 +84,7 @@ test: select_into select_distinct select_distinct_on select_implicit select_havi
 # ----------
 # Another group of parallel tests
 # ----------
-test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index
+test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index admin_funcs
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/admin_funcs.sql b/src/test/regress/sql/admin_funcs.sql
new file mode 100644
index 0000000000..36fde4cbf4
--- /dev/null
+++ b/src/test/regress/sql/admin_funcs.sql
@@ -0,0 +1,12 @@
+select pg_cancel_backend(NULL);
+select pg_cancel_backend(pg_backend_pid());
+select pg_cancel_backend(NULL, NULL);
+select pg_cancel_backend(NULL, 'suicide is painless');
+select case
+	when pg_cancel_backend(pg_backend_pid(), 'ソケットをブロッキングモードに設定できませんでした')
+	then pg_sleep(60)
+end;
+select case
+	when pg_cancel_backend(pg_backend_pid(), NULL)
+	then pg_sleep(60)
+end;
-- 
2.14.1.145.gb3622a4ee

From 1f65beed14e976b95dfab00d55b2d0fde4f41df8 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Wed, 13 Jun 2018 10:23:04 +0200
Subject: [PATCH 1/2] Refactor backend signalling code

This moves the system administration functions for signalling backends
from backend/utils/adt/misc.c into a separate file dedicated to backend
signalling. No new functionality is introduced in this commit.
---
 src/backend/storage/ipc/Makefile      |   6 +-
 src/backend/storage/ipc/ipci.c        |   1 +
 src/backend/storage/ipc/signalfuncs.c | 218 ++++++++++++++++++++++++++++++++++
 src/backend/tcop/postgres.c           |   1 +
 src/backend/utils/adt/misc.c          | 194 ------------------------------
 src/backend/utils/init/postinit.c     |   1 +
 src/include/storage/signalfuncs.h     |  27 +++++
 7 files changed, 251 insertions(+), 197 deletions(-)
 create mode 100644 src/backend/storage/ipc/signalfuncs.c
 create mode 100644 src/include/storage/signalfuncs.h

diff --git a/src/backend/storage/ipc/Makefile b/src/backend/storage/ipc/Makefile
index 9dbdc26c9b..bf4619d5fd 100644
--- a/src/backend/storage/ipc/Makefile
+++ b/src/backend/storage/ipc/Makefile
@@ -8,8 +8,8 @@ subdir = src/backend/storage/ipc
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o pmsignal.o procarray.o \
-	procsignal.o  shmem.o shmqueue.o shm_mq.o shm_toc.o sinval.o \
-	sinvaladt.o standby.o
+OBJS = signalfuncs.o barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o \
+	pmsignal.o procarray.o procsignal.o shmem.o shmqueue.o shm_mq.o \
+	shm_toc.o sinval.o sinvaladt.o standby.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 0c86a581c0..f1c460a761 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -42,6 +42,7 @@
 #include "storage/proc.h"
 #include "storage/procarray.h"
 #include "storage/procsignal.h"
+#include "storage/signalfuncs.h"
 #include "storage/sinvaladt.h"
 #include "storage/spin.h"
 #include "utils/backend_random.h"
diff --git a/src/backend/storage/ipc/signalfuncs.c b/src/backend/storage/ipc/signalfuncs.c
new file mode 100644
index 0000000000..249358e9c9
--- /dev/null
+++ b/src/backend/storage/ipc/signalfuncs.c
@@ -0,0 +1,218 @@
+/*-------------------------------------------------------------------------
+ *
+ * signalfuncs.c
+ *	  Routines for signalling backends
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/ipc/signalfuncs.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <signal.h>
+
+#include "catalog/pg_authid.h"
+#include "funcapi.h"
+#include "miscadmin.h"
+#include "postmaster/syslogger.h"
+#include "storage/ipc.h"
+#include "storage/pmsignal.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "storage/signalfuncs.h"
+#include "utils/acl.h"
+#include "utils/builtins.h"
+
+/*
+ * Send a signal to another backend.
+ *
+ * The signal is delivered if the user is either a superuser or the same
+ * role as the backend being signaled. For "dangerous" signals, an explicit
+ * check for superuser needs to be done prior to calling this function.
+ *
+ * Returns 0 on success, 1 on general failure, 2 on normal permission error
+ * and 3 if the caller needs to be a superuser.
+ *
+ * In the event of a general failure (return code 1), a warning message will
+ * be emitted. For permission errors, doing that is the responsibility of
+ * the caller.
+ */
+#define SIGNAL_BACKEND_SUCCESS 0
+#define SIGNAL_BACKEND_ERROR 1
+#define SIGNAL_BACKEND_NOPERMISSION 2
+#define SIGNAL_BACKEND_NOSUPERUSER 3
+static int
+pg_signal_backend(int pid, int sig)
+{
+	PGPROC	   *proc = BackendPidGetProc(pid);
+
+	/*
+	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
+	 * we reach kill(), a process for which we get a valid proc here might
+	 * have terminated on its own.  There's no way to acquire a lock on an
+	 * arbitrary process to prevent that. But since so far all the callers of
+	 * this mechanism involve some request for ending the process anyway, that
+	 * it might end on its own first is not a problem.
+	 */
+	if (proc == NULL)
+	{
+		/*
+		 * This is just a warning so a loop-through-resultset will not abort
+		 * if one backend terminated on its own during the run.
+		 */
+		ereport(WARNING,
+				(errmsg("PID %d is not a PostgreSQL server process", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+
+	/* Only allow superusers to signal superuser-owned backends. */
+	if (superuser_arg(proc->roleId) && !superuser())
+		return SIGNAL_BACKEND_NOSUPERUSER;
+
+	/* Users can signal backends they have role membership in. */
+	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
+		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
+		return SIGNAL_BACKEND_NOPERMISSION;
+
+	/*
+	 * Can the process we just validated above end, followed by the pid being
+	 * recycled for a new process, before reaching here?  Then we'd be trying
+	 * to kill the wrong thing.  Seems near impossible when sequential pid
+	 * assignment and wraparound is used.  Perhaps it could happen on a system
+	 * where pid re-use is randomized.  That race condition possibility seems
+	 * too unlikely to worry about.
+	 */
+
+	/* If we have setsid(), signal the backend's whole process group */
+#ifdef HAVE_SETSID
+	if (kill(-pid, sig))
+#else
+	if (kill(pid, sig))
+#endif
+	{
+		/* Again, just a warning to allow loops */
+		ereport(WARNING,
+				(errmsg("could not send signal to process %d: %m", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+	return SIGNAL_BACKEND_SUCCESS;
+}
+
+/*
+ * Signal to cancel a backend process.  This is allowed if you are a member of
+ * the role whose process is being canceled.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to cancel superuser query"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to terminate a backend process.  This is allowed if you are a member
+ * of the role whose process is being terminated.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to terminate superuser process"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to reload the database configuration
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_reload_conf(PG_FUNCTION_ARGS)
+{
+	if (kill(PostmasterPid, SIGHUP))
+	{
+		ereport(WARNING,
+				(errmsg("failed to send signal to postmaster: %m")));
+		PG_RETURN_BOOL(false);
+	}
+
+	PG_RETURN_BOOL(true);
+}
+
+
+/*
+ * Rotate log file
+ *
+ * This function is kept to support adminpack 1.0.
+ */
+Datum
+pg_rotate_logfile(PG_FUNCTION_ARGS)
+{
+	if (!superuser())
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be superuser to rotate log files with adminpack 1.0"),
+				  errhint("Consider using pg_logfile_rotate(), which is part of core, instead."))));
+
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
+/*
+ * Rotate log file
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
+{
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index e4c6e3d406..b17531b2cd 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -66,6 +66,7 @@
 #include "storage/ipc.h"
 #include "storage/proc.h"
 #include "storage/procsignal.h"
+#include "storage/signalfuncs.h"
 #include "storage/sinval.h"
 #include "tcop/fastpath.h"
 #include "tcop/pquery.h"
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index b24dece23f..6ea3679835 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -15,13 +15,11 @@
 #include "postgres.h"
 
 #include <sys/file.h>
-#include <signal.h>
 #include <dirent.h>
 #include <math.h>
 #include <unistd.h>
 
 #include "access/sysattr.h"
-#include "catalog/pg_authid.h"
 #include "catalog/catalog.h"
 #include "catalog/pg_tablespace.h"
 #include "catalog/pg_type.h"
@@ -35,13 +33,9 @@
 #include "postmaster/syslogger.h"
 #include "rewrite/rewriteHandler.h"
 #include "storage/fd.h"
-#include "storage/pmsignal.h"
-#include "storage/proc.h"
-#include "storage/procarray.h"
 #include "utils/lsyscache.h"
 #include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
-#include "utils/acl.h"
 #include "utils/builtins.h"
 #include "utils/timestamp.h"
 
@@ -198,194 +192,6 @@ current_query(PG_FUNCTION_ARGS)
 		PG_RETURN_NULL();
 }
 
-/*
- * Send a signal to another backend.
- *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
- *
- * Returns 0 on success, 1 on general failure, 2 on normal permission error
- * and 3 if the caller needs to be a superuser.
- *
- * In the event of a general failure (return code 1), a warning message will
- * be emitted. For permission errors, doing that is the responsibility of
- * the caller.
- */
-#define SIGNAL_BACKEND_SUCCESS 0
-#define SIGNAL_BACKEND_ERROR 1
-#define SIGNAL_BACKEND_NOPERMISSION 2
-#define SIGNAL_BACKEND_NOSUPERUSER 3
-static int
-pg_signal_backend(int pid, int sig)
-{
-	PGPROC	   *proc = BackendPidGetProc(pid);
-
-	/*
-	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
-	 * we reach kill(), a process for which we get a valid proc here might
-	 * have terminated on its own.  There's no way to acquire a lock on an
-	 * arbitrary process to prevent that. But since so far all the callers of
-	 * this mechanism involve some request for ending the process anyway, that
-	 * it might end on its own first is not a problem.
-	 */
-	if (proc == NULL)
-	{
-		/*
-		 * This is just a warning so a loop-through-resultset will not abort
-		 * if one backend terminated on its own during the run.
-		 */
-		ereport(WARNING,
-				(errmsg("PID %d is not a PostgreSQL server process", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-
-	/* Only allow superusers to signal superuser-owned backends. */
-	if (superuser_arg(proc->roleId) && !superuser())
-		return SIGNAL_BACKEND_NOSUPERUSER;
-
-	/* Users can signal backends they have role membership in. */
-	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
-		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
-		return SIGNAL_BACKEND_NOPERMISSION;
-
-	/*
-	 * Can the process we just validated above end, followed by the pid being
-	 * recycled for a new process, before reaching here?  Then we'd be trying
-	 * to kill the wrong thing.  Seems near impossible when sequential pid
-	 * assignment and wraparound is used.  Perhaps it could happen on a system
-	 * where pid re-use is randomized.  That race condition possibility seems
-	 * too unlikely to worry about.
-	 */
-
-	/* If we have setsid(), signal the backend's whole process group */
-#ifdef HAVE_SETSID
-	if (kill(-pid, sig))
-#else
-	if (kill(pid, sig))
-#endif
-	{
-		/* Again, just a warning to allow loops */
-		ereport(WARNING,
-				(errmsg("could not send signal to process %d: %m", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-	return SIGNAL_BACKEND_SUCCESS;
-}
-
-/*
- * Signal to cancel a backend process.  This is allowed if you are a member of
- * the role whose process is being canceled.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to cancel superuser query"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to terminate a backend process.  This is allowed if you are a member
- * of the role whose process is being terminated.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to terminate superuser process"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to reload the database configuration
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_reload_conf(PG_FUNCTION_ARGS)
-{
-	if (kill(PostmasterPid, SIGHUP))
-	{
-		ereport(WARNING,
-				(errmsg("failed to send signal to postmaster: %m")));
-		PG_RETURN_BOOL(false);
-	}
-
-	PG_RETURN_BOOL(true);
-}
-
-
-/*
- * Rotate log file
- *
- * This function is kept to support adminpack 1.0.
- */
-Datum
-pg_rotate_logfile(PG_FUNCTION_ARGS)
-{
-	if (!superuser())
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be superuser to rotate log files with adminpack 1.0"),
-				  errhint("Consider using pg_logfile_rotate(), which is part of core, instead."))));
-
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
-/*
- * Rotate log file
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
-{
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
 /* Function to find out which databases make use of a tablespace */
 
 typedef struct
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 4f1d2a0d28..5f61913120 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -47,6 +47,7 @@
 #include "storage/procarray.h"
 #include "storage/procsignal.h"
 #include "storage/proc.h"
+#include "storage/signalfuncs.h"
 #include "storage/sinvaladt.h"
 #include "storage/smgr.h"
 #include "tcop/tcopprot.h"
diff --git a/src/include/storage/signalfuncs.h b/src/include/storage/signalfuncs.h
new file mode 100644
index 0000000000..73927cfa34
--- /dev/null
+++ b/src/include/storage/signalfuncs.h
@@ -0,0 +1,27 @@
+/*-------------------------------------------------------------------------
+ *
+ * signalfuncs.h
+ *		Declarations for backend signalling
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/signalfuncs.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef SIGNALFUNCS_H
+#define SIGNALFUNCS_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size BackendSignalFeedbackShmemSize(void);
+extern void BackendSignalFeedbackShmemInit(void);
+extern void BackendSignalFeedbackInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern int SetBackendTerminationMessage(pid_t backend, char *message);
+extern int SetBackendSignalFeedback(pid_t backend, char *message, int sqlerrcode);
+extern bool HasBackendSignalFeedback(void);
+extern int ConsumeBackendSignalFeedback(char *msg, size_t len, int *sqlerrcode, pid_t *pid);
+
+#endif /* SIGNALFUNCS_H */
-- 
2.14.1.145.gb3622a4ee

From 5a4de9a130ce4e664dd35cf9dbcbcaee3caec2ab Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Wed, 13 Jun 2018 10:23:07 +0200
Subject: [PATCH 2/2] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend() or
pg_cancel_backend() to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
overloaded the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);

The backend API also expose functionality for altering the errcode
used when terminating or canceling the backend.
---
 doc/src/sgml/func.sgml                    |  13 +-
 src/backend/catalog/system_views.sql      |   8 +
 src/backend/storage/ipc/ipci.c            |   3 +
 src/backend/storage/ipc/signalfuncs.c     | 316 +++++++++++++++++++++++++++++-
 src/backend/tcop/postgres.c               |  61 +++++-
 src/backend/utils/init/postinit.c         |   2 +
 src/include/catalog/pg_proc.dat           |   4 +-
 src/include/storage/backend_signal.h      |  27 +++
 src/test/regress/expected/admin_funcs.out |  25 +++
 src/test/regress/parallel_schedule        |   2 +-
 src/test/regress/sql/admin_funcs.sql      |   8 +
 11 files changed, 451 insertions(+), 18 deletions(-)
 create mode 100644 src/include/storage/backend_signal.h
 create mode 100644 src/test/regress/expected/admin_funcs.out
 create mode 100644 src/test/regress/sql/admin_funcs.sql

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 9a7f683658..e61a9b0d00 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18756,7 +18756,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18781,7 +18781,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18812,6 +18812,15 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, it will
+    replace the default error message, which in turn will be the error
+    detail. <literal>message</literal> is limited to 128 ASCII characters, a
+    longer text will be truncated. An example where we cancel our own backend:
+<programlisting>
+postgres=# SELECT pg_cancel_backend(pg_backend_pid(), 'cancellation message text');
+ERROR:  cancellation message text
+DETAIL:  canceling statement due to user request by process 12345
+</programlisting>
    </para>
 
    <para>
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 7251552419..21ab9592a2 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -1027,6 +1027,14 @@ CREATE OR REPLACE FUNCTION pg_stop_backup (
   RETURNS SETOF record STRICT VOLATILE LANGUAGE internal as 'pg_stop_backup_v2'
   PARALLEL RESTRICTED;
 
+CREATE OR REPLACE FUNCTION
+  pg_cancel_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_cancel_backend' PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION
+  pg_terminate_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_terminate_backend' PARALLEL SAFE;
+
 -- legacy definition for compatibility with 9.3
 CREATE OR REPLACE FUNCTION
   json_populate_record(base anyelement, from_json json, use_json_as_text boolean DEFAULT false)
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index f1c460a761..04127ead9d 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -33,6 +33,7 @@
 #include "replication/walreceiver.h"
 #include "replication/walsender.h"
 #include "replication/origin.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/dsm.h"
 #include "storage/ipc.h"
@@ -151,6 +152,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, BackendSignalFeedbackShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -271,6 +273,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendSignalFeedbackShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/storage/ipc/signalfuncs.c b/src/backend/storage/ipc/signalfuncs.c
index 249358e9c9..5809fffa45 100644
--- a/src/backend/storage/ipc/signalfuncs.c
+++ b/src/backend/storage/ipc/signalfuncs.c
@@ -18,6 +18,7 @@
 
 #include "catalog/pg_authid.h"
 #include "funcapi.h"
+#include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "postmaster/syslogger.h"
 #include "storage/ipc.h"
@@ -28,12 +29,38 @@
 #include "utils/acl.h"
 #include "utils/builtins.h"
 
+/*
+ * Structure for registering a feedback payload to be sent to a cancelled, or
+ * terminated backend. Each backend is registered per pid in the array which is
+ * indexed by Backend ID. Reading and writing the message is protected by a
+ * per-slot spinlock.
+ */
+typedef struct
+{
+	pid_t	dest_pid;		/* The pid of the process being signalled */
+	pid_t	src_pid;		/* The pid of the processing signalling */
+	slock_t	mutex;			/* Per-slot protection */
+	char	message[MAX_CANCEL_MSG]; /* Message to send to signalled backend */
+	int		orig_length;	/* Length of the message as passed by the user,
+							 * if this length exceeds MAX_CANCEL_MSG it will
+							 * be truncated but we store the original length
+							 * in order to be able to convey truncation */
+	int		sqlerrcode;		/* errcode to use when signalling backend */
+} BackendSignalFeedbackShmemStruct;
+
+static BackendSignalFeedbackShmemStruct	*BackendSignalFeedbackSlots = NULL;
+static volatile BackendSignalFeedbackShmemStruct *MyCancelSlot = NULL;
+static void CleanupBackendSignalFeedback(int status, Datum argument);
+static int backend_feedback(pid_t backend_pid, char *message, int sqlerrcode);
+
 /*
  * Send a signal to another backend.
  *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
+ * The signal is delivered if the user is either a superuser or the same role
+ * as the backend being signaled. For "dangerous" signals, an explicit check
+ * for superuser needs to be done prior to calling this function. If msg is
+ * set, the contents will be passed as a message to the backend in the error
+ * message.
  *
  * Returns 0 on success, 1 on general failure, 2 on normal permission error
  * and 3 if the caller needs to be a superuser.
@@ -47,7 +74,7 @@
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -79,6 +106,30 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+	{
+		char *tmp = msg;
+
+		/*
+		 * The message to pass to the signalled backend is currently restricted
+		 * to ASCII only, since the sending backend might use an encoding which
+		 * is incompatible with the receiving with regards to conversion.
+		 */
+		while (*tmp != '\0')
+		{
+			if (!isascii(*tmp))
+				ereport(ERROR,
+						(errmsg("message is restricted to ASCII only")));
+			tmp++;
+		}
+
+		if (sig == SIGINT)
+			SetBackendCancelMessage(pid, msg);
+		else
+			SetBackendTerminationMessage(pid, msg);
+	}
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -112,7 +163,19 @@ pg_signal_backend(int pid, int sig)
 Datum
 pg_cancel_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -136,7 +199,19 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 Datum
 pg_terminate_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -148,7 +223,7 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
 }
 
 /*
@@ -216,3 +291,230 @@ pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
 	PG_RETURN_BOOL(true);
 }
 
+/*
+ * The following routines handle registering an optional message when
+ * cancelling, or terminating, a backend as well changing the sqlerrcode used.
+ * The combined payload of message/errcode is referred to as feedback.  The
+ * message will be stored in shared memory and is limited to MAX_CANCEL_MSG
+ * characters including the NULL terminator.
+ *
+ * Access to the feedback slots is protected by spinlocks.
+ */
+
+/*
+ * Return the required size for the cancelation feedback Shmem area.
+ */
+Size
+BackendSignalFeedbackShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendSignalFeedbackShmemStruct);
+}
+
+/*
+ * Create and initialize the Shmem structure for holding the feedback, the
+ * bookkeeping for them and the spinlocks associated.
+ */
+void
+BackendSignalFeedbackShmemInit(void)
+{
+	Size	size = BackendSignalFeedbackShmemSize();
+	bool	found;
+	int		i;
+
+	BackendSignalFeedbackSlots = (BackendSignalFeedbackShmemStruct *)
+		ShmemInitStruct("BackendSignalFeedbackSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendSignalFeedbackSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendSignalFeedbackSlots[i].mutex));
+	}
+}
+
+/*
+ * Set up the slot for the current backend_id
+ */
+void
+BackendSignalFeedbackInit(int backend_id)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->dest_pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupBackendSignalFeedback, Int32GetDatum(backend_id));
+}
+
+/*
+ * Ensure that the slot is purged and emptied at exit. Any message gets
+ * overwritten with null chars to avoid risking exposing a message intended for
+ * another backend to a new backend.
+ */
+static void
+CleanupBackendSignalFeedback(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->orig_length > 0)
+		MemSet(slot->message, '\0', sizeof(slot->message));
+
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->dest_pid = 0;
+	slot->src_pid = 0;
+}
+
+/*
+ * Set a message for the cancellation of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendCancelMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_QUERY_CANCELED);
+}
+
+/*
+ * Set a message for the termination of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendTerminationMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_ADMIN_SHUTDOWN);
+}
+
+/*
+ * Set both a message and a sqlerrcode for use when signalling the backend
+ * with the specified pid.
+ */
+int
+SetBackendSignalFeedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	return backend_feedback(backend_pid, message, sqlerrcode);
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns zero on success. If the backend isn't found, or no message is
+ * passed, 1 is returned.  If two backends collide in setting a message, the
+ * existing message will be overwritten by the last one in. The message will
+ * be truncated to fit within MAX_CANCEL_MSG bytes.
+ */
+static int
+backend_feedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	int		i;
+	int		len;
+
+	if (!message)
+		return 1;
+
+	len = pg_mbcliplen(message, strlen(message), MAX_CANCEL_MSG - 1);
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		BackendSignalFeedbackShmemStruct *slot = &BackendSignalFeedbackSlots[i];
+
+		if (slot->dest_pid != 0 && slot->dest_pid == backend_pid)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->dest_pid != backend_pid)
+			{
+				SpinLockRelease(&slot->mutex);
+				return 1;
+			}
+
+			/* Avoid risking to leak any part of a previously set message */
+			MemSet(slot->message, '\0', sizeof(slot->message));
+
+			memcpy(slot->message, message, len);
+			slot->orig_length = pg_mbstrlen(message);
+			slot->sqlerrcode = sqlerrcode;
+			slot->src_pid = MyProcPid;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+/*
+ * HasBackendSignalFeedback
+ *		Test if there is a backend signalling feedback to consume
+ *
+ * Test whether there is feedback registered for the current backend that can
+ * be consumed and presented to the user. It isn't strictly required to call
+ * this function prior to consuming a potential message, but since consuming it
+ * will clear it there can be cases where one would like to peek first.
+ */
+bool
+HasBackendSignalFeedback(void)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = ((slot->orig_length > 0) && (slot->sqlerrcode != 0));
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * ConsumeBackendSignalFeedback
+ *		Read anc clear backend signalling feedback
+ *
+ * Return the configured signal feedback in buffer, which is buf_len bytes in
+ * size.  The original length of the message is returned, or zero in case no
+ * message was found. If the returned length exceeds that of Min(buf_len,
+ * MAX_CANCEL_MSG), then truncation has been performed. The feedback (message
+ * and errcode) is cleared on consumption. There is no point in passing a
+ * buffer larger than MAX_CANCEL_NSG as that is the upper bound on what will be
+ * stored in the slot.
+ */
+int
+ConsumeBackendSignalFeedback(char *buffer, size_t buf_len, int *sqlerrcode,
+							 pid_t *pid)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->orig_length > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->orig_length;
+		*sqlerrcode = slot->sqlerrcode;
+		*pid = slot->src_pid;
+		slot->orig_length = 0;
+		slot->message[0] = '\0';
+		slot->sqlerrcode = 0;
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index b17531b2cd..d53a44f708 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -62,6 +62,7 @@
 #include "replication/slot.h"
 #include "replication/walsender.h"
 #include "rewrite/rewriteHandler.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
 #include "storage/proc.h"
@@ -2991,9 +2992,33 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_ADMIN_SHUTDOWN;
+					buffer[0] = '\0';
+				}
+				ereport(FATAL,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("terminating connection due to administrator command by process %d",
+								   pid)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3104,9 +3129,33 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_QUERY_CANCELED;
+					buffer[0] = '\0';
+				}
+
+				ereport(ERROR,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("canceling statement due to user request by process %d",
+								   pid)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 5f61913120..f0265624f4 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -40,6 +40,7 @@
 #include "postmaster/autovacuum.h"
 #include "postmaster/postmaster.h"
 #include "replication/walsender.h"
+#include "storage/backend_signal.h"
 #include "storage/bufmgr.h"
 #include "storage/fd.h"
 #include "storage/ipc.h"
@@ -781,6 +782,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendSignalFeedbackInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 8e4145f42b..ae5d45685e 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5972,10 +5972,10 @@
 
 { oid => '2171', descr => 'cancel a server process\' current query',
   proname => 'pg_cancel_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_cancel_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_cancel_backend' },
 { oid => '2096', descr => 'terminate a server process',
   proname => 'pg_terminate_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_terminate_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_terminate_backend' },
 { oid => '2172', descr => 'prepare for taking an online backup',
   proname => 'pg_start_backup', provolatile => 'v', proparallel => 'r',
   prorettype => 'pg_lsn', proargtypes => 'text bool bool',
diff --git a/src/include/storage/backend_signal.h b/src/include/storage/backend_signal.h
new file mode 100644
index 0000000000..86b46b3cc4
--- /dev/null
+++ b/src/include/storage/backend_signal.h
@@ -0,0 +1,27 @@
+/*-------------------------------------------------------------------------
+ *
+ * backend_signal.h
+ *		Declarations for backend signalling
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/backend_signal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef BACKEND_SIGNAL_H
+#define BACKEND_SIGNAL_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size BackendSignalFeedbackShmemSize(void);
+extern void BackendSignalFeedbackShmemInit(void);
+extern void BackendSignalFeedbackInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern int SetBackendTerminationMessage(pid_t backend, char *message);
+extern int SetBackendSignalFeedback(pid_t backend, char *message, int sqlerrcode);
+extern bool HasBackendSignalFeedback(void);
+extern int ConsumeBackendSignalFeedback(char *msg, size_t len, int *sqlerrcode, pid_t *pid);
+
+#endif /* BACKEND_SIGNAL_H */
diff --git a/src/test/regress/expected/admin_funcs.out b/src/test/regress/expected/admin_funcs.out
new file mode 100644
index 0000000000..d99bd56532
--- /dev/null
+++ b/src/test/regress/expected/admin_funcs.out
@@ -0,0 +1,25 @@
+select pg_cancel_backend(NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(pg_backend_pid());
+ERROR:  canceling statement due to user request
+select pg_cancel_backend(NULL, NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(NULL, 'suicide is painless');
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select case
+	when pg_cancel_backend(pg_backend_pid(), NULL)
+	then pg_sleep(60)
+end;
+ERROR:  canceling statement due to user request
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 16f979c8d9..cdba9235b6 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -84,7 +84,7 @@ test: select_into select_distinct select_distinct_on select_implicit select_havi
 # ----------
 # Another group of parallel tests
 # ----------
-test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index
+test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index admin_funcs
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/admin_funcs.sql b/src/test/regress/sql/admin_funcs.sql
new file mode 100644
index 0000000000..570c552347
--- /dev/null
+++ b/src/test/regress/sql/admin_funcs.sql
@@ -0,0 +1,8 @@
+select pg_cancel_backend(NULL);
+select pg_cancel_backend(pg_backend_pid());
+select pg_cancel_backend(NULL, NULL);
+select pg_cancel_backend(NULL, 'suicide is painless');
+select case
+	when pg_cancel_backend(pg_backend_pid(), NULL)
+	then pg_sleep(60)
+end;
-- 
2.14.1.145.gb3622a4ee

diff --git a/src/backend/storage/ipc/Makefile b/src/backend/storage/ipc/Makefile
index 9dbdc26c9b..bf4619d5fd 100644
--- a/src/backend/storage/ipc/Makefile
+++ b/src/backend/storage/ipc/Makefile
@@ -8,8 +8,8 @@ subdir = src/backend/storage/ipc
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o pmsignal.o procarray.o \
-	procsignal.o  shmem.o shmqueue.o shm_mq.o shm_toc.o sinval.o \
-	sinvaladt.o standby.o
+OBJS = signalfuncs.o barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o \
+	pmsignal.o procarray.o procsignal.o shmem.o shmqueue.o shm_mq.o \
+	shm_toc.o sinval.o sinvaladt.o standby.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/ipc/signalfuncs.c b/src/backend/storage/ipc/signalfuncs.c
new file mode 100644
index 0000000000..c09a047127
--- /dev/null
+++ b/src/backend/storage/ipc/signalfuncs.c
@@ -0,0 +1,216 @@
+/*-------------------------------------------------------------------------
+ *
+ * signalfuncs.c
+ *	  Functions for signalling backends
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/ipc/signalfuncs.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include <signal.h>
+
+#include "catalog/pg_authid.h"
+#include "funcapi.h"
+#include "miscadmin.h"
+#include "postmaster/syslogger.h"
+#include "storage/ipc.h"
+#include "storage/pmsignal.h"
+#include "storage/proc.h"
+#include "storage/procarray.h"
+#include "utils/acl.h"
+#include "utils/builtins.h"
+
+/*
+ * Send a signal to another backend.
+ *
+ * The signal is delivered if the user is either a superuser or the same
+ * role as the backend being signaled. For "dangerous" signals, an explicit
+ * check for superuser needs to be done prior to calling this function.
+ *
+ * Returns 0 on success, 1 on general failure, 2 on normal permission error
+ * and 3 if the caller needs to be a superuser.
+ *
+ * In the event of a general failure (return code 1), a warning message will
+ * be emitted. For permission errors, doing that is the responsibility of
+ * the caller.
+ */
+#define SIGNAL_BACKEND_SUCCESS 0
+#define SIGNAL_BACKEND_ERROR 1
+#define SIGNAL_BACKEND_NOPERMISSION 2
+#define SIGNAL_BACKEND_NOSUPERUSER 3
+static int
+pg_signal_backend(int pid, int sig)
+{
+	PGPROC	   *proc = BackendPidGetProc(pid);
+
+	/*
+	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
+	 * we reach kill(), a process for which we get a valid proc here might
+	 * have terminated on its own.  There's no way to acquire a lock on an
+	 * arbitrary process to prevent that. But since so far all the callers of
+	 * this mechanism involve some request for ending the process anyway, that
+	 * it might end on its own first is not a problem.
+	 */
+	if (proc == NULL)
+	{
+		/*
+		 * This is just a warning so a loop-through-resultset will not abort
+		 * if one backend terminated on its own during the run.
+		 */
+		ereport(WARNING,
+				(errmsg("PID %d is not a PostgreSQL server process", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+
+	/* Only allow superusers to signal superuser-owned backends. */
+	if (superuser_arg(proc->roleId) && !superuser())
+		return SIGNAL_BACKEND_NOSUPERUSER;
+
+	/* Users can signal backends they have role membership in. */
+	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
+		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
+		return SIGNAL_BACKEND_NOPERMISSION;
+
+	/*
+	 * Can the process we just validated above end, followed by the pid being
+	 * recycled for a new process, before reaching here?  Then we'd be trying
+	 * to kill the wrong thing.  Seems near impossible when sequential pid
+	 * assignment and wraparound is used.  Perhaps it could happen on a system
+	 * where pid re-use is randomized.  That race condition possibility seems
+	 * too unlikely to worry about.
+	 */
+
+	/* If we have setsid(), signal the backend's whole process group */
+#ifdef HAVE_SETSID
+	if (kill(-pid, sig))
+#else
+	if (kill(pid, sig))
+#endif
+	{
+		/* Again, just a warning to allow loops */
+		ereport(WARNING,
+				(errmsg("could not send signal to process %d: %m", pid)));
+		return SIGNAL_BACKEND_ERROR;
+	}
+	return SIGNAL_BACKEND_SUCCESS;
+}
+
+/*
+ * Signal to cancel a backend process.  This is allowed if you are a member of
+ * the role whose process is being canceled.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_cancel_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to cancel superuser query"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to terminate a backend process.  This is allowed if you are a member
+ * of the role whose process is being terminated.
+ *
+ * Note that only superusers can signal superuser-owned processes.
+ */
+Datum
+pg_terminate_backend(PG_FUNCTION_ARGS)
+{
+	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+
+	if (r == SIGNAL_BACKEND_NOSUPERUSER)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a superuser to terminate superuser process"))));
+
+	if (r == SIGNAL_BACKEND_NOPERMISSION)
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
+
+	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+}
+
+/*
+ * Signal to reload the database configuration
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_reload_conf(PG_FUNCTION_ARGS)
+{
+	if (kill(PostmasterPid, SIGHUP))
+	{
+		ereport(WARNING,
+				(errmsg("failed to send signal to postmaster: %m")));
+		PG_RETURN_BOOL(false);
+	}
+
+	PG_RETURN_BOOL(true);
+}
+
+
+/*
+ * Rotate log file
+ *
+ * This function is kept to support adminpack 1.0.
+ */
+Datum
+pg_rotate_logfile(PG_FUNCTION_ARGS)
+{
+	if (!superuser())
+		ereport(ERROR,
+				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+				 (errmsg("must be superuser to rotate log files with adminpack 1.0"),
+				  errhint("Consider using pg_logfile_rotate(), which is part of core, instead."))));
+
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
+
+/*
+ * Rotate log file
+ *
+ * Permission checking for this function is managed through the normal
+ * GRANT system.
+ */
+Datum
+pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
+{
+	if (!Logging_collector)
+	{
+		ereport(WARNING,
+				(errmsg("rotation not possible because log collection not active")));
+		PG_RETURN_BOOL(false);
+	}
+
+	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
+	PG_RETURN_BOOL(true);
+}
diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c
index b24dece23f..6ea3679835 100644
--- a/src/backend/utils/adt/misc.c
+++ b/src/backend/utils/adt/misc.c
@@ -15,13 +15,11 @@
 #include "postgres.h"
 
 #include <sys/file.h>
-#include <signal.h>
 #include <dirent.h>
 #include <math.h>
 #include <unistd.h>
 
 #include "access/sysattr.h"
-#include "catalog/pg_authid.h"
 #include "catalog/catalog.h"
 #include "catalog/pg_tablespace.h"
 #include "catalog/pg_type.h"
@@ -35,13 +33,9 @@
 #include "postmaster/syslogger.h"
 #include "rewrite/rewriteHandler.h"
 #include "storage/fd.h"
-#include "storage/pmsignal.h"
-#include "storage/proc.h"
-#include "storage/procarray.h"
 #include "utils/lsyscache.h"
 #include "utils/ruleutils.h"
 #include "tcop/tcopprot.h"
-#include "utils/acl.h"
 #include "utils/builtins.h"
 #include "utils/timestamp.h"
 
@@ -198,194 +192,6 @@ current_query(PG_FUNCTION_ARGS)
 		PG_RETURN_NULL();
 }
 
-/*
- * Send a signal to another backend.
- *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
- *
- * Returns 0 on success, 1 on general failure, 2 on normal permission error
- * and 3 if the caller needs to be a superuser.
- *
- * In the event of a general failure (return code 1), a warning message will
- * be emitted. For permission errors, doing that is the responsibility of
- * the caller.
- */
-#define SIGNAL_BACKEND_SUCCESS 0
-#define SIGNAL_BACKEND_ERROR 1
-#define SIGNAL_BACKEND_NOPERMISSION 2
-#define SIGNAL_BACKEND_NOSUPERUSER 3
-static int
-pg_signal_backend(int pid, int sig)
-{
-	PGPROC	   *proc = BackendPidGetProc(pid);
-
-	/*
-	 * BackendPidGetProc returns NULL if the pid isn't valid; but by the time
-	 * we reach kill(), a process for which we get a valid proc here might
-	 * have terminated on its own.  There's no way to acquire a lock on an
-	 * arbitrary process to prevent that. But since so far all the callers of
-	 * this mechanism involve some request for ending the process anyway, that
-	 * it might end on its own first is not a problem.
-	 */
-	if (proc == NULL)
-	{
-		/*
-		 * This is just a warning so a loop-through-resultset will not abort
-		 * if one backend terminated on its own during the run.
-		 */
-		ereport(WARNING,
-				(errmsg("PID %d is not a PostgreSQL server process", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-
-	/* Only allow superusers to signal superuser-owned backends. */
-	if (superuser_arg(proc->roleId) && !superuser())
-		return SIGNAL_BACKEND_NOSUPERUSER;
-
-	/* Users can signal backends they have role membership in. */
-	if (!has_privs_of_role(GetUserId(), proc->roleId) &&
-		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
-		return SIGNAL_BACKEND_NOPERMISSION;
-
-	/*
-	 * Can the process we just validated above end, followed by the pid being
-	 * recycled for a new process, before reaching here?  Then we'd be trying
-	 * to kill the wrong thing.  Seems near impossible when sequential pid
-	 * assignment and wraparound is used.  Perhaps it could happen on a system
-	 * where pid re-use is randomized.  That race condition possibility seems
-	 * too unlikely to worry about.
-	 */
-
-	/* If we have setsid(), signal the backend's whole process group */
-#ifdef HAVE_SETSID
-	if (kill(-pid, sig))
-#else
-	if (kill(pid, sig))
-#endif
-	{
-		/* Again, just a warning to allow loops */
-		ereport(WARNING,
-				(errmsg("could not send signal to process %d: %m", pid)));
-		return SIGNAL_BACKEND_ERROR;
-	}
-	return SIGNAL_BACKEND_SUCCESS;
-}
-
-/*
- * Signal to cancel a backend process.  This is allowed if you are a member of
- * the role whose process is being canceled.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_cancel_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to cancel superuser query"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose query is being canceled or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to terminate a backend process.  This is allowed if you are a member
- * of the role whose process is being terminated.
- *
- * Note that only superusers can signal superuser-owned processes.
- */
-Datum
-pg_terminate_backend(PG_FUNCTION_ARGS)
-{
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
-
-	if (r == SIGNAL_BACKEND_NOSUPERUSER)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a superuser to terminate superuser process"))));
-
-	if (r == SIGNAL_BACKEND_NOPERMISSION)
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
-
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
-}
-
-/*
- * Signal to reload the database configuration
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_reload_conf(PG_FUNCTION_ARGS)
-{
-	if (kill(PostmasterPid, SIGHUP))
-	{
-		ereport(WARNING,
-				(errmsg("failed to send signal to postmaster: %m")));
-		PG_RETURN_BOOL(false);
-	}
-
-	PG_RETURN_BOOL(true);
-}
-
-
-/*
- * Rotate log file
- *
- * This function is kept to support adminpack 1.0.
- */
-Datum
-pg_rotate_logfile(PG_FUNCTION_ARGS)
-{
-	if (!superuser())
-		ereport(ERROR,
-				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
-				 (errmsg("must be superuser to rotate log files with adminpack 1.0"),
-				  errhint("Consider using pg_logfile_rotate(), which is part of core, instead."))));
-
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
-/*
- * Rotate log file
- *
- * Permission checking for this function is managed through the normal
- * GRANT system.
- */
-Datum
-pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
-{
-	if (!Logging_collector)
-	{
-		ereport(WARNING,
-				(errmsg("rotation not possible because log collection not active")));
-		PG_RETURN_BOOL(false);
-	}
-
-	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
-	PG_RETURN_BOOL(true);
-}
-
 /* Function to find out which databases make use of a tablespace */
 
 typedef struct

From 7085f0d5948ce7d51b7fb9533f5383fdaeb715a6 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Fri, 5 Oct 2018 09:59:25 +0200
Subject: [PATCH] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend(), or
pg_cancel_backend(), to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
is overloading the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);

The backend API also expose functionality for altering the errcode
used when terminating or canceling the backend. This is however not
exposed in SQL in the above mentioned functions.

Also adds a new test suite for administrative functions.
---
 doc/src/sgml/func.sgml                    |  13 +-
 src/backend/catalog/system_views.sql      |   8 +
 src/backend/storage/ipc/ipci.c            |   3 +
 src/backend/storage/ipc/signalfuncs.c     | 320 +++++++++++++++++++++++++++++-
 src/backend/tcop/postgres.c               |  61 +++++-
 src/backend/utils/init/postinit.c         |   2 +
 src/include/catalog/pg_proc.dat           |   4 +-
 src/include/storage/signalfuncs.h         |  27 +++
 src/test/regress/expected/admin_funcs.out |  28 +++
 src/test/regress/parallel_schedule        |   2 +-
 src/test/regress/sql/admin_funcs.sql      |  11 +
 11 files changed, 461 insertions(+), 18 deletions(-)
 create mode 100644 src/include/storage/signalfuncs.h
 create mode 100644 src/test/regress/expected/admin_funcs.out
 create mode 100644 src/test/regress/sql/admin_funcs.sql

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index f984d069e1..5c1b302c78 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18756,7 +18756,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18781,7 +18781,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18812,6 +18812,15 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, it will
+    replace the default error message, which in turn will be the error
+    detail. <literal>message</literal> is limited to 128 ASCII characters, a
+    longer text will be truncated. An example where we cancel our own backend:
+<programlisting>
+postgres=# SELECT pg_cancel_backend(pg_backend_pid(), 'cancellation message text');
+ERROR:  cancellation message text
+DETAIL:  canceling statement due to user request by process 12345
+</programlisting>
    </para>
 
    <para>
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 020f28cbf6..145348e2ef 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -1027,6 +1027,14 @@ CREATE OR REPLACE FUNCTION pg_stop_backup (
   RETURNS SETOF record STRICT VOLATILE LANGUAGE internal as 'pg_stop_backup_v2'
   PARALLEL RESTRICTED;
 
+CREATE OR REPLACE FUNCTION
+  pg_cancel_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_cancel_backend' PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION
+  pg_terminate_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_terminate_backend' PARALLEL SAFE;
+
 -- legacy definition for compatibility with 9.3
 CREATE OR REPLACE FUNCTION
   json_populate_record(base anyelement, from_json json, use_json_as_text boolean DEFAULT false)
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 0c86a581c0..0486e08493 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -33,6 +33,7 @@
 #include "replication/walreceiver.h"
 #include "replication/walsender.h"
 #include "replication/origin.h"
+#include "storage/signalfuncs.h"
 #include "storage/bufmgr.h"
 #include "storage/dsm.h"
 #include "storage/ipc.h"
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, BackendSignalFeedbackShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendSignalFeedbackShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/storage/ipc/signalfuncs.c b/src/backend/storage/ipc/signalfuncs.c
index 878665b045..2dc1877ce3 100644
--- a/src/backend/storage/ipc/signalfuncs.c
+++ b/src/backend/storage/ipc/signalfuncs.c
@@ -17,21 +17,51 @@
 #include <signal.h>
 
 #include "catalog/pg_authid.h"
+#include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "postmaster/syslogger.h"
+#include "storage/ipc.h"
 #include "storage/pmsignal.h"
 #include "storage/proc.h"
 #include "storage/procarray.h"
+#include "storage/signalfuncs.h"
+#include "storage/spin.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
 
 
+/*
+ * Structure for registering a feedback payload to be sent to a cancelled, or
+ * terminated backend. Each backend is registered per pid in the array which is
+ * indexed by Backend ID. Reading and writing the message is protected by a
+ * per-slot spinlock.
+ */
+typedef struct
+{
+	pid_t	dest_pid;		/* The pid of the process being signalled */
+	pid_t	src_pid;		/* The pid of the processing signalling */
+	slock_t	mutex;			/* Per-slot protection */
+	char	message[MAX_CANCEL_MSG]; /* Message to send to signalled backend */
+	int		orig_length;	/* Length of the message as passed by the user,
+							 * if this length exceeds MAX_CANCEL_MSG it will
+							 * be truncated but we store the original length
+							 * in order to be able to convey truncation */
+	int		sqlerrcode;		/* errcode to use when signalling backend */
+} BackendSignalFeedbackShmemStruct;
+
+static BackendSignalFeedbackShmemStruct	*BackendSignalFeedbackSlots = NULL;
+static volatile BackendSignalFeedbackShmemStruct *MyCancelSlot = NULL;
+static void CleanupBackendSignalFeedback(int status, Datum argument);
+static int backend_feedback(pid_t backend_pid, char *message, int sqlerrcode);
+
 /*
  * Send a signal to another backend.
  *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
+ * The signal is delivered if the user is either a superuser or the same role
+ * as the backend being signaled. For "dangerous" signals, an explicit check
+ * for superuser needs to be done prior to calling this function. If msg is
+ * set, the contents will be passed as a message to the backend in the error
+ * message.
  *
  * Returns 0 on success, 1 on general failure, 2 on normal permission error
  * and 3 if the caller needs to be a superuser.
@@ -45,7 +75,7 @@
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -77,6 +107,30 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+	{
+		char *tmp = msg;
+
+		/*
+		 * The message to pass to the signalled backend is currently restricted
+		 * to ASCII only, since the sending backend might use an encoding which
+		 * is incompatible with the receiving with regards to conversion.
+		 */
+		while (*tmp != '\0')
+		{
+			if (!isascii(*tmp))
+				ereport(ERROR,
+						(errmsg("message is restricted to ASCII only")));
+			tmp++;
+		}
+
+		if (sig == SIGINT)
+			SetBackendCancelMessage(pid, msg);
+		else
+			SetBackendTerminationMessage(pid, msg);
+	}
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -110,7 +164,19 @@ pg_signal_backend(int pid, int sig)
 Datum
 pg_cancel_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -134,7 +200,19 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 Datum
 pg_terminate_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -146,7 +224,7 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
 }
 
 /*
@@ -213,3 +291,231 @@ pg_rotate_logfile_v2(PG_FUNCTION_ARGS)
 	SendPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE);
 	PG_RETURN_BOOL(true);
 }
+
+/*
+ * The following routines handle registering an optional message when
+ * cancelling, or terminating, a backend as well changing the sqlerrcode used.
+ * The combined payload of message/errcode is referred to as feedback.  The
+ * message will be stored in shared memory and is limited to MAX_CANCEL_MSG
+ * characters including the NULL terminator.
+ *
+ * Access to the feedback slots is protected by spinlocks.
+ */
+
+/*
+ * Return the required size for the cancelation feedback Shmem area.
+ */
+Size
+BackendSignalFeedbackShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendSignalFeedbackShmemStruct);
+}
+
+/*
+ * Create and initialize the Shmem structure for holding the feedback, the
+ * bookkeeping for them and the spinlocks associated.
+ */
+void
+BackendSignalFeedbackShmemInit(void)
+{
+	Size	size = BackendSignalFeedbackShmemSize();
+	bool	found;
+	int		i;
+
+	BackendSignalFeedbackSlots = (BackendSignalFeedbackShmemStruct *)
+		ShmemInitStruct("BackendSignalFeedbackSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendSignalFeedbackSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendSignalFeedbackSlots[i].mutex));
+	}
+}
+
+/*
+ * Set up the slot for the current backend_id
+ */
+void
+BackendSignalFeedbackInit(int backend_id)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->dest_pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupBackendSignalFeedback, Int32GetDatum(backend_id));
+}
+
+/*
+ * Ensure that the slot is purged and emptied at exit. Any message gets
+ * overwritten with null chars to avoid risking exposing a message intended for
+ * another backend to a new backend.
+ */
+static void
+CleanupBackendSignalFeedback(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->orig_length > 0)
+		MemSet(slot->message, '\0', sizeof(slot->message));
+
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->dest_pid = 0;
+	slot->src_pid = 0;
+}
+
+/*
+ * Set a message for the cancellation of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendCancelMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_QUERY_CANCELED);
+}
+
+/*
+ * Set a message for the termination of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendTerminationMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_ADMIN_SHUTDOWN);
+}
+
+/*
+ * Set both a message and a sqlerrcode for use when signalling the backend
+ * with the specified pid.
+ */
+int
+SetBackendSignalFeedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	return backend_feedback(backend_pid, message, sqlerrcode);
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns zero on success. If the backend isn't found, or no message is
+ * passed, 1 is returned.  If two backends collide in setting a message, the
+ * existing message will be overwritten by the last one in. The message will
+ * be truncated to fit within MAX_CANCEL_MSG bytes.
+ */
+static int
+backend_feedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	int		i;
+	int		len;
+
+	if (!message)
+		return 1;
+
+	len = pg_mbcliplen(message, strlen(message), MAX_CANCEL_MSG - 1);
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		BackendSignalFeedbackShmemStruct *slot = &BackendSignalFeedbackSlots[i];
+
+		if (slot->dest_pid != 0 && slot->dest_pid == backend_pid)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->dest_pid != backend_pid)
+			{
+				SpinLockRelease(&slot->mutex);
+				return 1;
+			}
+
+			/* Avoid risking to leak any part of a previously set message */
+			MemSet(slot->message, '\0', sizeof(slot->message));
+
+			memcpy(slot->message, message, len);
+			slot->orig_length = pg_mbstrlen(message);
+			slot->sqlerrcode = sqlerrcode;
+			slot->src_pid = MyProcPid;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+/*
+ * HasBackendSignalFeedback
+ *		Test if there is a backend signalling feedback to consume
+ *
+ * Test whether there is feedback registered for the current backend that can
+ * be consumed and presented to the user. It isn't strictly required to call
+ * this function prior to consuming a potential message, but since consuming it
+ * will clear it there can be cases where one would like to peek first.
+ */
+bool
+HasBackendSignalFeedback(void)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = ((slot->orig_length > 0) && (slot->sqlerrcode != 0));
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * ConsumeBackendSignalFeedback
+ *		Read anc clear backend signalling feedback
+ *
+ * Return the configured signal feedback in buffer, which is buf_len bytes in
+ * size.  The original length of the message is returned, or zero in case no
+ * message was found. If the returned length exceeds that of Min(buf_len,
+ * MAX_CANCEL_MSG), then truncation has been performed. The feedback (message
+ * and errcode) is cleared on consumption. There is no point in passing a
+ * buffer larger than MAX_CANCEL_NSG as that is the upper bound on what will be
+ * stored in the slot.
+ */
+int
+ConsumeBackendSignalFeedback(char *buffer, size_t buf_len, int *sqlerrcode,
+							 pid_t *pid)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->orig_length > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->orig_length;
+		*sqlerrcode = slot->sqlerrcode;
+		*pid = slot->src_pid;
+		slot->orig_length = 0;
+		slot->message[0] = '\0';
+		slot->sqlerrcode = 0;
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index e4c6e3d406..1db8ea1bda 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -62,6 +62,7 @@
 #include "replication/slot.h"
 #include "replication/walsender.h"
 #include "rewrite/rewriteHandler.h"
+#include "storage/signalfuncs.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
 #include "storage/proc.h"
@@ -2990,9 +2991,33 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_ADMIN_SHUTDOWN;
+					buffer[0] = '\0';
+				}
+				ereport(FATAL,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("terminating connection due to administrator command by process %d",
+								   pid)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3103,9 +3128,33 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_QUERY_CANCELED;
+					buffer[0] = '\0';
+				}
+
+				ereport(ERROR,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("canceling statement due to user request by process %d",
+								   pid)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 4f1d2a0d28..1c0a2eb1fe 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -40,6 +40,7 @@
 #include "postmaster/autovacuum.h"
 #include "postmaster/postmaster.h"
 #include "replication/walsender.h"
+#include "storage/signalfuncs.h"
 #include "storage/bufmgr.h"
 #include "storage/fd.h"
 #include "storage/ipc.h"
@@ -780,6 +781,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendSignalFeedbackInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 8579822bcd..b8926c19dc 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5972,10 +5972,10 @@
 
 { oid => '2171', descr => 'cancel a server process\' current query',
   proname => 'pg_cancel_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_cancel_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_cancel_backend' },
 { oid => '2096', descr => 'terminate a server process',
   proname => 'pg_terminate_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_terminate_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_terminate_backend' },
 { oid => '2172', descr => 'prepare for taking an online backup',
   proname => 'pg_start_backup', provolatile => 'v', proparallel => 'r',
   prorettype => 'pg_lsn', proargtypes => 'text bool bool',
diff --git a/src/include/storage/signalfuncs.h b/src/include/storage/signalfuncs.h
new file mode 100644
index 0000000000..73927cfa34
--- /dev/null
+++ b/src/include/storage/signalfuncs.h
@@ -0,0 +1,27 @@
+/*-------------------------------------------------------------------------
+ *
+ * signalfuncs.h
+ *		Declarations for backend signalling
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/signalfuncs.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef SIGNALFUNCS_H
+#define SIGNALFUNCS_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size BackendSignalFeedbackShmemSize(void);
+extern void BackendSignalFeedbackShmemInit(void);
+extern void BackendSignalFeedbackInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern int SetBackendTerminationMessage(pid_t backend, char *message);
+extern int SetBackendSignalFeedback(pid_t backend, char *message, int sqlerrcode);
+extern bool HasBackendSignalFeedback(void);
+extern int ConsumeBackendSignalFeedback(char *msg, size_t len, int *sqlerrcode, pid_t *pid);
+
+#endif /* SIGNALFUNCS_H */
diff --git a/src/test/regress/expected/admin_funcs.out b/src/test/regress/expected/admin_funcs.out
new file mode 100644
index 0000000000..84e1835fa6
--- /dev/null
+++ b/src/test/regress/expected/admin_funcs.out
@@ -0,0 +1,28 @@
+select pg_cancel_backend(NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select case
+	when pg_cancel_backend(pg_backend_pid())
+	then pg_sleep(60)
+end;
+ERROR:  canceling statement due to user request
+select pg_cancel_backend(NULL, NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(NULL, 'suicide is painless');
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select case
+	when pg_cancel_backend(pg_backend_pid(), NULL)
+	then pg_sleep(60)
+end;
+ERROR:  canceling statement due to user request
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 16f979c8d9..cdba9235b6 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -84,7 +84,7 @@ test: select_into select_distinct select_distinct_on select_implicit select_havi
 # ----------
 # Another group of parallel tests
 # ----------
-test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index
+test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index admin_funcs
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/admin_funcs.sql b/src/test/regress/sql/admin_funcs.sql
new file mode 100644
index 0000000000..73a4994535
--- /dev/null
+++ b/src/test/regress/sql/admin_funcs.sql
@@ -0,0 +1,11 @@
+select pg_cancel_backend(NULL);
+select case
+	when pg_cancel_backend(pg_backend_pid())
+	then pg_sleep(60)
+end;
+select pg_cancel_backend(NULL, NULL);
+select pg_cancel_backend(NULL, 'suicide is painless');
+select case
+	when pg_cancel_backend(pg_backend_pid(), NULL)
+	then pg_sleep(60)
+end;
-- 
2.14.1.145.gb3622a4ee

From 45102679e15becbf28186b1e59d79aab40b30ee7 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Fri, 5 Oct 2018 09:59:25 +0200
Subject: [PATCH] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend(), or
pg_cancel_backend(), to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
is overloading the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);

The backend API also expose functionality for altering the errcode
used when terminating or canceling the backend. This is however not
exposed in SQL in the above mentioned functions.

Also adds a new test suite for administrative functions.
---
 doc/src/sgml/func.sgml                    |  13 +-
 src/backend/catalog/system_views.sql      |   8 +
 src/backend/storage/ipc/Makefile          |   2 +-
 src/backend/storage/ipc/ipci.c            |   3 +
 src/backend/storage/ipc/signal_message.c  | 272 ++++++++++++++++++++++++++++++
 src/backend/storage/ipc/signalfuncs.c     |  66 +++++++-
 src/backend/tcop/postgres.c               |  61 ++++++-
 src/backend/utils/init/postinit.c         |   2 +
 src/include/catalog/pg_proc.dat           |   4 +-
 src/include/storage/signal_message.h      |  27 +++
 src/test/regress/expected/admin_funcs.out |  28 +++
 src/test/regress/parallel_schedule        |   2 +-
 src/test/regress/sql/admin_funcs.sql      |  11 ++
 13 files changed, 480 insertions(+), 19 deletions(-)
 create mode 100644 src/backend/storage/ipc/signal_message.c
 create mode 100644 src/include/storage/signal_message.h
 create mode 100644 src/test/regress/expected/admin_funcs.out
 create mode 100644 src/test/regress/sql/admin_funcs.sql

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 5193df3366..b0b85289d6 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18756,7 +18756,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18781,7 +18781,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18812,6 +18812,15 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, it will
+    replace the default error message, which in turn will be the error
+    detail. <literal>message</literal> is limited to 128 ASCII characters, a
+    longer text will be truncated. An example where we cancel our own backend:
+<programlisting>
+postgres=# SELECT pg_cancel_backend(pg_backend_pid(), 'cancellation message text');
+ERROR:  cancellation message text
+DETAIL:  canceling statement due to user request by process 12345
+</programlisting>
    </para>
 
    <para>
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 0c1bcebb0d..44a5fc4afd 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -1027,6 +1027,14 @@ CREATE OR REPLACE FUNCTION pg_stop_backup (
   RETURNS SETOF record STRICT VOLATILE LANGUAGE internal as 'pg_stop_backup_v2'
   PARALLEL RESTRICTED;
 
+CREATE OR REPLACE FUNCTION
+  pg_cancel_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_cancel_backend' PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION
+  pg_terminate_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_terminate_backend' PARALLEL SAFE;
+
 -- legacy definition for compatibility with 9.3
 CREATE OR REPLACE FUNCTION
   json_populate_record(base anyelement, from_json json, use_json_as_text boolean DEFAULT false)
diff --git a/src/backend/storage/ipc/Makefile b/src/backend/storage/ipc/Makefile
index 49e7c9f15e..fd628af59f 100644
--- a/src/backend/storage/ipc/Makefile
+++ b/src/backend/storage/ipc/Makefile
@@ -10,6 +10,6 @@ include $(top_builddir)/src/Makefile.global
 
 OBJS = barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o pmsignal.o procarray.o \
 	procsignal.o shmem.o shmqueue.o shm_mq.o shm_toc.o signalfuncs.o \
-	sinval.o sinvaladt.o standby.o
+	signal_message.o sinval.o sinvaladt.o standby.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 0c86a581c0..fb7c1a0b49 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -33,6 +33,7 @@
 #include "replication/walreceiver.h"
 #include "replication/walsender.h"
 #include "replication/origin.h"
+#include "storage/signal_message.h"
 #include "storage/bufmgr.h"
 #include "storage/dsm.h"
 #include "storage/ipc.h"
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, BackendSignalFeedbackShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendSignalFeedbackShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/storage/ipc/signal_message.c b/src/backend/storage/ipc/signal_message.c
new file mode 100644
index 0000000000..01f8ebcb17
--- /dev/null
+++ b/src/backend/storage/ipc/signal_message.c
@@ -0,0 +1,272 @@
+/*-------------------------------------------------------------------------
+ *
+ * signal_message.c
+ *	  Functions for sending a message to a signalled backend
+ *
+ * This file contains routines to handle registering an optional message when
+ * cancelling, or terminating, a backend as well changing the sqlerrcode used.
+ * The combined payload of message/errcode is referred to as feedback.  The
+ * message will be stored in shared memory and is limited to MAX_CANCEL_MSG
+ * characters including the NULL terminator.
+ *
+ * Access to the feedback slots is protected by spinlocks.
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/ipc/signal_message.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "mb/pg_wchar.h"
+#include "miscadmin.h"
+#include "storage/ipc.h"
+#include "storage/shmem.h"
+#include "storage/signal_message.h"
+#include "storage/spin.h"
+
+
+/*
+ * Structure for registering a feedback payload to be sent to a cancelled, or
+ * terminated backend. Each backend is registered per pid in the array which is
+ * indexed by Backend ID. Reading and writing the message is protected by a
+ * per-slot spinlock.
+ */
+typedef struct
+{
+	pid_t	dest_pid;		/* The pid of the process being signalled */
+	pid_t	src_pid;		/* The pid of the processing signalling */
+	slock_t	mutex;			/* Per-slot protection */
+	char	message[MAX_CANCEL_MSG]; /* Message to send to signalled backend */
+	int		orig_length;	/* Length of the message as passed by the user,
+							 * if this length exceeds MAX_CANCEL_MSG it will
+							 * be truncated but we store the original length
+							 * in order to be able to convey truncation */
+	int		sqlerrcode;		/* errcode to use when signalling backend */
+} BackendSignalFeedbackShmemStruct;
+
+static BackendSignalFeedbackShmemStruct	*BackendSignalFeedbackSlots = NULL;
+static volatile BackendSignalFeedbackShmemStruct *MyCancelSlot = NULL;
+static void CleanupBackendSignalFeedback(int status, Datum argument);
+static int backend_feedback(pid_t backend_pid, char *message, int sqlerrcode);
+
+/*
+ * Return the required size for the cancelation feedback Shmem area.
+ */
+Size
+BackendSignalFeedbackShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendSignalFeedbackShmemStruct);
+}
+
+/*
+ * Create and initialize the Shmem structure for holding the feedback, the
+ * bookkeeping for them and the spinlocks associated.
+ */
+void
+BackendSignalFeedbackShmemInit(void)
+{
+	Size	size = BackendSignalFeedbackShmemSize();
+	bool	found;
+	int		i;
+
+	BackendSignalFeedbackSlots = (BackendSignalFeedbackShmemStruct *)
+		ShmemInitStruct("BackendSignalFeedbackSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendSignalFeedbackSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendSignalFeedbackSlots[i].mutex));
+	}
+}
+
+/*
+ * Set up the slot for the current backend_id
+ */
+void
+BackendSignalFeedbackInit(int backend_id)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->dest_pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupBackendSignalFeedback, Int32GetDatum(backend_id));
+}
+
+/*
+ * Ensure that the slot is purged and emptied at exit. Any message gets
+ * overwritten with null chars to avoid risking exposing a message intended for
+ * another backend to a new backend.
+ */
+static void
+CleanupBackendSignalFeedback(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->orig_length > 0)
+		MemSet(slot->message, '\0', sizeof(slot->message));
+
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->dest_pid = 0;
+	slot->src_pid = 0;
+}
+
+/*
+ * Set a message for the cancellation of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendCancelMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_QUERY_CANCELED);
+}
+
+/*
+ * Set a message for the termination of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendTerminationMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_ADMIN_SHUTDOWN);
+}
+
+/*
+ * Set both a message and a sqlerrcode for use when signalling the backend
+ * with the specified pid.
+ */
+int
+SetBackendSignalFeedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	return backend_feedback(backend_pid, message, sqlerrcode);
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns zero on success. If the backend isn't found, or no message is
+ * passed, 1 is returned.  If two backends collide in setting a message, the
+ * existing message will be overwritten by the last one in. The message will
+ * be truncated to fit within MAX_CANCEL_MSG bytes.
+ */
+static int
+backend_feedback(pid_t backend_pid, char *message, int sqlerrcode)
+{
+	int		i;
+	int		len;
+
+	if (!message)
+		return 1;
+
+	len = pg_mbcliplen(message, strlen(message), MAX_CANCEL_MSG - 1);
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		BackendSignalFeedbackShmemStruct *slot = &BackendSignalFeedbackSlots[i];
+
+		if (slot->dest_pid != 0 && slot->dest_pid == backend_pid)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->dest_pid != backend_pid)
+			{
+				SpinLockRelease(&slot->mutex);
+				return 1;
+			}
+
+			memcpy(slot->message, message, len);
+			slot->orig_length = pg_mbstrlen(message);
+			slot->sqlerrcode = sqlerrcode;
+			slot->src_pid = MyProcPid;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+/*
+ * HasBackendSignalFeedback
+ *		Test if there is a backend signalling feedback to consume
+ *
+ * Test whether there is feedback registered for the current backend that can
+ * be consumed and presented to the user. It isn't strictly required to call
+ * this function prior to consuming a potential message, but since consuming it
+ * will clear it there can be cases where one would like to peek first.
+ */
+bool
+HasBackendSignalFeedback(void)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = ((slot->orig_length > 0) && (slot->sqlerrcode != 0));
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * ConsumeBackendSignalFeedback
+ *		Read and clear backend signalling feedback
+ *
+ * Return the configured signal feedback in buffer, which is buf_len bytes in
+ * size.  The original length of the message is returned, or zero in case no
+ * message was found. If the returned length exceeds that of Min(buf_len,
+ * MAX_CANCEL_MSG), then truncation has been performed. The feedback (message
+ * and errcode) is cleared on consumption. There is no point in passing a
+ * buffer larger than MAX_CANCEL_NSG as that is the upper bound on what will be
+ * stored in the slot.
+ */
+int
+ConsumeBackendSignalFeedback(char *buffer, size_t buf_len, int *sqlerrcode,
+							 pid_t *pid)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->orig_length > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		strlcpy(buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->orig_length;
+		*sqlerrcode = slot->sqlerrcode;
+		*pid = slot->src_pid;
+
+		slot->orig_length = 0;
+		/* Avoid risking to leak any part of a previously set message */
+		MemSet(slot->message, '\0', sizeof(slot->message));
+		slot->sqlerrcode = 0;
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/backend/storage/ipc/signalfuncs.c b/src/backend/storage/ipc/signalfuncs.c
index 878665b045..f0c02c7008 100644
--- a/src/backend/storage/ipc/signalfuncs.c
+++ b/src/backend/storage/ipc/signalfuncs.c
@@ -19,9 +19,11 @@
 #include "catalog/pg_authid.h"
 #include "miscadmin.h"
 #include "postmaster/syslogger.h"
+#include "storage/ipc.h"
 #include "storage/pmsignal.h"
 #include "storage/proc.h"
 #include "storage/procarray.h"
+#include "storage/signal_message.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
 
@@ -29,9 +31,11 @@
 /*
  * Send a signal to another backend.
  *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
+ * The signal is delivered if the user is either a superuser or the same role
+ * as the backend being signaled. For "dangerous" signals, an explicit check
+ * for superuser needs to be done prior to calling this function. If msg is
+ * set, the contents will be passed as a message to the backend in the error
+ * message.
  *
  * Returns 0 on success, 1 on general failure, 2 on normal permission error
  * and 3 if the caller needs to be a superuser.
@@ -45,7 +49,7 @@
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -77,6 +81,30 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+	{
+		char *tmp = msg;
+
+		/*
+		 * The message to pass to the signalled backend is currently restricted
+		 * to ASCII only, since the sending backend might use an encoding which
+		 * is incompatible with the receiving with regards to conversion.
+		 */
+		while (*tmp != '\0')
+		{
+			if (!isascii(*tmp))
+				ereport(ERROR,
+						(errmsg("message is restricted to ASCII only")));
+			tmp++;
+		}
+
+		if (sig == SIGINT)
+			SetBackendCancelMessage(pid, msg);
+		else
+			SetBackendTerminationMessage(pid, msg);
+	}
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -110,7 +138,19 @@ pg_signal_backend(int pid, int sig)
 Datum
 pg_cancel_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -134,7 +174,19 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 Datum
 pg_terminate_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -146,7 +198,7 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
 }
 
 /*
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index e4c6e3d406..fad63f024a 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -62,6 +62,7 @@
 #include "replication/slot.h"
 #include "replication/walsender.h"
 #include "rewrite/rewriteHandler.h"
+#include "storage/signal_message.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
 #include "storage/proc.h"
@@ -2990,9 +2991,33 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_ADMIN_SHUTDOWN;
+					buffer[0] = '\0';
+				}
+				ereport(FATAL,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("terminating connection due to administrator command by process %d",
+								   pid)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3103,9 +3128,33 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_QUERY_CANCELED;
+					buffer[0] = '\0';
+				}
+
+				ereport(ERROR,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("canceling statement due to user request by process %d",
+								   pid)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 4f1d2a0d28..4382691420 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -40,6 +40,7 @@
 #include "postmaster/autovacuum.h"
 #include "postmaster/postmaster.h"
 #include "replication/walsender.h"
+#include "storage/signal_message.h"
 #include "storage/bufmgr.h"
 #include "storage/fd.h"
 #include "storage/ipc.h"
@@ -780,6 +781,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendSignalFeedbackInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 038a11d6cd..587fbd8529 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5973,10 +5973,10 @@
 
 { oid => '2171', descr => 'cancel a server process\' current query',
   proname => 'pg_cancel_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_cancel_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_cancel_backend' },
 { oid => '2096', descr => 'terminate a server process',
   proname => 'pg_terminate_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_terminate_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_terminate_backend' },
 { oid => '2172', descr => 'prepare for taking an online backup',
   proname => 'pg_start_backup', provolatile => 'v', proparallel => 'r',
   prorettype => 'pg_lsn', proargtypes => 'text bool bool',
diff --git a/src/include/storage/signal_message.h b/src/include/storage/signal_message.h
new file mode 100644
index 0000000000..11ca34d24b
--- /dev/null
+++ b/src/include/storage/signal_message.h
@@ -0,0 +1,27 @@
+/*-------------------------------------------------------------------------
+ *
+ * signal_message.h
+ *		Declarations for sending a message to a signalled backend
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/signal_message.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef SIGNAL_MESSAGE_H
+#define SIGNAL_MESSAGE_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size BackendSignalFeedbackShmemSize(void);
+extern void BackendSignalFeedbackShmemInit(void);
+extern void BackendSignalFeedbackInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern int SetBackendTerminationMessage(pid_t backend, char *message);
+extern int SetBackendSignalFeedback(pid_t backend, char *message, int sqlerrcode);
+extern bool HasBackendSignalFeedback(void);
+extern int ConsumeBackendSignalFeedback(char *msg, size_t len, int *sqlerrcode, pid_t *pid);
+
+#endif /* SIGNAL_MESSAGE_H */
diff --git a/src/test/regress/expected/admin_funcs.out b/src/test/regress/expected/admin_funcs.out
new file mode 100644
index 0000000000..84e1835fa6
--- /dev/null
+++ b/src/test/regress/expected/admin_funcs.out
@@ -0,0 +1,28 @@
+select pg_cancel_backend(NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select case
+	when pg_cancel_backend(pg_backend_pid())
+	then pg_sleep(60)
+end;
+ERROR:  canceling statement due to user request
+select pg_cancel_backend(NULL, NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(NULL, 'suicide is painless');
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select case
+	when pg_cancel_backend(pg_backend_pid(), NULL)
+	then pg_sleep(60)
+end;
+ERROR:  canceling statement due to user request
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index 16f979c8d9..cdba9235b6 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -84,7 +84,7 @@ test: select_into select_distinct select_distinct_on select_implicit select_havi
 # ----------
 # Another group of parallel tests
 # ----------
-test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index
+test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index admin_funcs
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/admin_funcs.sql b/src/test/regress/sql/admin_funcs.sql
new file mode 100644
index 0000000000..73a4994535
--- /dev/null
+++ b/src/test/regress/sql/admin_funcs.sql
@@ -0,0 +1,11 @@
+select pg_cancel_backend(NULL);
+select case
+	when pg_cancel_backend(pg_backend_pid())
+	then pg_sleep(60)
+end;
+select pg_cancel_backend(NULL, NULL);
+select pg_cancel_backend(NULL, 'suicide is painless');
+select case
+	when pg_cancel_backend(pg_backend_pid(), NULL)
+	then pg_sleep(60)
+end;
-- 
2.14.1.145.gb3622a4ee

From 70065fb5caeba8592f5de711b4155abbc86f2ed8 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Wed, 31 Oct 2018 00:19:10 +0100
Subject: [PATCH 2/2] Allow pg_{cancel|terminate}_backend to pass message

This adds an optional message parameter to pg_cancel_backend() and
pg_terminate_backend(), whereby the administrator can inform the
user why the query was cancelled or connection terminated. A small
testcase is added to excercise the new codepath.
---
 doc/src/sgml/func.sgml                    | 13 +++++-
 src/backend/catalog/system_views.sql      |  8 ++++
 src/backend/storage/ipc/signalfuncs.c     | 66 +++++++++++++++++++++++++++----
 src/backend/tcop/postgres.c               | 61 +++++++++++++++++++++++++---
 src/include/catalog/pg_proc.dat           |  4 +-
 src/test/regress/expected/admin_funcs.out | 28 +++++++++++++
 src/test/regress/parallel_schedule        |  2 +-
 src/test/regress/sql/admin_funcs.sql      | 11 ++++++
 8 files changed, 175 insertions(+), 18 deletions(-)
 create mode 100644 src/test/regress/expected/admin_funcs.out
 create mode 100644 src/test/regress/sql/admin_funcs.sql

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 10816f556b..e334e77ae7 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18756,7 +18756,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18781,7 +18781,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18812,6 +18812,15 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, it will
+    replace the default error message, which in turn will be the error
+    detail. <literal>message</literal> is limited to 128 ASCII characters, a
+    longer text will be truncated. An example where we cancel our own backend:
+<programlisting>
+postgres=# SELECT pg_cancel_backend(pg_backend_pid(), 'cancellation message text');
+ERROR:  cancellation message text
+DETAIL:  canceling statement due to user request by process 12345
+</programlisting>
    </para>
 
    <para>
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 53ddc593a8..d164535beb 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -1032,6 +1032,14 @@ CREATE OR REPLACE FUNCTION
   RETURNS boolean STRICT VOLATILE LANGUAGE INTERNAL AS 'pg_promote'
   PARALLEL RESTRICTED;
 
+CREATE OR REPLACE FUNCTION
+  pg_cancel_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_cancel_backend' PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION
+  pg_terminate_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_terminate_backend' PARALLEL SAFE;
+
 -- legacy definition for compatibility with 9.3
 CREATE OR REPLACE FUNCTION
   json_populate_record(base anyelement, from_json json, use_json_as_text boolean DEFAULT false)
diff --git a/src/backend/storage/ipc/signalfuncs.c b/src/backend/storage/ipc/signalfuncs.c
index 878665b045..f0c02c7008 100644
--- a/src/backend/storage/ipc/signalfuncs.c
+++ b/src/backend/storage/ipc/signalfuncs.c
@@ -19,9 +19,11 @@
 #include "catalog/pg_authid.h"
 #include "miscadmin.h"
 #include "postmaster/syslogger.h"
+#include "storage/ipc.h"
 #include "storage/pmsignal.h"
 #include "storage/proc.h"
 #include "storage/procarray.h"
+#include "storage/signal_message.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
 
@@ -29,9 +31,11 @@
 /*
  * Send a signal to another backend.
  *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
+ * The signal is delivered if the user is either a superuser or the same role
+ * as the backend being signaled. For "dangerous" signals, an explicit check
+ * for superuser needs to be done prior to calling this function. If msg is
+ * set, the contents will be passed as a message to the backend in the error
+ * message.
  *
  * Returns 0 on success, 1 on general failure, 2 on normal permission error
  * and 3 if the caller needs to be a superuser.
@@ -45,7 +49,7 @@
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -77,6 +81,30 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+	{
+		char *tmp = msg;
+
+		/*
+		 * The message to pass to the signalled backend is currently restricted
+		 * to ASCII only, since the sending backend might use an encoding which
+		 * is incompatible with the receiving with regards to conversion.
+		 */
+		while (*tmp != '\0')
+		{
+			if (!isascii(*tmp))
+				ereport(ERROR,
+						(errmsg("message is restricted to ASCII only")));
+			tmp++;
+		}
+
+		if (sig == SIGINT)
+			SetBackendCancelMessage(pid, msg);
+		else
+			SetBackendTerminationMessage(pid, msg);
+	}
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -110,7 +138,19 @@ pg_signal_backend(int pid, int sig)
 Datum
 pg_cancel_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -134,7 +174,19 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 Datum
 pg_terminate_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -146,7 +198,7 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
 }
 
 /*
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index a3b9757565..50c56e0618 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -62,6 +62,7 @@
 #include "replication/slot.h"
 #include "replication/walsender.h"
 #include "rewrite/rewriteHandler.h"
+#include "storage/signal_message.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
 #include "storage/proc.h"
@@ -3013,9 +3014,33 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid, NULL);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_ADMIN_SHUTDOWN;
+					buffer[0] = '\0';
+				}
+				ereport(FATAL,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("terminating connection due to administrator command by process %d",
+								   pid)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3126,9 +3151,33 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid, NULL);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_QUERY_CANCELED;
+					buffer[0] = '\0';
+				}
+
+				ereport(ERROR,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("canceling statement due to user request by process %d",
+								   pid)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 4026018ba9..11b8830217 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5799,10 +5799,10 @@
 
 { oid => '2171', descr => 'cancel a server process\' current query',
   proname => 'pg_cancel_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_cancel_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_cancel_backend' },
 { oid => '2096', descr => 'terminate a server process',
   proname => 'pg_terminate_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_terminate_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_terminate_backend' },
 { oid => '2172', descr => 'prepare for taking an online backup',
   proname => 'pg_start_backup', provolatile => 'v', proparallel => 'r',
   prorettype => 'pg_lsn', proargtypes => 'text bool bool',
diff --git a/src/test/regress/expected/admin_funcs.out b/src/test/regress/expected/admin_funcs.out
new file mode 100644
index 0000000000..84e1835fa6
--- /dev/null
+++ b/src/test/regress/expected/admin_funcs.out
@@ -0,0 +1,28 @@
+select pg_cancel_backend(NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select case
+	when pg_cancel_backend(pg_backend_pid())
+	then pg_sleep(60)
+end;
+ERROR:  canceling statement due to user request
+select pg_cancel_backend(NULL, NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(NULL, 'suicide is painless');
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select case
+	when pg_cancel_backend(pg_backend_pid(), NULL)
+	then pg_sleep(60)
+end;
+ERROR:  canceling statement due to user request
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index b5e15501dd..5034cc8c20 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -84,7 +84,7 @@ test: select_into select_distinct select_distinct_on select_implicit select_havi
 # ----------
 # Another group of parallel tests
 # ----------
-test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index
+test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index admin_funcs
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/admin_funcs.sql b/src/test/regress/sql/admin_funcs.sql
new file mode 100644
index 0000000000..73a4994535
--- /dev/null
+++ b/src/test/regress/sql/admin_funcs.sql
@@ -0,0 +1,11 @@
+select pg_cancel_backend(NULL);
+select case
+	when pg_cancel_backend(pg_backend_pid())
+	then pg_sleep(60)
+end;
+select pg_cancel_backend(NULL, NULL);
+select pg_cancel_backend(NULL, 'suicide is painless');
+select case
+	when pg_cancel_backend(pg_backend_pid(), NULL)
+	then pg_sleep(60)
+end;
-- 
2.14.1.145.gb3622a4ee

From 119d7ed341477b1c5f644ae289bf8cb01ad5bc5a Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Wed, 31 Oct 2018 00:12:39 +0100
Subject: [PATCH 1/2] Add infrastructure for signalling backends with payload

This adds an API to include a payload consisting of a message, an
elevel and a custom sqlerrcode, when signalling a backend. The main
usecase is to be able to include context to the user as to why the
connection is terminated or query cancelled.
---
 src/backend/storage/ipc/Makefile         |   2 +-
 src/backend/storage/ipc/ipci.c           |   3 +
 src/backend/storage/ipc/signal_message.c | 286 +++++++++++++++++++++++++++++++
 src/backend/utils/init/postinit.c        |   2 +
 src/include/storage/signal_message.h     |  29 ++++
 5 files changed, 321 insertions(+), 1 deletion(-)
 create mode 100644 src/backend/storage/ipc/signal_message.c
 create mode 100644 src/include/storage/signal_message.h

diff --git a/src/backend/storage/ipc/Makefile b/src/backend/storage/ipc/Makefile
index 49e7c9f15e..fd628af59f 100644
--- a/src/backend/storage/ipc/Makefile
+++ b/src/backend/storage/ipc/Makefile
@@ -10,6 +10,6 @@ include $(top_builddir)/src/Makefile.global
 
 OBJS = barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o pmsignal.o procarray.o \
 	procsignal.o shmem.o shmqueue.o shm_mq.o shm_toc.o signalfuncs.o \
-	sinval.o sinvaladt.o standby.o
+	signal_message.o sinval.o sinvaladt.o standby.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 0c86a581c0..fb7c1a0b49 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -33,6 +33,7 @@
 #include "replication/walreceiver.h"
 #include "replication/walsender.h"
 #include "replication/origin.h"
+#include "storage/signal_message.h"
 #include "storage/bufmgr.h"
 #include "storage/dsm.h"
 #include "storage/ipc.h"
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, BackendSignalFeedbackShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendSignalFeedbackShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/storage/ipc/signal_message.c b/src/backend/storage/ipc/signal_message.c
new file mode 100644
index 0000000000..596f9584cc
--- /dev/null
+++ b/src/backend/storage/ipc/signal_message.c
@@ -0,0 +1,286 @@
+/*-------------------------------------------------------------------------
+ *
+ * signal_message.c
+ *	  Functions for sending a message to a signalled backend
+ *
+ * This file contains routines to handle registering an optional message when
+ * cancelling, or terminating, a backend as well changing the sqlerrcode used.
+ * The combined payload of message/errcode is referred to as feedback.  The
+ * message will be stored in shared memory and is limited to MAX_CANCEL_MSG
+ * characters including the NULL terminator.
+ *
+ * Access to the feedback slots is protected by spinlocks.
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/ipc/signal_message.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "mb/pg_wchar.h"
+#include "miscadmin.h"
+#include "storage/ipc.h"
+#include "storage/shmem.h"
+#include "storage/signal_message.h"
+#include "storage/spin.h"
+
+
+/*
+ * Structure for registering a feedback payload to be sent to a cancelled, or
+ * terminated backend. Each backend is registered per pid in the array which is
+ * indexed by Backend ID. Reading and writing the message is protected by a
+ * per-slot spinlock.
+ */
+typedef struct
+{
+	pid_t	dest_pid;		/* The pid of the process being signalled */
+	pid_t	src_pid;		/* The pid of the processing signalling */
+	slock_t	mutex;			/* Per-slot protection */
+	char	message[MAX_CANCEL_MSG]; /* Message to send to signalled backend */
+	int		orig_length;	/* Length of the message as passed by the user,
+							 * if this length exceeds MAX_CANCEL_MSG it will
+							 * be truncated but we store the original length
+							 * in order to be able to convey truncation */
+	int		sqlerrcode;		/* errcode to use when signalling backend */
+	int		elevel;			/* elevel to use when signalling backend */
+} BackendSignalFeedbackShmemStruct;
+
+static BackendSignalFeedbackShmemStruct	*BackendSignalFeedbackSlots = NULL;
+static volatile BackendSignalFeedbackShmemStruct *MyCancelSlot = NULL;
+static void CleanupBackendSignalFeedback(int status, Datum argument);
+static int backend_feedback(pid_t backend_pid, char *message, int sqlerrcode,
+							int elevel);
+
+/*
+ * Return the required size for the cancelation feedback Shmem area.
+ */
+Size
+BackendSignalFeedbackShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendSignalFeedbackShmemStruct);
+}
+
+/*
+ * Create and initialize the Shmem structure for holding the feedback, the
+ * bookkeeping for them and the spinlocks associated.
+ */
+void
+BackendSignalFeedbackShmemInit(void)
+{
+	Size	size = BackendSignalFeedbackShmemSize();
+	bool	found;
+	int		i;
+
+	BackendSignalFeedbackSlots = (BackendSignalFeedbackShmemStruct *)
+		ShmemInitStruct("BackendSignalFeedbackSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendSignalFeedbackSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendSignalFeedbackSlots[i].mutex));
+	}
+}
+
+/*
+ * Set up the slot for the current backend_id
+ */
+void
+BackendSignalFeedbackInit(int backend_id)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->elevel = 0;
+	slot->dest_pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupBackendSignalFeedback, Int32GetDatum(backend_id));
+}
+
+/*
+ * Ensure that the slot is purged and emptied at exit. Any message gets
+ * overwritten with null chars to avoid risking exposing a message intended for
+ * another backend to a new backend.
+ */
+static void
+CleanupBackendSignalFeedback(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->orig_length > 0)
+		MemSet(slot->message, '\0', sizeof(slot->message));
+
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->elevel = 0;
+	slot->dest_pid = 0;
+	slot->src_pid = 0;
+}
+
+/*
+ * Set a message for the cancellation of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendCancelMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_QUERY_CANCELED,
+							ERROR);
+}
+
+/*
+ * Set a message for the termination of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendTerminationMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_ADMIN_SHUTDOWN,
+							FATAL);
+}
+
+/*
+ * Set both a message, elevel and a sqlerrcode for use when signalling the
+ * backend with the specified pid.
+ */
+int
+SetBackendSignalFeedback(pid_t backend_pid, char *message, int sqlerrcode,
+						 int elevel)
+{
+	return backend_feedback(backend_pid, message, sqlerrcode, elevel);
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns zero on success. If the backend isn't found, or no message is
+ * passed, 1 is returned.  If two backends collide in setting a message, the
+ * existing message will be overwritten by the last one in. The message will
+ * be truncated to fit within MAX_CANCEL_MSG bytes.
+ */
+static int
+backend_feedback(pid_t backend_pid, char *message, int sqlerrcode, int elevel)
+{
+	int		i;
+	int		len;
+
+	if (!message)
+		return 1;
+
+	len = pg_mbcliplen(message, strlen(message), MAX_CANCEL_MSG - 1);
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		BackendSignalFeedbackShmemStruct *slot = &BackendSignalFeedbackSlots[i];
+
+		if (slot->dest_pid != 0 && slot->dest_pid == backend_pid)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->dest_pid != backend_pid)
+			{
+				SpinLockRelease(&slot->mutex);
+				return 1;
+			}
+
+			memcpy(slot->message, message, len);
+			slot->orig_length = pg_mbstrlen(message);
+			slot->sqlerrcode = sqlerrcode;
+			slot->elevel = elevel;
+			slot->src_pid = MyProcPid;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+/*
+ * HasBackendSignalFeedback
+ *		Test if there is a backend signalling feedback to consume
+ *
+ * Test whether there is feedback registered for the current backend that can
+ * be consumed and presented to the user. It isn't strictly required to call
+ * this function prior to consuming a potential message, but since consuming it
+ * will clear it there can be cases where one would like to peek first.
+ */
+bool
+HasBackendSignalFeedback(void)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = ((slot->orig_length > 0) && (slot->sqlerrcode != 0));
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * ConsumeBackendSignalFeedback
+ *		Read and clear backend signalling feedback
+ *
+ * Return the configured signal feedback in buffer, which is buf_len bytes in
+ * size.  The original length of the message is returned, or zero in case no
+ * message was found. If the returned length exceeds that of Min(buf_len,
+ * MAX_CANCEL_MSG), then truncation has been performed. The feedback (message
+ * and errcode) is cleared on consumption. There is no point in passing a
+ * buffer larger than MAX_CANCEL_MSG as that is the upper bound on what will be
+ * stored in the slot.
+ */
+int
+ConsumeBackendSignalFeedback(char *buffer, size_t buf_len, int *sqlerrcode,
+							 pid_t *pid, int *elevel)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->orig_length > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		if (buffer && buf_len)
+			strlcpy(buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->orig_length;
+		if (sqlerrcode)
+			*sqlerrcode = slot->sqlerrcode;
+		if (pid)
+			*pid = slot->src_pid;
+		if (elevel)
+			*elevel = slot->elevel;
+
+		slot->orig_length = 0;
+		/* Avoid risking to leak any part of a previously set message */
+		MemSet(slot->message, '\0', sizeof(slot->message));
+		slot->sqlerrcode = 0;
+		slot->elevel = 0;
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 4f1d2a0d28..4382691420 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -40,6 +40,7 @@
 #include "postmaster/autovacuum.h"
 #include "postmaster/postmaster.h"
 #include "replication/walsender.h"
+#include "storage/signal_message.h"
 #include "storage/bufmgr.h"
 #include "storage/fd.h"
 #include "storage/ipc.h"
@@ -780,6 +781,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendSignalFeedbackInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/include/storage/signal_message.h b/src/include/storage/signal_message.h
new file mode 100644
index 0000000000..e0f834f2f5
--- /dev/null
+++ b/src/include/storage/signal_message.h
@@ -0,0 +1,29 @@
+/*-------------------------------------------------------------------------
+ *
+ * signal_message.h
+ *		Declarations for sending a message to a signalled backend
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/signal_message.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef SIGNAL_MESSAGE_H
+#define SIGNAL_MESSAGE_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size BackendSignalFeedbackShmemSize(void);
+extern void BackendSignalFeedbackShmemInit(void);
+extern void BackendSignalFeedbackInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern int SetBackendTerminationMessage(pid_t backend, char *message);
+extern int SetBackendSignalFeedback(pid_t backend, char *message,
+									int sqlerrcode, int elevel);
+extern bool HasBackendSignalFeedback(void);
+extern int ConsumeBackendSignalFeedback(char *msg, size_t len, int *sqlerrcode,
+										pid_t *pid, int *elevel);
+
+#endif							/* SIGNAL_MESSAGE_H */
-- 
2.14.1.145.gb3622a4ee

From 9af3133898984acee754f71537f8a59e0addc253 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <daniel@yesql.se>
Date: Fri, 5 Oct 2018 09:59:25 +0200
Subject: [PATCH] Support optional message in backend cancel/terminate

This adds the ability for the caller of pg_terminate_backend(), or
pg_cancel_backend(), to include an optional message to the process
which is being signalled. The message will be appended to the error
message returned to the killed or cancelled process. The new syntax
is overloading the existing as:

    SELECT pg_terminate_backend(<pid> [, msg]);
    SELECT pg_cancel_backend(<pid> [, msg]);

The backend API also expose functionality for altering the errcode
used when terminating or canceling the backend. This is however not
exposed in SQL in the above mentioned functions.

Also adds a new test suite for administrative functions.
---
 doc/src/sgml/func.sgml                    |  13 +-
 src/backend/catalog/system_views.sql      |   8 +
 src/backend/storage/ipc/Makefile          |   2 +-
 src/backend/storage/ipc/ipci.c            |   3 +
 src/backend/storage/ipc/signal_message.c  | 286 ++++++++++++++++++++++++++++++
 src/backend/storage/ipc/signalfuncs.c     |  66 ++++++-
 src/backend/tcop/postgres.c               |  61 ++++++-
 src/backend/utils/init/postinit.c         |   2 +
 src/include/catalog/pg_proc.dat           |   4 +-
 src/include/storage/signal_message.h      |  29 +++
 src/test/regress/expected/admin_funcs.out |  28 +++
 src/test/regress/parallel_schedule        |   2 +-
 src/test/regress/sql/admin_funcs.sql      |  11 ++
 13 files changed, 496 insertions(+), 19 deletions(-)
 create mode 100644 src/backend/storage/ipc/signal_message.c
 create mode 100644 src/include/storage/signal_message.h
 create mode 100644 src/test/regress/expected/admin_funcs.out
 create mode 100644 src/test/regress/sql/admin_funcs.sql

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 10816f556b..e334e77ae7 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -18756,7 +18756,7 @@ SELECT set_config('log_statement_stats', 'off', false);
      <tbody>
       <row>
        <entry>
-        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_cancel_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Cancel a backend's current query.  This is also allowed if the
@@ -18781,7 +18781,7 @@ SELECT set_config('log_statement_stats', 'off', false);
       </row>
       <row>
        <entry>
-        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type>)</function></literal>
+        <literal><function>pg_terminate_backend(<parameter>pid</parameter> <type>int</type> [, <parameter>message</parameter> <type>text</type>])</function></literal>
         </entry>
        <entry><type>boolean</type></entry>
        <entry>Terminate a backend.  This is also allowed if the calling role
@@ -18812,6 +18812,15 @@ SELECT set_config('log_statement_stats', 'off', false);
     The role of an active backend can be found from the
     <structfield>usename</structfield> column of the
     <structname>pg_stat_activity</structname> view.
+    If the optional <literal>message</literal> parameter is set, it will
+    replace the default error message, which in turn will be the error
+    detail. <literal>message</literal> is limited to 128 ASCII characters, a
+    longer text will be truncated. An example where we cancel our own backend:
+<programlisting>
+postgres=# SELECT pg_cancel_backend(pg_backend_pid(), 'cancellation message text');
+ERROR:  cancellation message text
+DETAIL:  canceling statement due to user request by process 12345
+</programlisting>
    </para>
 
    <para>
diff --git a/src/backend/catalog/system_views.sql b/src/backend/catalog/system_views.sql
index 53ddc593a8..d164535beb 100644
--- a/src/backend/catalog/system_views.sql
+++ b/src/backend/catalog/system_views.sql
@@ -1032,6 +1032,14 @@ CREATE OR REPLACE FUNCTION
   RETURNS boolean STRICT VOLATILE LANGUAGE INTERNAL AS 'pg_promote'
   PARALLEL RESTRICTED;
 
+CREATE OR REPLACE FUNCTION
+  pg_cancel_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_cancel_backend' PARALLEL SAFE;
+
+CREATE OR REPLACE FUNCTION
+  pg_terminate_backend(pid int4, message text DEFAULT NULL)
+  RETURNS bool VOLATILE LANGUAGE internal AS 'pg_terminate_backend' PARALLEL SAFE;
+
 -- legacy definition for compatibility with 9.3
 CREATE OR REPLACE FUNCTION
   json_populate_record(base anyelement, from_json json, use_json_as_text boolean DEFAULT false)
diff --git a/src/backend/storage/ipc/Makefile b/src/backend/storage/ipc/Makefile
index 49e7c9f15e..fd628af59f 100644
--- a/src/backend/storage/ipc/Makefile
+++ b/src/backend/storage/ipc/Makefile
@@ -10,6 +10,6 @@ include $(top_builddir)/src/Makefile.global
 
 OBJS = barrier.o dsm_impl.o dsm.o ipc.o ipci.o latch.o pmsignal.o procarray.o \
 	procsignal.o shmem.o shmqueue.o shm_mq.o shm_toc.o signalfuncs.o \
-	sinval.o sinvaladt.o standby.o
+	signal_message.o sinval.o sinvaladt.o standby.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index 0c86a581c0..fb7c1a0b49 100644
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -33,6 +33,7 @@
 #include "replication/walreceiver.h"
 #include "replication/walsender.h"
 #include "replication/origin.h"
+#include "storage/signal_message.h"
 #include "storage/bufmgr.h"
 #include "storage/dsm.h"
 #include "storage/ipc.h"
@@ -150,6 +151,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 		size = add_size(size, SyncScanShmemSize());
 		size = add_size(size, AsyncShmemSize());
 		size = add_size(size, BackendRandomShmemSize());
+		size = add_size(size, BackendSignalFeedbackShmemSize());
 #ifdef EXEC_BACKEND
 		size = add_size(size, ShmemBackendArraySize());
 #endif
@@ -270,6 +272,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
 	SyncScanShmemInit();
 	AsyncShmemInit();
 	BackendRandomShmemInit();
+	BackendSignalFeedbackShmemInit();
 
 #ifdef EXEC_BACKEND
 
diff --git a/src/backend/storage/ipc/signal_message.c b/src/backend/storage/ipc/signal_message.c
new file mode 100644
index 0000000000..596f9584cc
--- /dev/null
+++ b/src/backend/storage/ipc/signal_message.c
@@ -0,0 +1,286 @@
+/*-------------------------------------------------------------------------
+ *
+ * signal_message.c
+ *	  Functions for sending a message to a signalled backend
+ *
+ * This file contains routines to handle registering an optional message when
+ * cancelling, or terminating, a backend as well changing the sqlerrcode used.
+ * The combined payload of message/errcode is referred to as feedback.  The
+ * message will be stored in shared memory and is limited to MAX_CANCEL_MSG
+ * characters including the NULL terminator.
+ *
+ * Access to the feedback slots is protected by spinlocks.
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/ipc/signal_message.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "mb/pg_wchar.h"
+#include "miscadmin.h"
+#include "storage/ipc.h"
+#include "storage/shmem.h"
+#include "storage/signal_message.h"
+#include "storage/spin.h"
+
+
+/*
+ * Structure for registering a feedback payload to be sent to a cancelled, or
+ * terminated backend. Each backend is registered per pid in the array which is
+ * indexed by Backend ID. Reading and writing the message is protected by a
+ * per-slot spinlock.
+ */
+typedef struct
+{
+	pid_t	dest_pid;		/* The pid of the process being signalled */
+	pid_t	src_pid;		/* The pid of the processing signalling */
+	slock_t	mutex;			/* Per-slot protection */
+	char	message[MAX_CANCEL_MSG]; /* Message to send to signalled backend */
+	int		orig_length;	/* Length of the message as passed by the user,
+							 * if this length exceeds MAX_CANCEL_MSG it will
+							 * be truncated but we store the original length
+							 * in order to be able to convey truncation */
+	int		sqlerrcode;		/* errcode to use when signalling backend */
+	int		elevel;			/* elevel to use when signalling backend */
+} BackendSignalFeedbackShmemStruct;
+
+static BackendSignalFeedbackShmemStruct	*BackendSignalFeedbackSlots = NULL;
+static volatile BackendSignalFeedbackShmemStruct *MyCancelSlot = NULL;
+static void CleanupBackendSignalFeedback(int status, Datum argument);
+static int backend_feedback(pid_t backend_pid, char *message, int sqlerrcode,
+							int elevel);
+
+/*
+ * Return the required size for the cancelation feedback Shmem area.
+ */
+Size
+BackendSignalFeedbackShmemSize(void)
+{
+	return MaxBackends * sizeof(BackendSignalFeedbackShmemStruct);
+}
+
+/*
+ * Create and initialize the Shmem structure for holding the feedback, the
+ * bookkeeping for them and the spinlocks associated.
+ */
+void
+BackendSignalFeedbackShmemInit(void)
+{
+	Size	size = BackendSignalFeedbackShmemSize();
+	bool	found;
+	int		i;
+
+	BackendSignalFeedbackSlots = (BackendSignalFeedbackShmemStruct *)
+		ShmemInitStruct("BackendSignalFeedbackSlots", size, &found);
+
+	if (!found)
+	{
+		MemSet(BackendSignalFeedbackSlots, 0, size);
+
+		for (i = 0; i < MaxBackends; i++)
+			SpinLockInit(&(BackendSignalFeedbackSlots[i].mutex));
+	}
+}
+
+/*
+ * Set up the slot for the current backend_id
+ */
+void
+BackendSignalFeedbackInit(int backend_id)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	slot->message[0] = '\0';
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->elevel = 0;
+	slot->dest_pid = MyProcPid;
+
+	MyCancelSlot = slot;
+
+	on_shmem_exit(CleanupBackendSignalFeedback, Int32GetDatum(backend_id));
+}
+
+/*
+ * Ensure that the slot is purged and emptied at exit. Any message gets
+ * overwritten with null chars to avoid risking exposing a message intended for
+ * another backend to a new backend.
+ */
+static void
+CleanupBackendSignalFeedback(int status, Datum argument)
+{
+	int backend_id = DatumGetInt32(argument);
+	volatile BackendSignalFeedbackShmemStruct *slot;
+
+	slot = &BackendSignalFeedbackSlots[backend_id - 1];
+
+	Assert(slot == MyCancelSlot);
+
+	MyCancelSlot = NULL;
+
+	if (slot->orig_length > 0)
+		MemSet(slot->message, '\0', sizeof(slot->message));
+
+	slot->orig_length = 0;
+	slot->sqlerrcode = 0;
+	slot->elevel = 0;
+	slot->dest_pid = 0;
+	slot->src_pid = 0;
+}
+
+/*
+ * Set a message for the cancellation of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendCancelMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_QUERY_CANCELED,
+							ERROR);
+}
+
+/*
+ * Set a message for the termination of the backend with the specified pid,
+ * using the default sqlerrcode.
+ */
+int
+SetBackendTerminationMessage(pid_t backend_pid, char *message)
+{
+	return backend_feedback(backend_pid, message, ERRCODE_ADMIN_SHUTDOWN,
+							FATAL);
+}
+
+/*
+ * Set both a message, elevel and a sqlerrcode for use when signalling the
+ * backend with the specified pid.
+ */
+int
+SetBackendSignalFeedback(pid_t backend_pid, char *message, int sqlerrcode,
+						 int elevel)
+{
+	return backend_feedback(backend_pid, message, sqlerrcode, elevel);
+}
+
+/*
+ * Sets a cancellation message for the backend with the specified pid, and
+ * returns zero on success. If the backend isn't found, or no message is
+ * passed, 1 is returned.  If two backends collide in setting a message, the
+ * existing message will be overwritten by the last one in. The message will
+ * be truncated to fit within MAX_CANCEL_MSG bytes.
+ */
+static int
+backend_feedback(pid_t backend_pid, char *message, int sqlerrcode, int elevel)
+{
+	int		i;
+	int		len;
+
+	if (!message)
+		return 1;
+
+	len = pg_mbcliplen(message, strlen(message), MAX_CANCEL_MSG - 1);
+
+	for (i = 0; i < MaxBackends; i++)
+	{
+		BackendSignalFeedbackShmemStruct *slot = &BackendSignalFeedbackSlots[i];
+
+		if (slot->dest_pid != 0 && slot->dest_pid == backend_pid)
+		{
+			SpinLockAcquire(&slot->mutex);
+			if (slot->dest_pid != backend_pid)
+			{
+				SpinLockRelease(&slot->mutex);
+				return 1;
+			}
+
+			memcpy(slot->message, message, len);
+			slot->orig_length = pg_mbstrlen(message);
+			slot->sqlerrcode = sqlerrcode;
+			slot->elevel = elevel;
+			slot->src_pid = MyProcPid;
+			SpinLockRelease(&slot->mutex);
+
+			if (len != strlen(message))
+				ereport(NOTICE,
+						(errmsg("message is too long and has been truncated")));
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+/*
+ * HasBackendSignalFeedback
+ *		Test if there is a backend signalling feedback to consume
+ *
+ * Test whether there is feedback registered for the current backend that can
+ * be consumed and presented to the user. It isn't strictly required to call
+ * this function prior to consuming a potential message, but since consuming it
+ * will clear it there can be cases where one would like to peek first.
+ */
+bool
+HasBackendSignalFeedback(void)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	bool 	has_message = false;
+
+	if (slot != NULL)
+	{
+		SpinLockAcquire(&slot->mutex);
+		has_message = ((slot->orig_length > 0) && (slot->sqlerrcode != 0));
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return has_message;
+}
+
+/*
+ * ConsumeBackendSignalFeedback
+ *		Read and clear backend signalling feedback
+ *
+ * Return the configured signal feedback in buffer, which is buf_len bytes in
+ * size.  The original length of the message is returned, or zero in case no
+ * message was found. If the returned length exceeds that of Min(buf_len,
+ * MAX_CANCEL_MSG), then truncation has been performed. The feedback (message
+ * and errcode) is cleared on consumption. There is no point in passing a
+ * buffer larger than MAX_CANCEL_MSG as that is the upper bound on what will be
+ * stored in the slot.
+ */
+int
+ConsumeBackendSignalFeedback(char *buffer, size_t buf_len, int *sqlerrcode,
+							 pid_t *pid, int *elevel)
+{
+	volatile BackendSignalFeedbackShmemStruct *slot = MyCancelSlot;
+	int		msg_length = 0;
+
+	if (slot != NULL && slot->orig_length > 0)
+	{
+		SpinLockAcquire(&slot->mutex);
+		if (buffer && buf_len)
+			strlcpy(buffer, (const char *) slot->message, buf_len);
+		msg_length = slot->orig_length;
+		if (sqlerrcode)
+			*sqlerrcode = slot->sqlerrcode;
+		if (pid)
+			*pid = slot->src_pid;
+		if (elevel)
+			*elevel = slot->elevel;
+
+		slot->orig_length = 0;
+		/* Avoid risking to leak any part of a previously set message */
+		MemSet(slot->message, '\0', sizeof(slot->message));
+		slot->sqlerrcode = 0;
+		slot->elevel = 0;
+		SpinLockRelease(&slot->mutex);
+	}
+
+	return msg_length;
+}
diff --git a/src/backend/storage/ipc/signalfuncs.c b/src/backend/storage/ipc/signalfuncs.c
index 878665b045..f0c02c7008 100644
--- a/src/backend/storage/ipc/signalfuncs.c
+++ b/src/backend/storage/ipc/signalfuncs.c
@@ -19,9 +19,11 @@
 #include "catalog/pg_authid.h"
 #include "miscadmin.h"
 #include "postmaster/syslogger.h"
+#include "storage/ipc.h"
 #include "storage/pmsignal.h"
 #include "storage/proc.h"
 #include "storage/procarray.h"
+#include "storage/signal_message.h"
 #include "utils/acl.h"
 #include "utils/builtins.h"
 
@@ -29,9 +31,11 @@
 /*
  * Send a signal to another backend.
  *
- * The signal is delivered if the user is either a superuser or the same
- * role as the backend being signaled. For "dangerous" signals, an explicit
- * check for superuser needs to be done prior to calling this function.
+ * The signal is delivered if the user is either a superuser or the same role
+ * as the backend being signaled. For "dangerous" signals, an explicit check
+ * for superuser needs to be done prior to calling this function. If msg is
+ * set, the contents will be passed as a message to the backend in the error
+ * message.
  *
  * Returns 0 on success, 1 on general failure, 2 on normal permission error
  * and 3 if the caller needs to be a superuser.
@@ -45,7 +49,7 @@
 #define SIGNAL_BACKEND_NOPERMISSION 2
 #define SIGNAL_BACKEND_NOSUPERUSER 3
 static int
-pg_signal_backend(int pid, int sig)
+pg_signal_backend(int pid, int sig, char *msg)
 {
 	PGPROC	   *proc = BackendPidGetProc(pid);
 
@@ -77,6 +81,30 @@ pg_signal_backend(int pid, int sig)
 		!has_privs_of_role(GetUserId(), DEFAULT_ROLE_SIGNAL_BACKENDID))
 		return SIGNAL_BACKEND_NOPERMISSION;
 
+	/* If the user supplied a message to the signalled backend */
+	if (msg != NULL)
+	{
+		char *tmp = msg;
+
+		/*
+		 * The message to pass to the signalled backend is currently restricted
+		 * to ASCII only, since the sending backend might use an encoding which
+		 * is incompatible with the receiving with regards to conversion.
+		 */
+		while (*tmp != '\0')
+		{
+			if (!isascii(*tmp))
+				ereport(ERROR,
+						(errmsg("message is restricted to ASCII only")));
+			tmp++;
+		}
+
+		if (sig == SIGINT)
+			SetBackendCancelMessage(pid, msg);
+		else
+			SetBackendTerminationMessage(pid, msg);
+	}
+
 	/*
 	 * Can the process we just validated above end, followed by the pid being
 	 * recycled for a new process, before reaching here?  Then we'd be trying
@@ -110,7 +138,19 @@ pg_signal_backend(int pid, int sig)
 Datum
 pg_cancel_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGINT);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGINT, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -134,7 +174,19 @@ pg_cancel_backend(PG_FUNCTION_ARGS)
 Datum
 pg_terminate_backend(PG_FUNCTION_ARGS)
 {
-	int			r = pg_signal_backend(PG_GETARG_INT32(0), SIGTERM);
+	int			r;
+	pid_t		pid;
+	char 	   *msg = NULL;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	pid = PG_GETARG_INT32(0);
+
+	if (PG_NARGS() == 2 && !PG_ARGISNULL(1))
+		msg = text_to_cstring(PG_GETARG_TEXT_PP(1));
+
+	r = pg_signal_backend(pid, SIGTERM, msg);
 
 	if (r == SIGNAL_BACKEND_NOSUPERUSER)
 		ereport(ERROR,
@@ -146,7 +198,7 @@ pg_terminate_backend(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
 				 (errmsg("must be a member of the role whose process is being terminated or member of pg_signal_backend"))));
 
-	PG_RETURN_BOOL(r == SIGNAL_BACKEND_SUCCESS);
+	return (r == SIGNAL_BACKEND_SUCCESS);
 }
 
 /*
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index a3b9757565..50c56e0618 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -62,6 +62,7 @@
 #include "replication/slot.h"
 #include "replication/walsender.h"
 #include "rewrite/rewriteHandler.h"
+#include "storage/signal_message.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
 #include "storage/proc.h"
@@ -3013,9 +3014,33 @@ ProcessInterrupts(void)
 					 errdetail_recovery_conflict()));
 		}
 		else
-			ereport(FATAL,
-					(errcode(ERRCODE_ADMIN_SHUTDOWN),
-					 errmsg("terminating connection due to administrator command")));
+		{
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid, NULL);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_ADMIN_SHUTDOWN;
+					buffer[0] = '\0';
+				}
+				ereport(FATAL,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("terminating connection due to administrator command by process %d",
+								   pid)));
+			}
+			else
+				ereport(FATAL,
+						(errcode(ERRCODE_ADMIN_SHUTDOWN),
+						 errmsg("terminating connection due to administrator command")));
+		}
 	}
 	if (ClientConnectionLost)
 	{
@@ -3126,9 +3151,33 @@ ProcessInterrupts(void)
 		if (!DoingCommandRead)
 		{
 			LockErrorCleanup();
-			ereport(ERROR,
-					(errcode(ERRCODE_QUERY_CANCELED),
-					 errmsg("canceling statement due to user request")));
+
+			if (HasBackendSignalFeedback())
+			{
+				char	buffer[MAX_CANCEL_MSG];
+				int		len;
+				int		sqlerrcode = 0;
+				pid_t	pid = 0;
+
+				len = ConsumeBackendSignalFeedback(buffer, MAX_CANCEL_MSG,
+												   &sqlerrcode, &pid, NULL);
+				if (len == 0)
+				{
+					sqlerrcode = ERRCODE_QUERY_CANCELED;
+					buffer[0] = '\0';
+				}
+
+				ereport(ERROR,
+						(errcode(sqlerrcode),
+						 errmsg("%s%s",
+								buffer, (len > sizeof(buffer) ? "..." : "")),
+						 errdetail("canceling statement due to user request by process %d",
+								   pid)));
+			}
+			else
+				ereport(ERROR,
+						(errcode(ERRCODE_QUERY_CANCELED),
+						 errmsg("canceling statement due to user request")));
 		}
 	}
 
diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c
index 4f1d2a0d28..4382691420 100644
--- a/src/backend/utils/init/postinit.c
+++ b/src/backend/utils/init/postinit.c
@@ -40,6 +40,7 @@
 #include "postmaster/autovacuum.h"
 #include "postmaster/postmaster.h"
 #include "replication/walsender.h"
+#include "storage/signal_message.h"
 #include "storage/bufmgr.h"
 #include "storage/fd.h"
 #include "storage/ipc.h"
@@ -780,6 +781,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username,
 		PerformAuthentication(MyProcPort);
 		InitializeSessionUserId(username, useroid);
 		am_superuser = superuser();
+		BackendSignalFeedbackInit(MyBackendId);
 	}
 
 	/*
diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat
index 4026018ba9..11b8830217 100644
--- a/src/include/catalog/pg_proc.dat
+++ b/src/include/catalog/pg_proc.dat
@@ -5799,10 +5799,10 @@
 
 { oid => '2171', descr => 'cancel a server process\' current query',
   proname => 'pg_cancel_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_cancel_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_cancel_backend' },
 { oid => '2096', descr => 'terminate a server process',
   proname => 'pg_terminate_backend', provolatile => 'v', prorettype => 'bool',
-  proargtypes => 'int4', prosrc => 'pg_terminate_backend' },
+  proargtypes => 'int4 text', proisstrict => 'f', prosrc => 'pg_terminate_backend' },
 { oid => '2172', descr => 'prepare for taking an online backup',
   proname => 'pg_start_backup', provolatile => 'v', proparallel => 'r',
   prorettype => 'pg_lsn', proargtypes => 'text bool bool',
diff --git a/src/include/storage/signal_message.h b/src/include/storage/signal_message.h
new file mode 100644
index 0000000000..e0f834f2f5
--- /dev/null
+++ b/src/include/storage/signal_message.h
@@ -0,0 +1,29 @@
+/*-------------------------------------------------------------------------
+ *
+ * signal_message.h
+ *		Declarations for sending a message to a signalled backend
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ *
+ *	  src/include/storage/signal_message.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef SIGNAL_MESSAGE_H
+#define SIGNAL_MESSAGE_H
+
+#define MAX_CANCEL_MSG 128
+
+extern Size BackendSignalFeedbackShmemSize(void);
+extern void BackendSignalFeedbackShmemInit(void);
+extern void BackendSignalFeedbackInit(int backend_id);
+
+extern int SetBackendCancelMessage(pid_t backend, char *message);
+extern int SetBackendTerminationMessage(pid_t backend, char *message);
+extern int SetBackendSignalFeedback(pid_t backend, char *message,
+									int sqlerrcode, int elevel);
+extern bool HasBackendSignalFeedback(void);
+extern int ConsumeBackendSignalFeedback(char *msg, size_t len, int *sqlerrcode,
+										pid_t *pid, int *elevel);
+
+#endif							/* SIGNAL_MESSAGE_H */
diff --git a/src/test/regress/expected/admin_funcs.out b/src/test/regress/expected/admin_funcs.out
new file mode 100644
index 0000000000..84e1835fa6
--- /dev/null
+++ b/src/test/regress/expected/admin_funcs.out
@@ -0,0 +1,28 @@
+select pg_cancel_backend(NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select case
+	when pg_cancel_backend(pg_backend_pid())
+	then pg_sleep(60)
+end;
+ERROR:  canceling statement due to user request
+select pg_cancel_backend(NULL, NULL);
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select pg_cancel_backend(NULL, 'suicide is painless');
+ pg_cancel_backend 
+-------------------
+ 
+(1 row)
+
+select case
+	when pg_cancel_backend(pg_backend_pid(), NULL)
+	then pg_sleep(60)
+end;
+ERROR:  canceling statement due to user request
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index b5e15501dd..5034cc8c20 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -84,7 +84,7 @@ test: select_into select_distinct select_distinct_on select_implicit select_havi
 # ----------
 # Another group of parallel tests
 # ----------
-test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index
+test: brin gin gist spgist privileges init_privs security_label collate matview lock replica_identity rowsecurity object_address tablesample groupingsets drop_operator password func_index admin_funcs
 
 # ----------
 # Another group of parallel tests
diff --git a/src/test/regress/sql/admin_funcs.sql b/src/test/regress/sql/admin_funcs.sql
new file mode 100644
index 0000000000..73a4994535
--- /dev/null
+++ b/src/test/regress/sql/admin_funcs.sql
@@ -0,0 +1,11 @@
+select pg_cancel_backend(NULL);
+select case
+	when pg_cancel_backend(pg_backend_pid())
+	then pg_sleep(60)
+end;
+select pg_cancel_backend(NULL, NULL);
+select pg_cancel_backend(NULL, 'suicide is painless');
+select case
+	when pg_cancel_backend(pg_backend_pid(), NULL)
+	then pg_sleep(60)
+end;
-- 
2.14.1.145.gb3622a4ee