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 "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 };
  49
  50
  51 /* call the fiber initial function once we have switched stack */
  52 static void start_fiber( void *arg )
  53 {
  54     struct fiber_data *fiber = arg;
  55     LPFIBER_START_ROUTINE start = fiber->start;
  56
  57     __TRY
  58     {
  59         fiber->start = NULL;
  60         start( fiber->param );
  61         ExitThread( 1 );
  62     }
  63     __EXCEPT(UnhandledExceptionFilter)
  64     {
  65         TerminateThread( GetCurrentThread(), GetExceptionCode() );
  66     }
  67     __ENDTRY
  68 }
  69
  70
  71 /***********************************************************************
  72  *           CreateFiber   (KERNEL32.@)
  73  */
  74 LPVOID WINAPI CreateFiber( SIZE_T stack, LPFIBER_START_ROUTINE start, LPVOID param )
  75 {
  76     return CreateFiberEx( stack, 0, 0, start, param );
  77 }
  78
  79
  80 /***********************************************************************
  81  *           CreateFiberEx   (KERNEL32.@)
  82  */
  83 LPVOID WINAPI CreateFiberEx( SIZE_T stack_commit, SIZE_T stack_reserve, DWORD flags,
  84                              LPFIBER_START_ROUTINE start, LPVOID param )
  85 {
  86     struct fiber_data *fiber;
  87
  88     if (!(fiber = HeapAlloc( GetProcessHeap(), 0, sizeof(*fiber) )))
  89     {
  90         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
  91         return NULL;
  92     }
  93
  94     /* FIXME: should use the thread stack allocation routines here */
  95     if (!stack_reserve) stack_reserve = 1024*1024;
  96     if(!(fiber->stack_allocation = VirtualAlloc( 0, stack_reserve, MEM_COMMIT, PAGE_READWRITE )))
  97     {
  98         HeapFree( GetProcessHeap(), 0, fiber );
  99         return NULL;
 100     }
 101     fiber->stack_base  = (char *)fiber->stack_allocation + stack_reserve;
 102     fiber->stack_limit = fiber->stack_allocation;
 103     fiber->param       = param;
 104     fiber->except      = (void *)-1;
 105     fiber->start       = start;
 106     fiber->flags       = flags;
 107     return fiber;
 108 }
 109
 110
 111 /***********************************************************************
 112  *           DeleteFiber   (KERNEL32.@)
 113  */
 114 void WINAPI DeleteFiber( LPVOID fiber_ptr )
 115 {
 116     struct fiber_data *fiber = fiber_ptr;
 117
 118     if (!fiber) return;
 119     if (fiber == NtCurrentTeb()->Tib.u.FiberData)
 120     {
 121         HeapFree( GetProcessHeap(), 0, fiber );
 122         ExitThread(1);
 123     }
 124     VirtualFree( fiber->stack_allocation, 0, MEM_RELEASE );
 125     HeapFree( GetProcessHeap(), 0, fiber );
 126 }
 127
 128
 129 /***********************************************************************
 130  *           ConvertThreadToFiber   (KERNEL32.@)
 131  */
 132 LPVOID WINAPI ConvertThreadToFiber( LPVOID param )
 133 {
 134     return ConvertThreadToFiberEx( param, 0 );
 135 }
 136
 137
 138 /***********************************************************************
 139  *           ConvertThreadToFiberEx   (KERNEL32.@)
 140  */
 141 LPVOID WINAPI ConvertThreadToFiberEx( LPVOID param, DWORD flags )
 142 {
 143     struct fiber_data *fiber;
 144
 145     if (!(fiber = HeapAlloc( GetProcessHeap(), 0, sizeof(*fiber) )))
 146     {
 147         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 148         return NULL;
 149     }
 150     fiber->param            = param;
 151     fiber->except           = NtCurrentTeb()->Tib.ExceptionList;
 152     fiber->stack_base       = NtCurrentTeb()->Tib.StackBase;
 153     fiber->stack_limit      = NtCurrentTeb()->Tib.StackLimit;
 154     fiber->stack_allocation = NtCurrentTeb()->DeallocationStack;
 155     fiber->start            = NULL;
 156     fiber->flags            = flags;
 157     NtCurrentTeb()->Tib.u.FiberData = fiber;
 158     return fiber;
 159 }
 160
 161
 162 /***********************************************************************
 163  *           ConvertFiberToThread   (KERNEL32.@)
 164  */
 165 BOOL WINAPI ConvertFiberToThread(void)
 166 {
 167     struct fiber_data *fiber = NtCurrentTeb()->Tib.u.FiberData;
 168
 169     if (fiber)
 170     {
 171         NtCurrentTeb()->Tib.u.FiberData = NULL;
 172         HeapFree( GetProcessHeap(), 0, fiber );
 173     }
 174     return TRUE;
 175 }
 176
 177
 178 /***********************************************************************
 179  *           SwitchToFiber   (KERNEL32.@)
 180  */
 181 void WINAPI SwitchToFiber( LPVOID fiber )
 182 {
 183     struct fiber_data *new_fiber = fiber;
 184     struct fiber_data *current_fiber = NtCurrentTeb()->Tib.u.FiberData;
 185
 186     current_fiber->except      = NtCurrentTeb()->Tib.ExceptionList;
 187     current_fiber->stack_limit = NtCurrentTeb()->Tib.StackLimit;
 188     /* stack_allocation and stack_base never change */
 189
 190     /* FIXME: should save floating point context if requested in fiber->flags */
 191     if (!sigsetjmp( current_fiber->jmpbuf, 1 ))
 192     {
 193         NtCurrentTeb()->Tib.u.FiberData   = new_fiber;
 194         NtCurrentTeb()->Tib.ExceptionList = new_fiber->except;
 195         NtCurrentTeb()->Tib.StackBase     = new_fiber->stack_base;
 196         NtCurrentTeb()->Tib.StackLimit    = new_fiber->stack_limit;
 197         NtCurrentTeb()->DeallocationStack = new_fiber->stack_allocation;
 198         if (new_fiber->start)  /* first time */
 199             wine_switch_to_stack( start_fiber, new_fiber, new_fiber->stack_base );
 200         else
 201             siglongjmp( new_fiber->jmpbuf, 1 );
 202     }
 203 }