AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-09 23:00:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix tst-setcontext9 for optimized small stacks.

Browse Source 
If the compiler reduces the stack usage in function f1 before calling
into function f2, then when we swapcontext back to f1 and continue
execution we may overwrite registers that were spilled to the stack
while f2 was executing.  Later when we return to f2 the corrupt
registers will be reloaded from the stack and the test will crash.  This
was most commonly observed on i686 with __x86.get_pc_thunk.dx and
needing to save and restore $edx.  Overall i686 has few registers and
the spilling to the stack is bound to happen, therefore the solution to
making this test robust is to split function f1 into two parts f1a and
f1b, and allocate f1b it's own stack such that subsequent execution does
not overwrite the stack in use by function f2.

Tested on i686 and x86_64.

Signed-off-by: Carlos O'Donell <carlos@redhat.com>
This commit is contained in:
Carlos O'Donell 2018-09-05 01:16:42 -04:00
parent e1080e7e5f
commit 791b350dc7
2 changed files with 44 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ChangeLog
View File

@ -1,3 +1,9 @@
2018-09-19 Carlos O'Donell <carlos@redhat.com>
* stdlib/tst-setcontext9.c (f1): Rename to...
(f1a): ... this.
(f1b): New function implementing lower half of f1 in alternate stack.
2018-09-19 Paul Eggert <eggert@cs.ucla.edu>
Fix mktime localtime offset confusion

47
stdlib/tst-setcontext9.c
View File

@ -41,26 +41,55 @@ f2 (void)
}
static void
f1 (void)
f1b (void)
{
puts ("start f1");
if (getcontext (&ctx[2]) != 0)
{
printf ("%s: getcontext: %m\n", __FUNCTION__);
exit (EXIT_FAILURE);
}
if (done)
{
puts ("set context in f1");
puts ("set context in f1b");
if (setcontext (&ctx[3]) != 0)
{
printf ("%s: setcontext: %m\n", __FUNCTION__);
exit (EXIT_FAILURE);
}
}
exit (EXIT_FAILURE);
}
static void
f1a (void)
{
char st2[32768];
puts ("start f1a");
if (getcontext (&ctx[2]) != 0)
{
printf ("%s: getcontext: %m\n", __FUNCTION__);
exit (EXIT_FAILURE);
}
ctx[2].uc_stack.ss_sp = st2;
ctx[2].uc_stack.ss_size = sizeof st2;
ctx[2].uc_link = &ctx[0];
makecontext (&ctx[2], (void (*) (void)) f1b, 0);
f2 ();
}
/* The execution path through the test looks like this:
do_test (call)
-> "making contexts"
-> "swap contexts"
f1a (via swapcontext to ctx[1], with alternate stack)
-> "start f1a"
f2 (call)
-> "swap contexts in f2"
f1b (via swapcontext to ctx[2], with alternate stack)
-> "set context in f1b"
do_test (via setcontext to ctx[3], main stack)
-> "setcontext"
f2 (via setcontext to ctx[4], with alternate stack)
-> "end f2"
We must use an alternate stack for f1b, because if we don't then the
result of executing an earlier caller may overwrite registers
spilled to the stack in f2. */
static int
do_test (void)
{
@ -79,7 +108,7 @@ do_test (void)
ctx[1].uc_stack.ss_sp = st1;
ctx[1].uc_stack.ss_size = sizeof st1;
ctx[1].uc_link = &ctx[0];
makecontext (&ctx[1], (void (*) (void)) f1, 0);
makecontext (&ctx[1], (void (*) (void)) f1a, 0);
puts ("swap contexts");
if (swapcontext (&ctx[3], &ctx[1]) != 0)
{