JehanneOS
/
newlib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

* miscfuncs.cc (struct thread_wrapper_arg): Convert char * to PBYTE. 

Change related casts throughout.
	(thread_wrapper): Only do the thread change if the application provided
	the stack.  Otherwise, just use the Windows-provided stack.  Set up
	POSIX guardpage here, if necessary.  Move related comment from
	CygwinCreateThread here.
	(CygwinCreateThread): Never allocate and set up own stack here.  Just
	compute stack size to reserve and use value in CreateThread call if
	stack hasn't been provided by the application.
This commit is contained in:
Corinna Vinschen 2012-02-13 15:23:03 +00:00
parent d7bcd2a16f
commit 722c69734d
2 changed files with 147 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
winsup/cygwin/ChangeLog
View File

@ -1,3 +1,15 @@
2012-02-13 Corinna Vinschen <corinna@vinschen.de>
* miscfuncs.cc (struct thread_wrapper_arg): Convert char * to PBYTE.
Change related casts throughout.
(thread_wrapper): Only do the thread change if the application provided
the stack. Otherwise, just use the Windows-provided stack. Set up
POSIX guardpage here, if necessary. Move related comment from
CygwinCreateThread here.
(CygwinCreateThread): Never allocate and set up own stack here. Just
compute stack size to reserve and use value in CreateThread call if
stack hasn't been provided by the application.
2012-02-13 Corinna Vinschen <corinna@vinschen.de> 2012-02-13 Corinna Vinschen <corinna@vinschen.de>
* Makefile.in (clean): Remove non-existant regexp dir. * Makefile.in (clean): Remove non-existant regexp dir.

155
winsup/cygwin/miscfuncs.cc
View File

@ -442,9 +442,9 @@ struct thread_wrapper_arg
{ {
LPTHREAD_START_ROUTINE func; LPTHREAD_START_ROUTINE func;
PVOID arg; PVOID arg;
char *stackaddr; PBYTE stackaddr;
char *stackbase; PBYTE stackbase;
char *commitaddr; ULONG guardsize;
}; };
DWORD WINAPI DWORD WINAPI
@ -458,25 +458,58 @@ thread_wrapper (VOID *arg)
thread_wrapper_arg wrapper_arg = *(thread_wrapper_arg *) arg; thread_wrapper_arg wrapper_arg = *(thread_wrapper_arg *) arg;
cfree (arg); cfree (arg);
PTEB teb = NtCurrentTeb ();
if (!wrapper_arg.stackaddr)
{
/* The simple case: Windows-provided stack. */
/* If guardsize is exactly the page_size, we can assume that the
application will behave Windows conformant in terms of stack usage.
We can especially assume that it never allocates more than one
page at a time (alloca/_chkstk). Therefore, this is the default
case which allows a Windows compatible stack setup with a
reserved region, a guard page, and a commited region. We don't
need to set up a POSIX guardpage since Windows already handles
stack overflow: Trying to extend the stack into the last three
pages of the stack results in a SEGV. */
if (wrapper_arg.guardsize != wincap.page_size ())
{
/* However, if guardsize is set to something other than the
page size, we commit the entire stack, remove the Windows
guardpage and, if guardsize is > 0, set up a POSIX guardpage. */
DWORD old_prot;
ULONG stacksize = (uintptr_t) teb->Tib.StackBase
- (uintptr_t) teb->DeallocationStack;
VirtualAlloc (teb->DeallocationStack, stacksize,
MEM_COMMIT, PAGE_READWRITE);
VirtualProtect (teb->DeallocationStack, stacksize,
PAGE_READWRITE, &old_prot);
VirtualProtect (teb->DeallocationStack, wrapper_arg.guardsize,
PAGE_NOACCESS, &old_prot);
teb->Tib.StackLimit = (PVOID) ((PBYTE) teb->DeallocationStack
+ wrapper_arg.guardsize);
}
wrapper_arg.func (wrapper_arg.arg);
}
else
{
/* The tricky case: Application-provided stack. */
/* Remove _cygtls from this stack since it won't be used anymore. */ /* Remove _cygtls from this stack since it won't be used anymore. */
_my_tls.remove (0); _my_tls.remove (0);
/* Set stack values in TEB */ /* Set stack values in TEB */
PTEB teb = NtCurrentTeb ();
teb->Tib.StackBase = wrapper_arg.stackbase; teb->Tib.StackBase = wrapper_arg.stackbase;
teb->Tib.StackLimit = wrapper_arg.commitaddr ?: wrapper_arg.stackaddr; teb->Tib.StackLimit = wrapper_arg.stackaddr;
/* Set DeallocationStack value. If we have an application-provided stack, /* Set DeallocationStack value. If we have an application-provided
we set DeallocationStack to NULL, so NtTerminateThread does not deallocate stack, we set DeallocationStack to NULL, so NtTerminateThread does
any stack. If we created the stack in CygwinCreateThread, we set not deallocate any stack. Store the OS-provided DeallocationStack
DeallocationStack to the stackaddr of our own stack, so it's automatically address in wrapper_arg.stackaddr. The below assembler code will
deallocated when the thread is terminated. */ release the OS stack after switching to our new stack. */
char *dealloc_addr = (char *) teb->DeallocationStack; wrapper_arg.stackaddr = (PBYTE) teb->DeallocationStack;
teb->DeallocationStack = wrapper_arg.commitaddr ? wrapper_arg.stackaddr teb->DeallocationStack = NULL;
: NULL;
/* Store the OS-provided DeallocationStack address in wrapper_arg.stackaddr.
The below assembler code will release the OS stack after switching to our
new stack. */
wrapper_arg.stackaddr = dealloc_addr;
/* Initialize new _cygtls. */ /* Initialize new _cygtls. */
_my_tls.init_thread (wrapper_arg.stackbase - CYGTLS_PADSIZE, _my_tls.init_thread (wrapper_arg.stackbase - CYGTLS_PADSIZE,
@ -545,6 +578,7 @@ thread_wrapper (VOID *arg)
call *%%eax # Call thread func \n" call *%%eax # Call thread func \n"
: : [WRAPPER_ARG] "r" (&wrapper_arg), : : [WRAPPER_ARG] "r" (&wrapper_arg),
[CYGTLS] "i" (CYGTLS_PADSIZE)); [CYGTLS] "i" (CYGTLS_PADSIZE));
}
/* Never return from here. */ /* Never return from here. */
ExitThread (0); ExitThread (0);
} }
@ -554,11 +588,9 @@ CygwinCreateThread (LPTHREAD_START_ROUTINE thread_func, PVOID thread_arg,
PVOID stackaddr, ULONG stacksize, ULONG guardsize, PVOID stackaddr, ULONG stacksize, ULONG guardsize,
DWORD creation_flags, LPDWORD thread_id) DWORD creation_flags, LPDWORD thread_id)
{ {
PVOID real_stackaddr = NULL;
ULONG real_stacksize = 0; ULONG real_stacksize = 0;
ULONG real_guardsize = 0; ULONG real_guardsize = 0;
thread_wrapper_arg *wrapper_arg; thread_wrapper_arg *wrapper_arg;
HANDLE thread = NULL;
wrapper_arg = (thread_wrapper_arg *) ccalloc (HEAP_STR, 1, wrapper_arg = (thread_wrapper_arg *) ccalloc (HEAP_STR, 1,
sizeof *wrapper_arg); sizeof *wrapper_arg);
@ -573,14 +605,12 @@ CygwinCreateThread (LPTHREAD_START_ROUTINE thread_func, PVOID thread_arg,
if (stackaddr) if (stackaddr)
{ {
/* If the application provided the stack, just use it. */ /* If the application provided the stack, just use it. */
wrapper_arg->stackaddr = (char *) stackaddr; wrapper_arg->stackaddr = (PBYTE) stackaddr;
wrapper_arg->stackbase = (char *) stackaddr + stacksize; wrapper_arg->stackbase = (PBYTE) stackaddr + stacksize;
} }
else else
{ {
char *commitaddr; /* If not, we let CreateThread reserve the stack. */
/* If not, we have to create the stack here. */
real_stacksize = roundup2 (stacksize, wincap.page_size ()); real_stacksize = roundup2 (stacksize, wincap.page_size ());
real_guardsize = roundup2 (guardsize, wincap.page_size ()); real_guardsize = roundup2 (guardsize, wincap.page_size ());
/* Add the guardsize to the stacksize */ /* Add the guardsize to the stacksize */
@ -592,76 +622,17 @@ CygwinCreateThread (LPTHREAD_START_ROUTINE thread_func, PVOID thread_arg,
/* Now roundup the result to the next allocation boundary. */ /* Now roundup the result to the next allocation boundary. */
real_stacksize = roundup2 (real_stacksize, real_stacksize = roundup2 (real_stacksize,
wincap.allocation_granularity ()); wincap.allocation_granularity ());
/* Reserve stack. wrapper_arg->guardsize = real_guardsize;
FIXME? If the TOP_DOWN method tends to collide too much with
other stuff, we should provide our own mechanism to find a
suitable place for the stack. Top down from the start of
the Cygwin DLL comes to mind. */
real_stackaddr = VirtualAlloc (NULL, real_stacksize,
MEM_RESERVE | MEM_TOP_DOWN,
PAGE_READWRITE);
if (!real_stackaddr)
return NULL;
/* Set up committed region. Two cases: */
if (real_guardsize != wincap.page_size ())
{
/* If guardsize is set to something other than the page size, we
commit the entire stack and, if guardsize is > 0, we set up a
POSIX guardpage. We don't set up a Windows guardpage. */
if (!VirtualAlloc (real_stackaddr, real_guardsize, MEM_COMMIT,
PAGE_NOACCESS))
goto err;
commitaddr = (char *) real_stackaddr + real_guardsize;
if (!VirtualAlloc (commitaddr, real_stacksize - real_guardsize,
MEM_COMMIT, PAGE_READWRITE))
goto err;
} }
else /* Use the STACK_SIZE_PARAM_IS_A_RESERVATION parameter. This doesn't
{ work on Windows 2000, but either we deallocate the OS stack in
/* If guardsize is exactly the page_size, we can assume that the thread_wrapper anyway, or the reservation is rounded to the next Meg.
application will behave Windows conformant in terms of stack usage. Nothing to worry about.
We can especially assume that it never allocates more than one Note that we reserve a 256K stack as minimum size, not 64K, otherwise
page at a time (alloca/_chkstk). Therefore, this is the default the thread creation might crash the process due to a stack overflow. */
case which allows a Windows compatible stack setup with a return CreateThread (&sec_none_nih, stackaddr ? 4 * PTHREAD_STACK_MIN
reserved region, a guard page, and a commited region. We don't : real_stacksize,
need to set up a POSIX guardpage since Windows already handles
stack overflow: Trying to extend the stack into the last three
pages of the stack results in a SEGV.
We always commit 64K here, starting with the guardpage. */
commitaddr = (char *) real_stackaddr + real_stacksize
- wincap.allocation_granularity ();
if (!VirtualAlloc (commitaddr, wincap.page_size (), MEM_COMMIT,
PAGE_READWRITE | PAGE_GUARD))
goto err;
commitaddr += wincap.page_size ();
if (!VirtualAlloc (commitaddr, wincap.allocation_granularity ()
- wincap.page_size (), MEM_COMMIT,
PAGE_READWRITE))
goto err;
}
wrapper_arg->stackaddr = (char *) real_stackaddr;
wrapper_arg->stackbase = (char *) real_stackaddr + real_stacksize;
wrapper_arg->commitaddr = commitaddr;
}
/* Use the STACK_SIZE_PARAM_IS_A_RESERVATION parameter so only the
minimum size for a thread stack is reserved by the OS. This doesn't
work on Windows 2000, but we deallocate the OS stack in thread_wrapper
anyway, so this should be a problem only in a tight memory condition.
Note that we reserve a 256K stack, not 64K, otherwise the thread creation
might crash the process due to a stack overflow. */
thread = CreateThread (&sec_none_nih, 4 * PTHREAD_STACK_MIN,
thread_wrapper, wrapper_arg, thread_wrapper, wrapper_arg,
creation_flags | STACK_SIZE_PARAM_IS_A_RESERVATION, creation_flags | STACK_SIZE_PARAM_IS_A_RESERVATION,
thread_id); thread_id);
err:
if (!thread && real_stackaddr)
{
/* Don't report the wrong error even though VirtualFree is very unlikely
to fail. */
DWORD err = GetLastError ();
VirtualFree (real_stackaddr, 0, MEM_RELEASE);
SetLastError (err);
}
return thread;
} }