git.oblomov.eu Git - wine/blob - dlls/kernel/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 "winreg.h"
  35 #include "winternl.h"
  36 #include "wine/exception.h"
  37 #include "wine/library.h"
  38
  39 struct fiber_data
  40 {
  41     LPVOID                param;             /* 00 fiber param */
  42     void                 *except;            /* 04 saved exception handlers list */
  43     void                 *stack_base;        /* 08 top of fiber stack */
  44     void                 *stack_limit;       /* 0c fiber stack low-water mark */
  45     void                 *stack_allocation;  /* 10 base of the fiber stack allocation */
  46     sigjmp_buf            jmpbuf;            /* 14 setjmp buffer (on Windows: CONTEXT) */
  47     DWORD                 flags;             /*    fiber flags */
  48     LPFIBER_START_ROUTINE start;             /*    start routine */
  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_EXECUTE_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     return fiber;
 109 }
 110
 111
 112 /***********************************************************************
 113  *           DeleteFiber   (KERNEL32.@)
 114  */
 115 void WINAPI DeleteFiber( LPVOID fiber_ptr )
 116 {
 117     struct fiber_data *fiber = fiber_ptr;
 118
 119     if (!fiber) return;
 120     if (fiber == NtCurrentTeb()->Tib.u.FiberData)
 121     {
 122         HeapFree( GetProcessHeap(), 0, fiber );
 123         ExitThread(1);
 124     }
 125     VirtualFree( fiber->stack_allocation, 0, MEM_RELEASE );
 126     HeapFree( GetProcessHeap(), 0, fiber );
 127 }
 128
 129
 130 /***********************************************************************
 131  *           ConvertThreadToFiber   (KERNEL32.@)
 132  */
 133 LPVOID WINAPI ConvertThreadToFiber( LPVOID param )
 134 {
 135     return ConvertThreadToFiberEx( param, 0 );
 136 }
 137
 138
 139 /***********************************************************************
 140  *           ConvertThreadToFiberEx   (KERNEL32.@)
 141  */
 142 LPVOID WINAPI ConvertThreadToFiberEx( LPVOID param, DWORD flags )
 143 {
 144     struct fiber_data *fiber;
 145
 146     if (!(fiber = HeapAlloc( GetProcessHeap(), 0, sizeof(*fiber) )))
 147     {
 148         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 149         return NULL;
 150     }
 151     fiber->param            = param;
 152     fiber->except           = NtCurrentTeb()->Tib.ExceptionList;
 153     fiber->stack_base       = NtCurrentTeb()->Tib.StackBase;
 154     fiber->stack_limit      = NtCurrentTeb()->Tib.StackLimit;
 155     fiber->stack_allocation = NtCurrentTeb()->DeallocationStack;
 156     fiber->start            = NULL;
 157     fiber->flags            = flags;
 158     NtCurrentTeb()->Tib.u.FiberData = fiber;
 159     return fiber;
 160 }
 161
 162
 163 /***********************************************************************
 164  *           ConvertFiberToThread   (KERNEL32.@)
 165  */
 166 BOOL WINAPI ConvertFiberToThread(void)
 167 {
 168     struct fiber_data *fiber = NtCurrentTeb()->Tib.u.FiberData;
 169
 170     if (fiber)
 171     {
 172         NtCurrentTeb()->Tib.u.FiberData = NULL;
 173         HeapFree( GetProcessHeap(), 0, fiber );
 174     }
 175     return TRUE;
 176 }
 177
 178
 179 /***********************************************************************
 180  *           SwitchToFiber   (KERNEL32.@)
 181  */
 182 void WINAPI SwitchToFiber( LPVOID fiber )
 183 {
 184     struct fiber_data *new_fiber = fiber;
 185     struct fiber_data *current_fiber = NtCurrentTeb()->Tib.u.FiberData;
 186
 187     current_fiber->except      = NtCurrentTeb()->Tib.ExceptionList;
 188     current_fiber->stack_limit = NtCurrentTeb()->Tib.StackLimit;
 189     /* stack_allocation and stack_base never change */
 190
 191     /* FIXME: should save floating point context if requested in fiber->flags */
 192     if (!sigsetjmp( current_fiber->jmpbuf, 1 ))
 193     {
 194         NtCurrentTeb()->Tib.u.FiberData   = new_fiber;
 195         NtCurrentTeb()->Tib.ExceptionList = new_fiber->except;
 196         NtCurrentTeb()->Tib.StackBase     = new_fiber->stack_base;
 197         NtCurrentTeb()->Tib.StackLimit    = new_fiber->stack_limit;
 198         NtCurrentTeb()->DeallocationStack = new_fiber->stack_allocation;
 199         if (new_fiber->start)  /* first time */
 200             wine_switch_to_stack( start_fiber, new_fiber, new_fiber->stack_base );
 201         else
 202             siglongjmp( new_fiber->jmpbuf, 1 );
 203     }
 204 }