scheduler/syslevel.c

   1 /*
   2  * Win32 'syslevel' routines
   3  *
   4  * Copyright 1998 Ulrich Weigand
   5  */
   6
   7 #include <unistd.h>
   8 #include <sys/types.h>
   9 #include <signal.h>
  10 #include "syslevel.h"
  11 #include "heap.h"
  12 #include "stackframe.h"
  13 #include "debugtools.h"
  14
  15 DEFAULT_DEBUG_CHANNEL(win32)
  16
  17 static SYSLEVEL Win16Mutex;
  18 static SEGPTR segpWin16Mutex;
  19
  20 /* Global variable to save current TEB while in 16-bit code */
  21 WORD SYSLEVEL_Win16CurrentTeb = 0;
  22
  23 /* TEB of initial process for emergency use */
  24 WORD SYSLEVEL_EmergencyTeb = 0;
  25
  26
  27 /************************************************************************
  28  *           SYSLEVEL_Init
  29  */
  30 void SYSLEVEL_Init(void)
  31 {
  32     SYSLEVEL **w16Mutex = SEGPTR_ALLOC(sizeof(SYSLEVEL *));
  33
  34     *w16Mutex = &Win16Mutex;
  35     segpWin16Mutex = SEGPTR_GET(w16Mutex);
  36
  37     _CreateSysLevel( &Win16Mutex, 1 );
  38 }
  39
  40 /************************************************************************
  41  *           GetpWin16Lock32    (KERNEL32.93)
  42  */
  43 VOID WINAPI GetpWin16Lock(SYSLEVEL **lock)
  44 {
  45     *lock = &Win16Mutex;
  46 }
  47
  48 /************************************************************************
  49  *           GetpWin16Lock16    (KERNEL.449)
  50  */
  51 SEGPTR WINAPI GetpWin16Lock16(void)
  52 {
  53     return segpWin16Mutex;
  54 }
  55
  56 /************************************************************************
  57  *           _CreateSysLevel    (KERNEL.438)
  58  */
  59 VOID WINAPI _CreateSysLevel(SYSLEVEL *lock, INT level)
  60 {
  61     InitializeCriticalSection( &lock->crst );
  62     MakeCriticalSectionGlobal( &lock->crst );
  63     lock->level = level;
  64
  65     TRACE("(%p, %d): handle is %d\n",
  66                   lock, level, lock->crst.LockSemaphore );
  67 }
  68
  69 /************************************************************************
  70  *           _EnterSysLevel    (KERNEL32.97) (KERNEL.439)
  71  */
  72 VOID WINAPI _EnterSysLevel(SYSLEVEL *lock)
  73 {
  74     THDB *thdb = THREAD_Current();
  75     int i;
  76
  77     TRACE("(%p, level %d): thread %p (fs %04x, pid %d) count before %ld\n",
  78                   lock, lock->level, thdb->teb.tid, thdb->teb_sel, getpid(),
  79                   thdb->sys_count[lock->level] );
  80
  81     for ( i = 3; i > lock->level; i-- )
  82         if ( thdb->sys_count[i] > 0 )
  83         {
  84             ERR("(%p, level %d): Holding %p, level %d. Expect deadlock!\n",
  85                         lock, lock->level, thdb->sys_mutex[i], i );
  86         }
  87
  88     EnterCriticalSection( &lock->crst );
  89
  90     thdb->sys_count[lock->level]++;
  91     thdb->sys_mutex[lock->level] = lock;
  92
  93     TRACE("(%p, level %d): thread %p (fs %04x, pid %d) count after  %ld\n",
  94                   lock, lock->level, thdb->teb.tid, thdb->teb_sel, getpid(),
  95                   thdb->sys_count[lock->level] );
  96
  97     if (lock == &Win16Mutex)
  98         GET_FS( SYSLEVEL_Win16CurrentTeb );
  99 }
 100
 101 /************************************************************************
 102  *           _LeaveSysLevel    (KERNEL32.98) (KERNEL.440)
 103  */
 104 VOID WINAPI _LeaveSysLevel(SYSLEVEL *lock)
 105 {
 106     THDB *thdb = THREAD_Current();
 107
 108     TRACE("(%p, level %d): thread %p (fs %04x, pid %d) count before %ld\n",
 109                   lock, lock->level, thdb->teb.tid, thdb->teb_sel, getpid(),
 110                   thdb->sys_count[lock->level] );
 111
 112     if ( thdb->sys_count[lock->level] <= 0 || thdb->sys_mutex[lock->level] != lock )
 113     {
 114         ERR("(%p, level %d): Invalid state: count %ld mutex %p.\n",
 115                     lock, lock->level, thdb->sys_count[lock->level],
 116                     thdb->sys_mutex[lock->level] );
 117     }
 118     else
 119     {
 120         if ( --thdb->sys_count[lock->level] == 0 )
 121             thdb->sys_mutex[lock->level] = NULL;
 122     }
 123
 124     LeaveCriticalSection( &lock->crst );
 125
 126     TRACE("(%p, level %d): thread %p (fs %04x, pid %d) count after  %ld\n",
 127                   lock, lock->level, thdb->teb.tid, thdb->teb_sel, getpid(),
 128                   thdb->sys_count[lock->level] );
 129 }
 130
 131 /************************************************************************
 132  *           (KERNEL32.86)
 133  */
 134 VOID WINAPI _KERNEL32_86(SYSLEVEL *lock)
 135 {
 136     _LeaveSysLevel(lock);
 137 }
 138
 139 /************************************************************************
 140  *           _ConfirmSysLevel    (KERNEL32.95) (KERNEL.436)
 141  */
 142 DWORD WINAPI _ConfirmSysLevel(SYSLEVEL *lock)
 143 {
 144     if ( lock && lock->crst.OwningThread == GetCurrentThreadId() )
 145         return lock->crst.RecursionCount;
 146     else
 147         return 0L;
 148 }
 149
 150 /************************************************************************
 151  *           _CheckNotSysLevel    (KERNEL32.94) (KERNEL.437)
 152  */
 153 VOID WINAPI _CheckNotSysLevel(SYSLEVEL *lock)
 154 {
 155     FIXME("(%p)\n", lock);
 156 }
 157
 158
 159 /************************************************************************
 160  *           SYSLEVEL_EnterWin16Lock                    [KERNEL.480]
 161  */
 162 VOID WINAPI SYSLEVEL_EnterWin16Lock(VOID)
 163 {
 164     _EnterSysLevel(&Win16Mutex);
 165 }
 166
 167 /************************************************************************
 168  *           SYSLEVEL_LeaveWin16Lock            [KERNEL.481]
 169  */
 170 VOID WINAPI SYSLEVEL_LeaveWin16Lock(VOID)
 171 {
 172     _LeaveSysLevel(&Win16Mutex);
 173 }
 174 /************************************************************************
 175  *           _ConfirmWin16Lock    (KERNEL32.96)
 176  */
 177 DWORD WINAPI _ConfirmWin16Lock(void)
 178 {
 179     return _ConfirmSysLevel(&Win16Mutex);
 180 }
 181
 182 /************************************************************************
 183  *           ReleaseThunkLock    (KERNEL32.48)
 184  */
 185 VOID WINAPI ReleaseThunkLock(DWORD *mutex_count)
 186 {
 187     DWORD count = _ConfirmSysLevel(&Win16Mutex);
 188     *mutex_count = count;
 189
 190     while (count-- > 0)
 191         _LeaveSysLevel(&Win16Mutex);
 192 }
 193
 194 /************************************************************************
 195  *           RestoreThunkLock    (KERNEL32.49)
 196  */
 197 VOID WINAPI RestoreThunkLock(DWORD mutex_count)
 198 {
 199     while (mutex_count-- > 0)
 200         _EnterSysLevel(&Win16Mutex);
 201 }
 202
 203 /************************************************************************
 204  *           SYSLEVEL_ReleaseWin16Lock
 205  */
 206 VOID SYSLEVEL_ReleaseWin16Lock(VOID)
 207 {
 208     DWORD count;
 209
 210     ReleaseThunkLock(&count);
 211
 212     if (count > 0xffff)
 213         ERR("Win16Mutex recursion count too large!\n");
 214
 215     CURRENT_STACK16->mutex_count = (WORD)count;
 216 }
 217
 218 /************************************************************************
 219  *           SYSLEVEL_RestoreWin16Lock
 220  */
 221 VOID SYSLEVEL_RestoreWin16Lock(VOID)
 222 {
 223     DWORD count = CURRENT_STACK16->mutex_count;
 224
 225     if (!count)
 226         ERR("Win16Mutex recursion count is zero!\n");
 227
 228     RestoreThunkLock(count);
 229 }
 230
 231 /************************************************************************
 232  *           SYSLEVEL_CheckNotLevel
 233  */
 234 VOID SYSLEVEL_CheckNotLevel( INT level )
 235 {
 236     THDB *thdb = THREAD_Current();
 237     INT i;
 238
 239     for ( i = 3; i >= level; i-- )
 240         if ( thdb->sys_count[i] > 0 )
 241         {
 242             ERR("(%d): Holding lock of level %d!\n",
 243                        level, i );
 244
 245             kill( getpid(), SIGHUP );
 246             break;
 247         }
 248 }
 249