scheduler/syslevel.c

   1 /*
   2  * Win32 'syslevel' routines
   3  *
   4  * Copyright 1998 Ulrich Weigand
   5  */
   6
   7 #include <unistd.h>
   8 #include "syslevel.h"
   9 #include "heap.h"
  10 #include "stackframe.h"
  11 #include "debug.h"
  12
  13 DEFAULT_DEBUG_CHANNEL(win32)
  14
  15 static CRITICAL_SECTION Win16Mutex;
  16 static SEGPTR segpWin16Mutex;
  17
  18 /* Global variable to save current TEB while in 16-bit code */
  19 WORD SYSLEVEL_Win16CurrentTeb = 0;
  20
  21 /* TEB of initial process for emergency use */
  22 WORD SYSLEVEL_EmergencyTeb = 0;
  23
  24
  25 /************************************************************************
  26  *           SYSLEVEL_Init
  27  */
  28 void SYSLEVEL_Init(void)
  29 {
  30     CRITICAL_SECTION **w16Mutex = SEGPTR_ALLOC(sizeof(CRITICAL_SECTION *));
  31
  32     *w16Mutex = &Win16Mutex;
  33     segpWin16Mutex = SEGPTR_GET(w16Mutex);
  34
  35     InitializeCriticalSection(&Win16Mutex);
  36     MakeCriticalSectionGlobal(&Win16Mutex);
  37 }
  38
  39 /************************************************************************
  40  *           GetpWin16Lock32    (KERNEL32.93)
  41  */
  42 VOID WINAPI GetpWin16Lock(CRITICAL_SECTION **lock)
  43 {
  44     *lock = &Win16Mutex;
  45 }
  46
  47 /************************************************************************
  48  *           GetpWin16Lock16    (KERNEL.449)
  49  */
  50 SEGPTR WINAPI GetpWin16Lock16(void)
  51 {
  52     return segpWin16Mutex;
  53 }
  54
  55 /************************************************************************
  56  *           _EnterSysLevel    (KERNEL32.97)
  57  */
  58 VOID WINAPI _EnterSysLevel(CRITICAL_SECTION *lock)
  59 {
  60     EnterCriticalSection(lock);
  61
  62     if (lock == &Win16Mutex)
  63         GET_FS( SYSLEVEL_Win16CurrentTeb );
  64 }
  65
  66 /************************************************************************
  67  *           _LeaveSysLevel    (KERNEL32.98)
  68  */
  69 VOID WINAPI _LeaveSysLevel(CRITICAL_SECTION *lock)
  70 {
  71     LeaveCriticalSection(lock);
  72 }
  73
  74 /************************************************************************
  75  *           (KERNEL32.86)
  76  */
  77 VOID WINAPI _KERNEL32_86(CRITICAL_SECTION *lock)
  78 {
  79     _LeaveSysLevel(lock);
  80 }
  81
  82 /************************************************************************
  83  *           SYSLEVEL_EnterWin16Lock                    [KERNEL.480]
  84  */
  85 VOID WINAPI SYSLEVEL_EnterWin16Lock(VOID)
  86 {
  87     TRACE(win32, "thread %04x (pid %d) about to enter\n",
  88           THREAD_Current()->teb_sel, getpid());
  89
  90     _EnterSysLevel(&Win16Mutex);
  91
  92     TRACE(win32, "thread %04x (pid %d) entered, count is %ld\n",
  93           THREAD_Current()->teb_sel, getpid(), Win16Mutex.RecursionCount);
  94 }
  95
  96 /************************************************************************
  97  *           SYSLEVEL_LeaveWin16Lock            [KERNEL.481]
  98  */
  99 VOID WINAPI SYSLEVEL_LeaveWin16Lock(VOID)
 100 {
 101     TRACE(win32, "thread %04x (pid %d) about to leave, count is %ld\n",
 102           THREAD_Current()->teb_sel, getpid(), Win16Mutex.RecursionCount);
 103
 104     _LeaveSysLevel(&Win16Mutex);
 105 }
 106
 107 /************************************************************************
 108  *           _CheckNotSysLevel    (KERNEL32.94)
 109  */
 110 VOID WINAPI _CheckNotSysLevel(CRITICAL_SECTION *lock)
 111 {
 112     FIXME(win32, "()\n");
 113 }
 114
 115 /************************************************************************
 116  *           _ConfirmSysLevel    (KERNEL32.95)
 117  */
 118 VOID WINAPI _ConfirmSysLevel(CRITICAL_SECTION *lock)
 119 {
 120     FIXME(win32, "()\n");
 121 }
 122
 123 /************************************************************************
 124  *           _ConfirmWin16Lock    (KERNEL32.96)
 125  */
 126 DWORD WINAPI _ConfirmWin16Lock(void)
 127 {
 128     if ( Win16Mutex.OwningThread == GetCurrentThreadId() )
 129         return Win16Mutex.RecursionCount;
 130     else
 131         return 0L;
 132 }
 133
 134 /************************************************************************
 135  *           ReleaseThunkLock    (KERNEL32.48)
 136  */
 137 VOID WINAPI ReleaseThunkLock(DWORD *mutex_count)
 138 {
 139     DWORD count = Win16Mutex.RecursionCount;
 140     *mutex_count = count;
 141
 142     while (count-- > 0)
 143         _LeaveSysLevel(&Win16Mutex);
 144 }
 145
 146 /************************************************************************
 147  *           RestoreThunkLock    (KERNEL32.49)
 148  */
 149 VOID WINAPI RestoreThunkLock(DWORD mutex_count)
 150 {
 151     while (mutex_count-- > 0)
 152         _EnterSysLevel(&Win16Mutex);
 153 }
 154
 155 /************************************************************************
 156  *           SYSLEVEL_ReleaseWin16Lock
 157  */
 158 VOID SYSLEVEL_ReleaseWin16Lock(VOID)
 159 {
 160     DWORD count;
 161
 162     TRACE(win32, "thread %04x (pid %d) about to release, count is %ld\n",
 163           THREAD_Current()->teb_sel, getpid(), Win16Mutex.RecursionCount);
 164
 165     ReleaseThunkLock(&count);
 166
 167     if (count > 0xffff)
 168         ERR(win32, "Win16Mutex recursion count too large!\n");
 169
 170     CURRENT_STACK16->mutex_count = (WORD)count;
 171 }
 172
 173 /************************************************************************
 174  *           SYSLEVEL_RestoreWin16Lock
 175  */
 176 VOID SYSLEVEL_RestoreWin16Lock(VOID)
 177 {
 178     DWORD count = CURRENT_STACK16->mutex_count;
 179
 180     if (!count)
 181         ERR(win32, "Win16Mutex recursion count is zero!\n");
 182
 183     TRACE(win32, "thread %04x (pid %d) about to restore (count %ld)\n",
 184           THREAD_Current()->teb_sel, getpid(), count);
 185
 186     RestoreThunkLock(count);
 187
 188     TRACE(win32, "thread %04x (pid %d) restored lock, count is %ld\n",
 189           THREAD_Current()->teb_sel, getpid(), Win16Mutex.RecursionCount);
 190 }
 191