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 }
310
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.