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 "ntddk.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 = { CRITICAL_SECTION_INIT, 1 };
  18
  19 /* Global variable to save current TEB while in 16-bit code */
  20 WORD SYSLEVEL_Win16CurrentTeb = 0;
  21
  22
  23 /************************************************************************
  24  *           GetpWin16Lock    (KERNEL32.93)
  25  */
  26 VOID WINAPI GetpWin16Lock(SYSLEVEL **lock)
  27 {
  28     *lock = &Win16Mutex;
  29 }
  30
  31 /************************************************************************
  32  *           GetpWin16Lock    (KERNEL.449)
  33  */
  34 SEGPTR WINAPI GetpWin16Lock16(void)
  35 {
  36     static SEGPTR segpWin16Mutex;
  37     if (!segpWin16Mutex)
  38     {
  39         SYSLEVEL **w16Mutex = SEGPTR_ALLOC(sizeof(SYSLEVEL *));
  40         *w16Mutex = &Win16Mutex;
  41         segpWin16Mutex = SEGPTR_GET(w16Mutex);
  42     }
  43     return segpWin16Mutex;
  44 }
  45
  46 /************************************************************************
  47  *           _CreateSysLevel    (KERNEL.438)
  48  */
  49 VOID WINAPI _CreateSysLevel(SYSLEVEL *lock, INT level)
  50 {
  51     InitializeCriticalSection( &lock->crst );
  52     lock->level = level;
  53
  54     TRACE("(%p, %d): handle is %d\n",
  55                   lock, level, lock->crst.LockSemaphore );
  56 }
  57
  58 /************************************************************************
  59  *           _EnterSysLevel    (KERNEL32.97)
  60  *           _EnterSysLevel    (KERNEL.439)
  61  */
  62 VOID WINAPI _EnterSysLevel(SYSLEVEL *lock)
  63 {
  64     TEB *teb = NtCurrentTeb();
  65     int i;
  66
  67     TRACE("(%p, level %d): thread %p (fs %04x, pid %ld) count before %ld\n",
  68                   lock, lock->level, teb->tid, teb->teb_sel, (long) getpid(),
  69                   teb->sys_count[lock->level] );
  70
  71     for ( i = 3; i > lock->level; i-- )
  72         if ( teb->sys_count[i] > 0 )
  73         {
  74             ERR("(%p, level %d): Holding %p, level %d. Expect deadlock!\n",
  75                         lock, lock->level, teb->sys_mutex[i], i );
  76         }
  77
  78     EnterCriticalSection( &lock->crst );
  79
  80     teb->sys_count[lock->level]++;
  81     teb->sys_mutex[lock->level] = lock;
  82
  83     TRACE("(%p, level %d): thread %p (fs %04x, pid %ld) count after  %ld\n",
  84                   lock, lock->level, teb->tid, teb->teb_sel, (long) getpid(),
  85                   teb->sys_count[lock->level] );
  86
  87     if (lock == &Win16Mutex)
  88         SYSLEVEL_Win16CurrentTeb = __get_fs();
  89 }
  90
  91 /************************************************************************
  92  *           _LeaveSysLevel    (KERNEL32.98)
  93  *           _LeaveSysLevel    (KERNEL.440)
  94  */
  95 VOID WINAPI _LeaveSysLevel(SYSLEVEL *lock)
  96 {
  97     TEB *teb = NtCurrentTeb();
  98
  99     TRACE("(%p, level %d): thread %p (fs %04x, pid %ld) count before %ld\n",
 100                   lock, lock->level, teb->tid, teb->teb_sel, (long) getpid(),
 101                   teb->sys_count[lock->level] );
 102
 103     if ( teb->sys_count[lock->level] <= 0 || teb->sys_mutex[lock->level] != lock )
 104     {
 105         ERR("(%p, level %d): Invalid state: count %ld mutex %p.\n",
 106                     lock, lock->level, teb->sys_count[lock->level],
 107                     teb->sys_mutex[lock->level] );
 108     }
 109     else
 110     {
 111         if ( --teb->sys_count[lock->level] == 0 )
 112             teb->sys_mutex[lock->level] = NULL;
 113     }
 114
 115     LeaveCriticalSection( &lock->crst );
 116
 117     TRACE("(%p, level %d): thread %p (fs %04x, pid %ld) count after  %ld\n",
 118                   lock, lock->level, teb->tid, teb->teb_sel, (long) getpid(),
 119                   teb->sys_count[lock->level] );
 120 }
 121
 122 /************************************************************************
 123  *              @ (KERNEL32.86)
 124  */
 125 VOID WINAPI _KERNEL32_86(SYSLEVEL *lock)
 126 {
 127     _LeaveSysLevel(lock);
 128 }
 129
 130 /************************************************************************
 131  *           _ConfirmSysLevel    (KERNEL32.95)
 132  *           _ConfirmSysLevel    (KERNEL.436)
 133  */
 134 DWORD WINAPI _ConfirmSysLevel(SYSLEVEL *lock)
 135 {
 136     if ( lock && lock->crst.OwningThread == GetCurrentThreadId() )
 137         return lock->crst.RecursionCount;
 138     else
 139         return 0L;
 140 }
 141
 142 /************************************************************************
 143  *           _CheckNotSysLevel    (KERNEL32.94)
 144  *           _CheckNotSysLevel    (KERNEL.437)
 145  */
 146 VOID WINAPI _CheckNotSysLevel(SYSLEVEL *lock)
 147 {
 148     FIXME("(%p)\n", lock);
 149 }
 150
 151
 152 /************************************************************************
 153  *           _EnterWin16Lock                    [KERNEL.480]
 154  */
 155 VOID WINAPI _EnterWin16Lock(void)
 156 {
 157     _EnterSysLevel(&Win16Mutex);
 158 }
 159
 160 /************************************************************************
 161  *           _LeaveWin16Lock            [KERNEL.481]
 162  */
 163 VOID WINAPI _LeaveWin16Lock(void)
 164 {
 165     _LeaveSysLevel(&Win16Mutex);
 166 }
 167
 168 /************************************************************************
 169  *           _ConfirmWin16Lock    (KERNEL32.96)
 170  */
 171 DWORD WINAPI _ConfirmWin16Lock(void)
 172 {
 173     return _ConfirmSysLevel(&Win16Mutex);
 174 }
 175
 176 /************************************************************************
 177  *           ReleaseThunkLock    (KERNEL32.48)
 178  */
 179 VOID WINAPI ReleaseThunkLock(DWORD *mutex_count)
 180 {
 181     DWORD count = _ConfirmSysLevel(&Win16Mutex);
 182     *mutex_count = count;
 183
 184     while (count-- > 0)
 185         _LeaveSysLevel(&Win16Mutex);
 186 }
 187
 188 /************************************************************************
 189  *           RestoreThunkLock    (KERNEL32.49)
 190  */
 191 VOID WINAPI RestoreThunkLock(DWORD mutex_count)
 192 {
 193     while (mutex_count-- > 0)
 194         _EnterSysLevel(&Win16Mutex);
 195 }
 196
 197 /************************************************************************
 198  *           SYSLEVEL_CheckNotLevel
 199  */
 200 VOID SYSLEVEL_CheckNotLevel( INT level )
 201 {
 202     INT i;
 203
 204     for ( i = 3; i >= level; i-- )
 205         if ( NtCurrentTeb()->sys_count[i] > 0 )
 206         {
 207             ERR("(%d): Holding lock of level %d!\n",
 208                        level, i );
 209             DbgBreakPoint();
 210             break;
 211         }
 212 }