File mysql-5.0.67-stack-guard.patch of Package mysql

File mysql-5.0.67-stack-guard.patch of Package mysql (Revision 513c16d2d7b542b33b818cf6a94e03d2)

Currently displaying revision 513c16d2d7b542b33b818cf6a94e03d2, show latest

mysql is not accounting for the "guard page" when setting thread stack size
requests.  This is fatal on PPC systems, which may use guard pages as large
as 64K.  This patch also documents the IA64 situation a bit better.

Note: there are quite a few other setstacksize calls besides the two in
mysqld.cc; is it important to fix any of the others?

Index: sql/mysqld.cc
===================================================================
--- sql/mysqld.cc.orig
+++ sql/mysqld.cc
@@ -2467,6 +2467,68 @@ static void init_signals(void)
   DBUG_VOID_RETURN;
 }
 
+/* pthread_attr_setstacksize without so much platform-dependency */
+/* returns the actual stack size if possible */
+static size_t my_setstacksize(pthread_attr_t *attr, size_t stacksize)
+{
+  size_t guard_size = 0;
+
+#if defined(__ia64__) || defined(__ia64)
+  /*
+    On IA64, half of the requested stack size is used for "normal stack"
+    and half for "register stack".  The space measured by check_stack_overrun
+    is the "normal stack", so double the request to make sure we have the
+    caller-expected amount of normal stack.
+
+    NOTE: there is no guarantee that the register stack can't grow faster
+    than normal stack, so it's very unclear that we won't dump core due to
+    stack overrun despite check_stack_overrun's efforts.  Experimentation
+    shows that in the execution_constants test, the register stack grows
+    less than half as fast as normal stack, but perhaps other scenarios are
+    less forgiving.  If it turns out that more space is needed for the
+    register stack, that could be forced (rather inefficiently) by using a
+    multiplier higher than 2 here.
+  */
+  stacksize *= 2;
+#endif
+
+  /*
+    On many machines, the "guard space" is subtracted from the requested
+    stack size, and that space is quite large on some platforms.  So add
+    it to our request, if we can find out what it is.
+
+    FIXME: autoconfiscate use of pthread_attr_getguardsize
+  */
+  if (pthread_attr_getguardsize(attr, &guard_size))
+    guard_size = 0;		/* if can't find it out, treat as 0 */
+
+  pthread_attr_setstacksize(attr, stacksize + guard_size);
+
+  /* Retrieve actual stack size if possible */
+#ifdef HAVE_PTHREAD_ATTR_GETSTACKSIZE
+  {
+    size_t real_stack_size= 0;
+    /* We must ignore real_stack_size = 0 as Solaris 2.9 can return 0 here */
+    if (pthread_attr_getstacksize(attr, &real_stack_size) == 0 &&
+	real_stack_size > guard_size)
+    {
+      real_stack_size -= guard_size;
+      if (real_stack_size < stacksize)
+      {
+	if (global_system_variables.log_warnings)
+	  sql_print_warning("Asked for %ld thread stack, but got %ld",
+			    (long) stacksize, (long) real_stack_size);
+	stacksize= real_stack_size;
+      }
+    }
+  }
+#endif
+
+#if defined(__ia64__) || defined(__ia64)
+  stacksize /= 2;
+#endif
+  return stacksize;
+}
 
 static void start_signal_handler(void)
 {
@@ -2480,15 +2542,7 @@ static void start_signal_handler(void)
   (void) pthread_attr_setdetachstate(&thr_attr,PTHREAD_CREATE_DETACHED);
   if (!(opt_specialflag & SPECIAL_NO_PRIOR))
     my_pthread_attr_setprio(&thr_attr,INTERRUPT_PRIOR);
-#if defined(__ia64__) || defined(__ia64)
-  /*
-    Peculiar things with ia64 platforms - it seems we only have half the
-    stack size in reality, so we have to double it here
-  */
-  pthread_attr_setstacksize(&thr_attr,thread_stack*2);
-#else
-  pthread_attr_setstacksize(&thr_attr,thread_stack);
-#endif
+  (void) my_setstacksize(&thr_attr,thread_stack);
 #endif
 
   (void) pthread_mutex_lock(&LOCK_thread_count);
@@ -3662,41 +3716,12 @@ int main(int argc, char **argv)
   init_signals();
   if (!(opt_specialflag & SPECIAL_NO_PRIOR))
     my_pthread_setprio(pthread_self(),CONNECT_PRIOR);
-#if defined(__ia64__) || defined(__ia64)
-  /*
-    Peculiar things with ia64 platforms - it seems we only have half the
-    stack size in reality, so we have to double it here
-  */
-  pthread_attr_setstacksize(&connection_attrib,thread_stack*2);
-#else
-  pthread_attr_setstacksize(&connection_attrib,thread_stack);
-#endif
-#ifdef HAVE_PTHREAD_ATTR_GETSTACKSIZE
-  {
-    /* Retrieve used stack size;  Needed for checking stack overflows */
-    size_t stack_size= 0;
-    pthread_attr_getstacksize(&connection_attrib, &stack_size);
-#if defined(__ia64__) || defined(__ia64)
-    stack_size/= 2;
-#endif
-    /* We must check if stack_size = 0 as Solaris 2.9 can return 0 here */
-    if (stack_size && stack_size < thread_stack)
-    {
-      if (global_system_variables.log_warnings)
-	sql_print_warning("Asked for %lu thread stack, but got %ld",
-			  thread_stack, (long) stack_size);
-#if defined(__ia64__) || defined(__ia64)
-      thread_stack= stack_size*2;
-#else
-      thread_stack= stack_size;
-#endif
-    }
-  }
-#endif
+
 #ifdef __NETWARE__
   /* Increasing stacksize of threads on NetWare */
-
   pthread_attr_setstacksize(&connection_attrib, NW_THD_STACKSIZE);
+#else
+  thread_stack = my_setstacksize(&connection_attrib,thread_stack);
 #endif
 
   (void) thr_setconcurrency(concurrency);	// 10 by default