Fix stack size and address inconsistency due to executable stack

When a stack is marked executable due to loading a DSO that requires
an executable stack, the logic tends to leave out a portion of stack
after the first frame, thus causing a difference in the value returned
by pthread_getattr_np before and after the stack is marked
executable. It ought to be possible to fix this by marking the rest of
the stack as executable too, but in the interest of marking as less of
the stack as executable as possible, the path this fix takes is to
make pthread_getattr_np also look at the first frame as the underflow
end of the stack and compute size and stack top accordingly.

The above happens only for the main process stack. NPTL thread stacks
are not affected by this change.

diff --git a/ChangeLog b/ChangeLog
index f97e481081dd23807b0202ff6e5deec2134202d3..7ee459ba438274db332868a84c796be655569448 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+2012-05-26  Siddhesh Poyarekar  <siddhesh@redhat.com>
+
+       [BZ #12416]
+       * elf/tst-execstack.c: Include stackinfo.h.
+       (do_test): Adjust test case to ensure that pthread_getattr_np
+       behaviour remains the same after marking stack executable.
+
 2012-05-25  Joseph Myers  <joseph@codesourcery.com>
 
        * sysdeps/unix/sysv/linux/kernel-features.h

diff --git a/NEWS b/NEWS
index 6f8469742be6b0fe873f639b1fd344d33b42673f..9583748a8f929feeba1a46869a39fd79d936501e 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -16,19 +16,19 @@ Version 2.16
   6884, 6890, 6894, 6895, 6907, 6911, 6959, 7064, 9739, 9902, 10110, 10135,
   10140, 10153, 10210, 10254, 10346, 10375, 10545, 10716, 10846, 11174,
   11322, 11365, 11451, 11494, 11521, 11677, 11837, 11959, 12047, 12097,
-  12193, 12297, 12298, 12301, 12340, 12354, 12495, 13058, 13361, 13525,
-  13526, 13527, 13528, 13529, 13530, 13531, 13532, 13533, 13547, 13551,
-  13552, 13553, 13555, 13556, 13559, 13563, 13566, 13576, 13583, 13592,
-  13594, 13613, 13618, 13637, 13656, 13658, 13673, 13691, 13695, 13704,
-  13705, 13706, 13726, 13738, 13739, 13750, 13758, 13760, 13761, 13775,
-  13786, 13787, 13792, 13806, 13824, 13840, 13841, 13844, 13846, 13851,
-  13852, 13854, 13871, 13872, 13873, 13879, 13883, 13884, 13885, 13886,
-  13892, 13895, 13908, 13910, 13911, 13912, 13913, 13914, 13915, 13916,
-  13917, 13918, 13919, 13920, 13921, 13922, 13923, 13924, 13926, 13927,
-  13928, 13938, 13941, 13942, 13954, 13955, 13956, 13963, 13967, 13968,
-  13970, 13973, 13979, 13983, 13986, 14012, 14027, 14033, 14034, 14036,
-  14040, 14043, 14044, 14049, 14053, 14055, 14059, 14064, 14080, 14083,
-  14103, 14104, 14109, 14122, 14123, 14153
+  12193, 12297, 12298, 12301, 12340, 12354, 12416, 12495, 13058, 13361,
+  13525, 13526, 13527, 13528, 13529, 13530, 13531, 13532, 13533, 13547,
+  13551, 13552, 13553, 13555, 13556, 13559, 13563, 13566, 13576, 13583,
+  13592, 13594, 13613, 13618, 13637, 13656, 13658, 13673, 13691, 13695,
+  13704, 13705, 13706, 13726, 13738, 13739, 13750, 13758, 13760, 13761,
+  13775, 13786, 13787, 13792, 13806, 13824, 13840, 13841, 13844, 13846,
+  13851, 13852, 13854, 13871, 13872, 13873, 13879, 13883, 13884, 13885,
+  13886, 13892, 13895, 13908, 13910, 13911, 13912, 13913, 13914, 13915,
+  13916, 13917, 13918, 13919, 13920, 13921, 13922, 13923, 13924, 13926,
+  13927, 13928, 13938, 13941, 13942, 13954, 13955, 13956, 13963, 13967,
+  13968, 13970, 13973, 13979, 13983, 13986, 14012, 14027, 14033, 14034,
+  14036, 14040, 14043, 14044, 14049, 14053, 14055, 14059, 14064, 14080,
+  14083, 14103, 14104, 14109, 14122, 14123, 14153
 
 * ISO C11 support:
 

diff --git a/elf/tst-execstack.c b/elf/tst-execstack.c
index 6632e5336708a2d673240582870bf5cadd16831a..02cc270d804232a588977006c7754cd6929e89dd 100644 (file)
--- a/elf/tst-execstack.c
+++ b/elf/tst-execstack.c
@@ -7,6 +7,7 @@
 #include <string.h>
 #include <unistd.h>
 #include <error.h>
+#include <stackinfo.h>
 
 static void
 print_maps (void)
@@ -46,7 +47,6 @@ waiter_thread (void *arg)
 }
 #endif
 
-
 static bool allow_execstack = true;
 
 
@@ -107,6 +107,35 @@ do_test (void)
 
   print_maps ();
 
+#if USE_PTHREADS
+  void *old_stack_addr, *new_stack_addr;
+  size_t stack_size;
+  pthread_t me = pthread_self ();
+  pthread_attr_t attr;
+  int ret = 0;
+
+  ret = pthread_getattr_np (me, &attr);
+  if (ret)
+    {
+      printf ("before execstack: pthread_getattr_np returned error: %s\n",
+             strerror (ret));
+      return 1;
+    }
+
+  ret = pthread_attr_getstack (&attr, &old_stack_addr, &stack_size);
+  if (ret)
+    {
+      printf ("before execstack: pthread_attr_getstack returned error: %s\n",
+             strerror (ret));
+      return 1;
+    }
+# if _STACK_GROWS_DOWN
+    old_stack_addr += stack_size;
+# else
+    old_stack_addr -= stack_size;
+# endif
+#endif
+
   /* Loading this module should force stacks to become executable.  */
   void *h = dlopen ("tst-execstack-mod.so", RTLD_LAZY);
   if (h == NULL)
@@ -129,6 +158,46 @@ do_test (void)
 
   print_maps ();
 
+#if USE_PTHREADS
+  ret = pthread_getattr_np (me, &attr);
+  if (ret)
+    {
+      printf ("after execstack: pthread_getattr_np returned error: %s\n",
+             strerror (ret));
+      return 1;
+    }
+
+  ret = pthread_attr_getstack (&attr, &new_stack_addr, &stack_size);
+  if (ret)
+    {
+      printf ("after execstack: pthread_attr_getstack returned error: %s\n",
+             strerror (ret));
+      return 1;
+    }
+
+# if _STACK_GROWS_DOWN
+    new_stack_addr += stack_size;
+# else
+    new_stack_addr -= stack_size;
+# endif
+
+  /* It is possible that the dlopen'd module may have been mmapped just below
+     the stack.  The stack size is taken as MIN(stack rlimit size, end of last
+     vma) in pthread_getattr_np.  If rlimit is set high enough, it is possible
+     that the size may have changed.  A subsequent call to
+     pthread_attr_getstack returns the size and (bottom - size) as the
+     stacksize and stackaddr respectively.  If the size changes due to the
+     above, then both stacksize and stackaddr can change, but the stack bottom
+     should remain the same, which is computed as stackaddr + stacksize.  */
+  if (old_stack_addr != new_stack_addr)
+    {
+      printf ("Stack end changed, old: %p, new: %p\n",
+             old_stack_addr, new_stack_addr);
+      return 1;
+    }
+  printf ("Stack address remains the same: %p\n", old_stack_addr);
+#endif
+
   /* Test that growing the stack region gets new executable pages too.  */
   deeper ((void (*) (void)) f);
 

diff --git a/nptl/ChangeLog b/nptl/ChangeLog
index a488ccb37d444d150f9cd352880c5f6ca2cce627..492668bdeb944d9600a888fc37009e327d58cab9 100644 (file)
--- a/nptl/ChangeLog
+++ b/nptl/ChangeLog
@@ -1,3 +1,10 @@
+2012-05-26  Siddhesh Poyarekar  <siddhesh@redhat.com>
+
+       [BZ #12416]
+       * nptl/pthread_getattr_np.c (pthread_getattr_np): Use
+       __libc_stack_end rounded to the end of containing page as the
+       real stack end.
+
 2012-05-25  Rayson Ho  <rho@redhat.com>
 
        * sysdeps/unix/sysv/linux/i386/lowlevellock.h: Low-level SystemTap

diff --git a/nptl/pthread_getattr_np.c b/nptl/pthread_getattr_np.c
index f1268dd82fcda855201bd316ddcbedf05adb3d3b..75d717bb1f93b3531641b5633281cef199c76600 100644 (file)
--- a/nptl/pthread_getattr_np.c
+++ b/nptl/pthread_getattr_np.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002-2004, 2006, 2007, 2011 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2012 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
@@ -84,6 +84,18 @@ pthread_getattr_np (thread_id, attr)
            ret = errno;
          else
            {
+             /* We consider the main process stack to have ended with
+                the page containing __libc_stack_end.  There is stuff below
+                it in the stack too, like the program arguments, environment
+                variables and auxv info, but we ignore those pages when
+                returning size so that the output is consistent when the
+                stack is marked executable due to a loaded DSO requiring
+                it.  */
+             void *stack_end = (void *) ((uintptr_t) __libc_stack_end
+                                         & -(uintptr_t) GLRO(dl_pagesize));
+#if _STACK_GROWS_DOWN
+             stack_end += GLRO(dl_pagesize);
+#endif
              /* We need no locking.  */
              __fsetlocking (fp, FSETLOCKING_BYCALLER);
 
@@ -109,7 +121,7 @@ pthread_getattr_np (thread_id, attr)
                    {
                      /* Found the entry.  Now we have the info we need.  */
                      iattr->stacksize = rl.rlim_cur;
-                     iattr->stackaddr = (void *) to;
+                     iattr->stackaddr = stack_end;
 
                      /* The limit might be too high.  */
                      if ((size_t) iattr->stacksize