kernel32: Add support for loading stand-alone 16-bit modules.
[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
38 struct fiber_data
39 {
40     LPVOID                param;             /* 00 fiber param */
41     void                 *except;            /* 04 saved exception handlers list */
42     void                 *stack_base;        /* 08 top of fiber stack */
43     void                 *stack_limit;       /* 0c fiber stack low-water mark */
44     void                 *stack_allocation;  /* 10 base of the fiber stack allocation */
45     sigjmp_buf            jmpbuf;            /* 14 setjmp buffer (on Windows: CONTEXT) */
46     DWORD                 flags;             /*    fiber flags */
47     LPFIBER_START_ROUTINE start;             /*    start routine */
48     void                **fls_slots;         /*    fiber storage slots */
49 };
50
51
52 /* call the fiber initial function once we have switched stack */
53 static void start_fiber( void *arg )
54 {
55     struct fiber_data *fiber = arg;
56     LPFIBER_START_ROUTINE start = fiber->start;
57
58     __TRY
59     {
60         fiber->start = NULL;
61         start( fiber->param );
62         ExitThread( 1 );
63     }
64     __EXCEPT(UnhandledExceptionFilter)
65     {
66         TerminateThread( GetCurrentThread(), GetExceptionCode() );
67     }
68     __ENDTRY
69 }
70
71
72 /***********************************************************************
73  *           CreateFiber   (KERNEL32.@)
74  */
75 LPVOID WINAPI CreateFiber( SIZE_T stack, LPFIBER_START_ROUTINE start, LPVOID param )
76 {
77     return CreateFiberEx( stack, 0, 0, start, param );
78 }
79
80
81 /***********************************************************************
82  *           CreateFiberEx   (KERNEL32.@)
83  */
84 LPVOID WINAPI CreateFiberEx( SIZE_T stack_commit, SIZE_T stack_reserve, DWORD flags,
85                              LPFIBER_START_ROUTINE start, LPVOID param )
86 {
87     struct fiber_data *fiber;
88
89     if (!(fiber = HeapAlloc( GetProcessHeap(), 0, sizeof(*fiber) )))
90     {
91         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
92         return NULL;
93     }
94
95     /* FIXME: should use the thread stack allocation routines here */
96     if (!stack_reserve) stack_reserve = 1024*1024;
97     if(!(fiber->stack_allocation = VirtualAlloc( 0, stack_reserve, MEM_COMMIT, PAGE_READWRITE )))
98     {
99         HeapFree( GetProcessHeap(), 0, fiber );
100         return NULL;
101     }
102     fiber->stack_base  = (char *)fiber->stack_allocation + stack_reserve;
103     fiber->stack_limit = fiber->stack_allocation;
104     fiber->param       = param;
105     fiber->except      = (void *)-1;
106     fiber->start       = start;
107     fiber->flags       = flags;
108     fiber->fls_slots   = NULL;
109     return fiber;
110 }
111
112
113 /***********************************************************************
114  *           DeleteFiber   (KERNEL32.@)
115  */
116 void WINAPI DeleteFiber( LPVOID fiber_ptr )
117 {
118     struct fiber_data *fiber = fiber_ptr;
119
120     if (!fiber) return;
121     if (fiber == NtCurrentTeb()->Tib.u.FiberData)
122     {
123         HeapFree( GetProcessHeap(), 0, fiber );
124         ExitThread(1);
125     }
126     VirtualFree( fiber->stack_allocation, 0, MEM_RELEASE );
127     HeapFree( GetProcessHeap(), 0, fiber->fls_slots );
128     HeapFree( GetProcessHeap(), 0, fiber );
129 }
130
131
132 /***********************************************************************
133  *           ConvertThreadToFiber   (KERNEL32.@)
134  */
135 LPVOID WINAPI ConvertThreadToFiber( LPVOID param )
136 {
137     return ConvertThreadToFiberEx( param, 0 );
138 }
139
140
141 /***********************************************************************
142  *           ConvertThreadToFiberEx   (KERNEL32.@)
143  */
144 LPVOID WINAPI ConvertThreadToFiberEx( LPVOID param, DWORD flags )
145 {
146     struct fiber_data *fiber;
147
148     if (!(fiber = HeapAlloc( GetProcessHeap(), 0, sizeof(*fiber) )))
149     {
150         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
151         return NULL;
152     }
153     fiber->param            = param;
154     fiber->except           = NtCurrentTeb()->Tib.ExceptionList;
155     fiber->stack_base       = NtCurrentTeb()->Tib.StackBase;
156     fiber->stack_limit      = NtCurrentTeb()->Tib.StackLimit;
157     fiber->stack_allocation = NtCurrentTeb()->DeallocationStack;
158     fiber->start            = NULL;
159     fiber->flags            = flags;
160     fiber->fls_slots        = NtCurrentTeb()->FlsSlots;
161     NtCurrentTeb()->Tib.u.FiberData = fiber;
162     return fiber;
163 }
164
165
166 /***********************************************************************
167  *           ConvertFiberToThread   (KERNEL32.@)
168  */
169 BOOL WINAPI ConvertFiberToThread(void)
170 {
171     struct fiber_data *fiber = NtCurrentTeb()->Tib.u.FiberData;
172
173     if (fiber)
174     {
175         NtCurrentTeb()->Tib.u.FiberData = NULL;
176         HeapFree( GetProcessHeap(), 0, fiber );
177     }
178     return TRUE;
179 }
180
181
182 /***********************************************************************
183  *           SwitchToFiber   (KERNEL32.@)
184  */
185 void WINAPI SwitchToFiber( LPVOID fiber )
186 {
187     struct fiber_data *new_fiber = fiber;
188     struct fiber_data *current_fiber = NtCurrentTeb()->Tib.u.FiberData;
189
190     current_fiber->except      = NtCurrentTeb()->Tib.ExceptionList;
191     current_fiber->stack_limit = NtCurrentTeb()->Tib.StackLimit;
192     current_fiber->fls_slots   = NtCurrentTeb()->FlsSlots;
193     /* stack_allocation and stack_base never change */
194
195     /* FIXME: should save floating point context if requested in fiber->flags */
196     if (!sigsetjmp( current_fiber->jmpbuf, 0 ))
197     {
198         NtCurrentTeb()->Tib.u.FiberData   = new_fiber;
199         NtCurrentTeb()->Tib.ExceptionList = new_fiber->except;
200         NtCurrentTeb()->Tib.StackBase     = new_fiber->stack_base;
201         NtCurrentTeb()->Tib.StackLimit    = new_fiber->stack_limit;
202         NtCurrentTeb()->DeallocationStack = new_fiber->stack_allocation;
203         NtCurrentTeb()->FlsSlots          = new_fiber->fls_slots;
204         if (new_fiber->start)  /* first time */
205             wine_switch_to_stack( start_fiber, new_fiber, new_fiber->stack_base );
206         else
207             siglongjmp( new_fiber->jmpbuf, 1 );
208     }
209 }
210
211 /***********************************************************************
212  *           FlsAlloc   (KERNEL32.@)
213  */
214 DWORD WINAPI FlsAlloc( PFLS_CALLBACK_FUNCTION callback )
215 {
216     DWORD index;
217     PEB * const peb = NtCurrentTeb()->Peb;
218
219     RtlAcquirePebLock();
220     if (!peb->FlsCallback &&
221         !(peb->FlsCallback = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
222                                         8 * sizeof(peb->FlsBitmapBits) * sizeof(void*) )))
223     {
224         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
225         index = FLS_OUT_OF_INDEXES;
226     }
227     else
228     {
229         index = RtlFindClearBitsAndSet( peb->FlsBitmap, 1, 0 );
230         if (index != ~0U)
231         {
232             if (!NtCurrentTeb()->FlsSlots &&
233                 !(NtCurrentTeb()->FlsSlots = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
234                                                         8 * sizeof(peb->FlsBitmapBits) * sizeof(void*) )))
235             {
236                 RtlClearBits( peb->FlsBitmap, index, 1 );
237                 index = FLS_OUT_OF_INDEXES;
238                 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
239             }
240             else
241             {
242                 NtCurrentTeb()->FlsSlots[index] = 0; /* clear the value */
243                 peb->FlsCallback[index] = callback;
244             }
245         }
246         else SetLastError( ERROR_NO_MORE_ITEMS );
247     }
248     RtlReleasePebLock();
249     return index;
250 }
251
252 /***********************************************************************
253  *           FlsFree   (KERNEL32.@)
254  */
255 BOOL WINAPI FlsFree( DWORD index )
256 {
257     BOOL ret;
258
259     RtlAcquirePebLock();
260     ret = RtlAreBitsSet( NtCurrentTeb()->Peb->FlsBitmap, index, 1 );
261     if (ret) RtlClearBits( NtCurrentTeb()->Peb->FlsBitmap, index, 1 );
262     if (ret)
263     {
264         /* FIXME: call Fls callback */
265         /* FIXME: add equivalent of ThreadZeroTlsCell here */
266         if (NtCurrentTeb()->FlsSlots) NtCurrentTeb()->FlsSlots[index] = 0;
267     }
268     else SetLastError( ERROR_INVALID_PARAMETER );
269     RtlReleasePebLock();
270     return TRUE;
271 }
272
273 /***********************************************************************
274  *           FlsGetValue   (KERNEL32.@)
275  */
276 PVOID WINAPI FlsGetValue( DWORD index )
277 {
278     if (index >= 8 * sizeof(NtCurrentTeb()->Peb->FlsBitmapBits) || !NtCurrentTeb()->FlsSlots)
279     {
280         SetLastError( ERROR_INVALID_PARAMETER );
281         return NULL;
282     }
283     SetLastError( ERROR_SUCCESS );
284     return NtCurrentTeb()->FlsSlots[index];
285 }
286
287 /***********************************************************************
288  *           FlsSetValue   (KERNEL32.@)
289  */
290 BOOL WINAPI FlsSetValue( DWORD index, PVOID data )
291 {
292     if (index >= 8 * sizeof(NtCurrentTeb()->Peb->FlsBitmapBits))
293     {
294         SetLastError( ERROR_INVALID_PARAMETER );
295         return FALSE;
296     }
297     if (!NtCurrentTeb()->FlsSlots &&
298         !(NtCurrentTeb()->FlsSlots = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
299                                         8 * sizeof(NtCurrentTeb()->Peb->FlsBitmapBits) * sizeof(void*) )))
300     {
301         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
302         return FALSE;
303     }
304     NtCurrentTeb()->FlsSlots[index] = data;
305     return TRUE;
306 }