postgres.git / summary / log / commit / refs

commit    faa90079839343e7b350c869b45f496ea3e9a05c
Author:   Tom Lane <tgl@sss.pgh.pa.us>
Date:     Sun Nov 07 02:59:15 2010 +0000
First released in: 9.1.0, 8.1.23, 8.2.19, 8.3.13, 8.4.6, 9.0.2

    Add support for detecting register-stack overrun on IA64.
    
    Per recent investigation, the register stack can grow faster than the
    regular stack depending on compiler and choice of options.  To avoid
    crashes we must check both stacks in check_stack_depth().
    
    Back-patch to all supported versions.


 src/backend/tcop/postgres.c | 60 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)

diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 43e912f5cff..cf591ed5e32 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -111,6 +111,12 @@ static long max_stack_depth_bytes = 100 * 1024L;
  */
 char	   *stack_base_ptr = NULL;
 
+/*
+ * On IA64 we also have to remember the register stack base.
+ */
+#if defined(__ia64__) || defined(__ia64)
+char	   *register_stack_base_ptr = NULL;
+#endif
 
 /*
  * Flag to mark SIGHUP. Whenever the main loop comes around it
@@ -2677,6 +2683,35 @@ ProcessInterrupts(void)
 }
 
 
+/*
+ * IA64-specific code to fetch the AR.BSP register for stack depth checks.
+ *
+ * We currently support gcc and icc here.
+ */
+#if defined(__ia64__) || defined(__ia64)
+
+#include <asm/ia64regs.h>
+
+static __inline__ char *
+ia64_get_bsp(void)
+{
+	char	   *ret;
+
+#ifndef __INTEL_COMPILER
+	/* the ;; is a "stop", seems to be required before fetching BSP */
+	__asm__ __volatile__(
+		";;\n"
+		"	mov	%0=ar.bsp	\n"
+:		"=r"(ret));
+#else
+  ret = (char *) __getReg(_IA64_REG_AR_BSP);
+#endif
+  return ret;
+}
+
+#endif /* IA64 */
+
+
 /*
  * check_stack_depth: check for excessively deep recursion
  *
@@ -2719,6 +2754,28 @@ check_stack_depth(void)
 		 errhint("Increase the configuration parameter \"max_stack_depth\", "
 		   "after ensuring the platform's stack depth limit is adequate.")));
 	}
+
+	/*
+	 * On IA64 there is a separate "register" stack that requires its own
+	 * independent check.  For this, we have to measure the change in the
+	 * "BSP" pointer from PostgresMain to here.  Logic is just as above,
+	 * except that we know IA64's register stack grows up.
+	 *
+	 * Note we assume that the same max_stack_depth applies to both stacks.
+	 */
+#if defined(__ia64__) || defined(__ia64)
+	stack_depth = (long) (ia64_get_bsp() - register_stack_base_ptr);
+
+	if (stack_depth > max_stack_depth_bytes &&
+		register_stack_base_ptr != NULL)
+	{
+		ereport(ERROR,
+				(errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
+				 errmsg("stack depth limit exceeded"),
+		 errhint("Increase the configuration parameter \"max_stack_depth\", "
+		   "after ensuring the platform's stack depth limit is adequate.")));
+	}
+#endif /* IA64 */
 }
 
 /* GUC assign hook for max_stack_depth */
@@ -2894,6 +2951,9 @@ PostgresMain(int argc, char *argv[], const char *username)
 
 	/* Set up reference point for stack depth checking */
 	stack_base_ptr = &stack_base;
+#if defined(__ia64__) || defined(__ia64)
+	register_stack_base_ptr = ia64_get_bsp();
+#endif
 
 	/* Compute paths, if we didn't inherit them from postmaster */
 	if (my_exec_path[0] == '\0')


[parent: 78f0924f0081]