kernel32/tests: Make the toolhelp test less verbose by default.
[wine] / dlls / kernel32 / fiber.c
1 /*
2  * Fiber support
3  *
4  * Copyright 2002 Alexandre Julliard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  *
20  * FIXME:
21  * - proper handling of 16-bit stack and signal stack
22  */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <setjmp.h>
28 #include <stdarg.h>
29
30 #define NONAMELESSUNION
31 #include "windef.h"
32 #include "winbase.h"
33 #include "winerror.h"
34 #include "winternl.h"
35 #include "wine/exception.h"
36 #include "wine/library.h"
37 #include "wine/debug.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(fiber);
40
41 struct fiber_data
42 {
43     LPVOID                param;             /* 00 fiber param */
44     void                 *except;            /* 04 saved exception handlers list */
45     void                 *stack_base;        /* 08 top of fiber stack */
46     void                 *stack_limit;       /* 0c fiber stack low-water mark */
47     void                 *stack_allocation;  /* 10 base of the fiber stack allocation */
48     sigjmp_buf            jmpbuf;            /* 14 setjmp buffer (on Windows: CONTEXT) */
49     DWORD                 flags;             /*    fiber flags */
50     LPFIBER_START_ROUTINE start;             /*    start routine */
51     void                **fls_slots;         /*    fiber storage slots */
52 };
53
54
55 /* call the fiber initial function once we have switched stack */
56 static void start_fiber( void *arg )
57 {
58     struct fiber_data *fiber = arg;
59     LPFIBER_START_ROUTINE start = fiber->start;
60
61     __TRY
62     {
63         fiber->start = NULL;
64         start( fiber->param );
65         ExitThread( 1 );
66     }
67     __EXCEPT(UnhandledExceptionFilter)
68     {
69         TerminateThread( GetCurrentThread(), GetExceptionCode() );
70     }
71     __ENDTRY
72 }
73
74
75 /***********************************************************************
76  *           CreateFiber   (KERNEL32.@)
77  */
78 LPVOID WINAPI CreateFiber( SIZE_T stack, LPFIBER_START_ROUTINE start, LPVOID param )
79 {
80     return CreateFiberEx( stack, 0, 0, start, param );
81 }
82
83
84 /***********************************************************************
85  *           CreateFiberEx   (KERNEL32.@)
86  */
87 LPVOID WINAPI CreateFiberEx( SIZE_T stack_commit, SIZE_T stack_reserve, DWORD flags,
88                              LPFIBER_START_ROUTINE start, LPVOID param )
89 {
90     struct fiber_data *fiber;
91
92     if (!(fiber = HeapAlloc( GetProcessHeap(), 0, sizeof(*fiber) )))
93     {
94         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
95         return NULL;
96     }
97
98     /* FIXME: should use the thread stack allocation routines here */
99     if (!stack_reserve) stack_reserve = 1024*1024;
100     if(!(fiber->stack_allocation = VirtualAlloc( 0, stack_reserve, MEM_COMMIT, PAGE_READWRITE )))
101     {
102         HeapFree( GetProcessHeap(), 0, fiber );
103         return NULL;
104     }
105     fiber->stack_base  = (char *)fiber->stack_allocation + stack_reserve;
106     fiber->stack_limit = fiber->stack_allocation;
107     fiber->param       = param;
108     fiber->except      = (void *)-1;
109     fiber->start       = start;
110     fiber->flags       = flags;
111     fiber->fls_slots   = NULL;
112     return fiber;
113 }
114
115
116 /***********************************************************************
117  *           DeleteFiber   (KERNEL32.@)
118  */
119 void WINAPI DeleteFiber( LPVOID fiber_ptr )
120 {
121     struct fiber_data *fiber = fiber_ptr;
122
123     if (!fiber) return;
124     if (fiber == NtCurrentTeb()->Tib.u.FiberData)
125     {
126         HeapFree( GetProcessHeap(), 0, fiber );
127         ExitThread(1);
128     }
129     VirtualFree( fiber->stack_allocation, 0, MEM_RELEASE );
130     HeapFree( GetProcessHeap(), 0, fiber->fls_slots );
131     HeapFree( GetProcessHeap(), 0, fiber );
132 }
133
134
135 /***********************************************************************
136  *           ConvertThreadToFiber   (KERNEL32.@)
137  */
138 LPVOID WINAPI ConvertThreadToFiber( LPVOID param )
139 {
140     return ConvertThreadToFiberEx( param, 0 );
141 }
142
143
144 /***********************************************************************
145  *           ConvertThreadToFiberEx   (KERNEL32.@)
146  */
147 LPVOID WINAPI ConvertThreadToFiberEx( LPVOID param, DWORD flags )
148 {
149     struct fiber_data *fiber;
150
151     if (!(fiber = HeapAlloc( GetProcessHeap(), 0, sizeof(*fiber) )))
152     {
153         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
154         return NULL;
155     }
156     fiber->param            = param;
157     fiber->except           = NtCurrentTeb()->Tib.ExceptionList;
158     fiber->stack_base       = NtCurrentTeb()->Tib.StackBase;
159     fiber->stack_limit      = NtCurrentTeb()->Tib.StackLimit;
160     fiber->stack_allocation = NtCurrentTeb()->DeallocationStack;
161     fiber->start            = NULL;
162     fiber->flags            = flags;
163     fiber->fls_slots        = NtCurrentTeb()->FlsSlots;
164     NtCurrentTeb()->Tib.u.FiberData = fiber;
165     return fiber;
166 }
167
168
169 /***********************************************************************
170  *           ConvertFiberToThread   (KERNEL32.@)
171  */
172 BOOL WINAPI ConvertFiberToThread(void)
173 {
174     struct fiber_data *fiber = NtCurrentTeb()->Tib.u.FiberData;
175
176     if (fiber)
177     {
178         NtCurrentTeb()->Tib.u.FiberData = NULL;
179         HeapFree( GetProcessHeap(), 0, fiber );
180     }
181     return TRUE;
182 }
183
184
185 /***********************************************************************
186  *           SwitchToFiber   (KERNEL32.@)
187  */
188 void WINAPI SwitchToFiber( LPVOID fiber )
189 {
190     struct fiber_data *new_fiber = fiber;
191     struct fiber_data *current_fiber = NtCurrentTeb()->Tib.u.FiberData;
192
193     current_fiber->except      = NtCurrentTeb()->Tib.ExceptionList;
194     current_fiber->stack_limit = NtCurrentTeb()->Tib.StackLimit;
195     current_fiber->fls_slots   = NtCurrentTeb()->FlsSlots;
196     /* stack_allocation and stack_base never change */
197
198     /* FIXME: should save floating point context if requested in fiber->flags */
199     if (!sigsetjmp( current_fiber->jmpbuf, 0 ))
200     {
201         NtCurrentTeb()->Tib.u.FiberData   = new_fiber;
202         NtCurrentTeb()->Tib.ExceptionList = new_fiber->except;
203         NtCurrentTeb()->Tib.StackBase     = new_fiber->stack_base;
204         NtCurrentTeb()->Tib.StackLimit    = new_fiber->stack_limit;
205         NtCurrentTeb()->DeallocationStack = new_fiber->stack_allocation;
206         NtCurrentTeb()->FlsSlots          = new_fiber->fls_slots;
207         if (new_fiber->start)  /* first time */
208             wine_switch_to_stack( start_fiber, new_fiber, new_fiber->stack_base );
209         else
210             siglongjmp( new_fiber->jmpbuf, 1 );
211     }
212 }
213
214 /***********************************************************************
215  *           FlsAlloc   (KERNEL32.@)
216  */
217 DWORD WINAPI FlsAlloc( PFLS_CALLBACK_FUNCTION callback )
218 {
219     DWORD index;
220     PEB * const peb = NtCurrentTeb()->Peb;
221
222     RtlAcquirePebLock();
223     if (!peb->FlsCallback &&
224         !(peb->FlsCallback = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
225                                         8 * sizeof(peb->FlsBitmapBits) * sizeof(void*) )))
226     {
227         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
228         index = FLS_OUT_OF_INDEXES;
229     }
230     else
231     {
232         index = RtlFindClearBitsAndSet( peb->FlsBitmap, 1, 0 );
233         if (index != ~0U)
234         {
235             if (!NtCurrentTeb()->FlsSlots &&
236                 !(NtCurrentTeb()->FlsSlots = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
237                                                         8 * sizeof(peb->FlsBitmapBits) * sizeof(void*) )))
238             {
239                 RtlClearBits( peb->FlsBitmap, index, 1 );
240                 index = FLS_OUT_OF_INDEXES;
241                 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
242             }
243             else
244             {
245                 NtCurrentTeb()->FlsSlots[index] = 0; /* clear the value */
246                 peb->FlsCallback[index] = callback;
247             }
248         }
249         else SetLastError( ERROR_NO_MORE_ITEMS );
250     }
251     RtlReleasePebLock();
252     return index;
253 }
254
255 /***********************************************************************
256  *           FlsFree   (KERNEL32.@)
257  */
258 BOOL WINAPI FlsFree( DWORD index )
259 {
260     BOOL ret;
261
262     RtlAcquirePebLock();
263     ret = RtlAreBitsSet( NtCurrentTeb()->Peb->FlsBitmap, index, 1 );
264     if (ret) RtlClearBits( NtCurrentTeb()->Peb->FlsBitmap, index, 1 );
265     if (ret)
266     {
267         /* FIXME: call Fls callback */
268         /* FIXME: add equivalent of ThreadZeroTlsCell here */
269         if (NtCurrentTeb()->FlsSlots) NtCurrentTeb()->FlsSlots[index] = 0;
270     }
271     else SetLastError( ERROR_INVALID_PARAMETER );
272     RtlReleasePebLock();
273     return TRUE;
274 }
275
276 /***********************************************************************
277  *           FlsGetValue   (KERNEL32.@)
278  */
279 PVOID WINAPI FlsGetValue( DWORD index )
280 {
281     if (index >= 8 * sizeof(NtCurrentTeb()->Peb->FlsBitmapBits) || !NtCurrentTeb()->FlsSlots)
282     {
283         SetLastError( ERROR_INVALID_PARAMETER );
284         return NULL;
285     }
286     SetLastError( ERROR_SUCCESS );
287     return NtCurrentTeb()->FlsSlots[index];
288 }
289
290 /***********************************************************************
291  *           FlsSetValue   (KERNEL32.@)
292  */
293 BOOL WINAPI FlsSetValue( DWORD index, PVOID data )
294 {
295     if (index >= 8 * sizeof(NtCurrentTeb()->Peb->FlsBitmapBits))
296     {
297         SetLastError( ERROR_INVALID_PARAMETER );
298         return FALSE;
299     }
300     if (!NtCurrentTeb()->FlsSlots &&
301         !(NtCurrentTeb()->FlsSlots = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
302                                         8 * sizeof(NtCurrentTeb()->Peb->FlsBitmapBits) * sizeof(void*) )))
303     {
304         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
305         return FALSE;
306     }
307     NtCurrentTeb()->FlsSlots[index] = data;
308     return TRUE;
309 }