dlls/ntoskrnl.exe/sync.c

   1 /*
   2  * Kernel synchronization
   3  *
   4  * Copyright (C) 2018 Zebediah Figura
   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include <stdarg.h>
  23
  24 #include "ntstatus.h"
  25 #define WIN32_NO_STATUS
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winternl.h"
  29 #include "ddk/ntddk.h"
  30 #include "ddk/wdm.h"
  31
  32 #include "wine/debug.h"
  33
  34 #include "ntoskrnl_private.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(ntoskrnl);
  37
  38 enum object_type
  39 {
  40     TYPE_MANUAL_EVENT = 0,
  41     TYPE_AUTO_EVENT = 1,
  42     TYPE_MUTEX = 2,
  43     TYPE_SEMAPHORE = 5,
  44     TYPE_MANUAL_TIMER = 8,
  45     TYPE_AUTO_TIMER = 9,
  46 };
  47
  48 static CRITICAL_SECTION sync_cs;
  49 static CRITICAL_SECTION_DEBUG sync_cs_debug =
  50 {
  51     0, 0, &sync_cs,
  52     { &sync_cs_debug.ProcessLocksList, &sync_cs_debug.ProcessLocksList },
  53     0, 0, { (DWORD_PTR)(__FILE__ ": sync_cs") }
  54 };
  55 static CRITICAL_SECTION sync_cs = { &sync_cs_debug, -1, 0, 0, 0, 0 };
  56
  57 /***********************************************************************
  58  *           KeWaitForMultipleObjects   (NTOSKRNL.EXE.@)
  59  */
  60 NTSTATUS WINAPI KeWaitForMultipleObjects(ULONG count, void *pobjs[],
  61     WAIT_TYPE wait_type, KWAIT_REASON reason, KPROCESSOR_MODE mode,
  62     BOOLEAN alertable, LARGE_INTEGER *timeout, KWAIT_BLOCK *wait_blocks)
  63 {
  64     DISPATCHER_HEADER **objs = (DISPATCHER_HEADER **)pobjs;
  65     HANDLE handles[MAXIMUM_WAIT_OBJECTS];
  66     NTSTATUS ret;
  67     ULONG i;
  68
  69     TRACE("count %u, objs %p, wait_type %u, reason %u, mode %d, alertable %u, timeout %p, wait_blocks %p.\n",
  70         count, objs, wait_type, reason, mode, alertable, timeout, wait_blocks);
  71
  72     /* We co-opt DISPATCHER_HEADER.WaitListHead:
  73      * Blink stores a handle to the synchronization object,
  74      * Flink stores the number of threads currently waiting on this object. */
  75
  76     EnterCriticalSection( &sync_cs );
  77     for (i = 0; i < count; i++)
  78     {
  79         ++*((ULONG_PTR *)&objs[i]->WaitListHead.Flink);
  80         if (!objs[i]->WaitListHead.Blink)
  81         {
  82             switch (objs[i]->Type)
  83             {
  84             case TYPE_MANUAL_EVENT:
  85                 objs[i]->WaitListHead.Blink = CreateEventW( NULL, TRUE, objs[i]->SignalState, NULL );
  86                 break;
  87             case TYPE_AUTO_EVENT:
  88                 objs[i]->WaitListHead.Blink = CreateEventW( NULL, FALSE, objs[i]->SignalState, NULL );
  89                 break;
  90             case TYPE_MUTEX:
  91                 objs[i]->WaitListHead.Blink = CreateMutexW( NULL, FALSE, NULL );
  92                 break;
  93             case TYPE_SEMAPHORE:
  94             {
  95                 KSEMAPHORE *semaphore = CONTAINING_RECORD(objs[i], KSEMAPHORE, Header);
  96                 objs[i]->WaitListHead.Blink = CreateSemaphoreW( NULL,
  97                     semaphore->Header.SignalState, semaphore->Limit, NULL );
  98                 break;
  99             }
 100             case TYPE_MANUAL_TIMER:
 101             case TYPE_AUTO_TIMER:
 102                 break;
 103             }
 104         }
 105
 106         handles[i] = objs[i]->WaitListHead.Blink;
 107     }
 108     LeaveCriticalSection( &sync_cs );
 109
 110     ret = NtWaitForMultipleObjects( count, handles, (wait_type == WaitAny), alertable, timeout );
 111
 112     EnterCriticalSection( &sync_cs );
 113     for (i = 0; i < count; i++)
 114     {
 115         if (ret == i || (!ret && wait_type == WaitAll))
 116         {
 117             switch (objs[i]->Type)
 118             {
 119             case TYPE_AUTO_EVENT:
 120             case TYPE_AUTO_TIMER:
 121                 objs[i]->SignalState = FALSE;
 122                 break;
 123             case TYPE_MUTEX:
 124             case TYPE_SEMAPHORE:
 125                 --objs[i]->SignalState;
 126                 break;
 127             }
 128         }
 129
 130         if (!--*((ULONG_PTR *)&objs[i]->WaitListHead.Flink))
 131         {
 132             switch (objs[i]->Type)
 133             {
 134             case TYPE_MANUAL_EVENT:
 135             case TYPE_AUTO_EVENT:
 136             case TYPE_SEMAPHORE:
 137                 CloseHandle(objs[i]->WaitListHead.Blink);
 138                 objs[i]->WaitListHead.Blink = NULL;
 139                 break;
 140             case TYPE_MUTEX:
 141                 /* Native will panic if a mutex is destroyed while held, so we
 142                  * don't have to worry about leaking the handle here. */
 143                 if (objs[i]->SignalState == 1)
 144                 {
 145                     CloseHandle(objs[i]->WaitListHead.Blink);
 146                     objs[i]->WaitListHead.Blink = NULL;
 147                 }
 148                 break;
 149             }
 150         }
 151     }
 152     LeaveCriticalSection( &sync_cs );
 153
 154     return ret;
 155 }
 156
 157 /***********************************************************************
 158  *           KeWaitForSingleObject   (NTOSKRNL.EXE.@)
 159  */
 160 NTSTATUS WINAPI KeWaitForSingleObject( void *obj, KWAIT_REASON reason,
 161     KPROCESSOR_MODE mode, BOOLEAN alertable, LARGE_INTEGER *timeout )
 162 {
 163     return KeWaitForMultipleObjects( 1, &obj, WaitAny, reason, mode, alertable, timeout, NULL );
 164 }
 165
 166 /***********************************************************************
 167  *           KeWaitForMutexObject   (NTOSKRNL.EXE.@)
 168  */
 169 NTSTATUS WINAPI KeWaitForMutexObject( PRKMUTEX mutex, KWAIT_REASON reason,
 170     KPROCESSOR_MODE mode, BOOLEAN alertable, LARGE_INTEGER *timeout)
 171 {
 172     return KeWaitForSingleObject( mutex, reason, mode, alertable, timeout );
 173 }
 174
 175
 176 /***********************************************************************
 177  *           KeInitializeEvent   (NTOSKRNL.EXE.@)
 178  */
 179 void WINAPI KeInitializeEvent( PRKEVENT event, EVENT_TYPE type, BOOLEAN state )
 180 {
 181     TRACE("event %p, type %u, state %u.\n", event, type, state);
 182
 183     event->Header.Type = type;
 184     event->Header.SignalState = state;
 185     event->Header.WaitListHead.Blink = NULL;
 186     event->Header.WaitListHead.Flink = NULL;
 187 }
 188
 189 static const WCHAR event_type_name[] = {'E','v','e','n','t',0};
 190
 191 static struct _OBJECT_TYPE event_type = {
 192     event_type_name,
 193 };
 194
 195 POBJECT_TYPE ExEventObjectType = &event_type;
 196
 197 /***********************************************************************
 198  *           KeSetEvent   (NTOSKRNL.EXE.@)
 199  */
 200 LONG WINAPI KeSetEvent( PRKEVENT event, KPRIORITY increment, BOOLEAN wait )
 201 {
 202     HANDLE handle;
 203     LONG ret;
 204
 205     TRACE("event %p, increment %d, wait %u.\n", event, increment, wait);
 206
 207     EnterCriticalSection( &sync_cs );
 208     ret = InterlockedExchange( &event->Header.SignalState, TRUE );
 209     if ((handle = event->Header.WaitListHead.Blink))
 210         SetEvent( handle );
 211     LeaveCriticalSection( &sync_cs );
 212
 213     return ret;
 214 }
 215
 216 /***********************************************************************
 217  *           KeResetEvent   (NTOSKRNL.EXE.@)
 218  */
 219 LONG WINAPI KeResetEvent( PRKEVENT event )
 220 {
 221     HANDLE handle;
 222     LONG ret;
 223
 224     TRACE("event %p.\n", event);
 225
 226     EnterCriticalSection( &sync_cs );
 227     ret = InterlockedExchange( &event->Header.SignalState, FALSE );
 228     if ((handle = event->Header.WaitListHead.Blink))
 229         ResetEvent( handle );
 230     LeaveCriticalSection( &sync_cs );
 231
 232     return ret;
 233 }
 234
 235 /***********************************************************************
 236  *           KeClearEvent (NTOSKRNL.EXE.@)
 237  */
 238 void WINAPI KeClearEvent( PRKEVENT event )
 239 {
 240     KeResetEvent( event );
 241 }
 242
 243 /***********************************************************************
 244  *           KeInitializeSemaphore   (NTOSKRNL.EXE.@)
 245  */
 246 void WINAPI KeInitializeSemaphore( PRKSEMAPHORE semaphore, LONG count, LONG limit )
 247 {
 248     TRACE("semaphore %p, count %d, limit %d.\n", semaphore, count, limit);
 249
 250     semaphore->Header.Type = TYPE_SEMAPHORE;
 251     semaphore->Header.SignalState = count;
 252     semaphore->Header.WaitListHead.Blink = NULL;
 253     semaphore->Header.WaitListHead.Flink = NULL;
 254     semaphore->Limit = limit;
 255 }
 256
 257 /***********************************************************************
 258  *           KeReleaseSemaphore   (NTOSKRNL.EXE.@)
 259  */
 260 LONG WINAPI KeReleaseSemaphore( PRKSEMAPHORE semaphore, KPRIORITY increment,
 261                                 LONG count, BOOLEAN wait )
 262 {
 263     HANDLE handle;
 264     LONG ret;
 265
 266     TRACE("semaphore %p, increment %d, count %d, wait %u.\n",
 267         semaphore, increment, count, wait);
 268
 269     EnterCriticalSection( &sync_cs );
 270     ret = InterlockedExchangeAdd( &semaphore->Header.SignalState, count );
 271     if ((handle = semaphore->Header.WaitListHead.Blink))
 272         ReleaseSemaphore( handle, count, NULL );
 273     LeaveCriticalSection( &sync_cs );
 274
 275     return ret;
 276 }
 277
 278 static const WCHAR semaphore_type_name[] = {'S','e','m','a','p','h','o','r','e',0};
 279
 280 static struct _OBJECT_TYPE semaphore_type =
 281 {
 282     semaphore_type_name
 283 };
 284
 285 POBJECT_TYPE ExSemaphoreObjectType = &semaphore_type;
 286
 287 /***********************************************************************
 288  *           KeInitializeMutex   (NTOSKRNL.EXE.@)
 289  */
 290 void WINAPI KeInitializeMutex( PRKMUTEX mutex, ULONG level )
 291 {
 292     TRACE("mutex %p, level %u.\n", mutex, level);
 293
 294     mutex->Header.Type = TYPE_MUTEX;
 295     mutex->Header.SignalState = 1;
 296     mutex->Header.WaitListHead.Blink = NULL;
 297     mutex->Header.WaitListHead.Flink = NULL;
 298 }
 299
 300 /***********************************************************************
 301  *           KeReleaseMutex   (NTOSKRNL.EXE.@)
 302  */
 303 LONG WINAPI KeReleaseMutex( PRKMUTEX mutex, BOOLEAN wait )
 304 {
 305     LONG ret;
 306
 307     TRACE("mutex %p, wait %u.\n", mutex, wait);
 308
 309     EnterCriticalSection( &sync_cs );
 310     ret = mutex->Header.SignalState++;
 311     if (!ret && !mutex->Header.WaitListHead.Flink)
 312     {
 313         CloseHandle( mutex->Header.WaitListHead.Blink );
 314         mutex->Header.WaitListHead.Blink = NULL;
 315     }
 316     LeaveCriticalSection( &sync_cs );
 317
 318     return ret;
 319 }
 320
 321 /***********************************************************************
 322  *           KeInitializeTimerEx   (NTOSKRNL.EXE.@)
 323  */
 324 void WINAPI KeInitializeTimerEx( KTIMER *timer, TIMER_TYPE type )
 325 {
 326     TRACE("timer %p, type %u.\n", timer, type);
 327
 328     RtlZeroMemory(timer, sizeof(KTIMER));
 329     timer->Header.Type = (type == NotificationTimer) ? TYPE_MANUAL_TIMER : TYPE_AUTO_TIMER;
 330     timer->Header.SignalState = FALSE;
 331     timer->Header.Inserted = FALSE;
 332     timer->Header.WaitListHead.Blink = NULL;
 333     timer->Header.WaitListHead.Flink = NULL;
 334 }
 335
 336 /***********************************************************************
 337  *           KeInitializeTimer   (NTOSKRNL.EXE.@)
 338  */
 339 void WINAPI KeInitializeTimer( KTIMER *timer )
 340 {
 341     KeInitializeTimerEx(timer, NotificationTimer);
 342 }
 343
 344 /***********************************************************************
 345  *           KeSetTimerEx (NTOSKRNL.EXE.@)
 346  */
 347 BOOLEAN WINAPI KeSetTimerEx( KTIMER *timer, LARGE_INTEGER duetime, LONG period, KDPC *dpc )
 348 {
 349     BOOL ret;
 350
 351     TRACE("timer %p, duetime %s, period %d, dpc %p.\n",
 352         timer, wine_dbgstr_longlong(duetime.QuadPart), period, dpc);
 353
 354     if (dpc)
 355     {
 356         FIXME("Unhandled DPC %p.\n", dpc);
 357         return FALSE;
 358     }
 359
 360     EnterCriticalSection( &sync_cs );
 361
 362     ret = timer->Header.Inserted;
 363     timer->Header.Inserted = TRUE;
 364     timer->Header.WaitListHead.Blink = CreateWaitableTimerW( NULL, timer->Header.Type == TYPE_MANUAL_TIMER, NULL );
 365     SetWaitableTimer( timer->Header.WaitListHead.Blink, &duetime, period, NULL, NULL, FALSE );
 366
 367     LeaveCriticalSection( &sync_cs );
 368
 369     return ret;
 370 }
 371
 372 BOOLEAN WINAPI KeCancelTimer( KTIMER *timer )
 373 {
 374     BOOL ret;
 375
 376     TRACE("timer %p.\n", timer);
 377
 378     EnterCriticalSection( &sync_cs );
 379     ret = timer->Header.Inserted;
 380     timer->Header.Inserted = FALSE;
 381     CloseHandle(timer->Header.WaitListHead.Blink);
 382     timer->Header.WaitListHead.Blink = NULL;
 383     LeaveCriticalSection( &sync_cs );
 384
 385     return ret;
 386 }
 387
 388 /***********************************************************************
 389  *           KeDelayExecutionThread  (NTOSKRNL.EXE.@)
 390  */
 391 NTSTATUS WINAPI KeDelayExecutionThread( KPROCESSOR_MODE mode, BOOLEAN alertable, LARGE_INTEGER *timeout )
 392 {
 393     TRACE("mode %d, alertable %u, timeout %p.\n", mode, alertable, timeout);
 394     return NtDelayExecution( alertable, timeout );
 395 }
 396
 397 /***********************************************************************
 398  *           KeInitializeSpinLock   (NTOSKRNL.EXE.@)
 399  */
 400 void WINAPI KeInitializeSpinLock( KSPIN_LOCK *lock )
 401 {
 402     TRACE("lock %p.\n", lock);
 403     *lock = 0;
 404 }
 405
 406 static inline void small_pause(void)
 407 {
 408 #ifdef __x86_64__
 409     __asm__ __volatile__( "rep;nop" : : : "memory" );
 410 #else
 411     __asm__ __volatile__( "" : : : "memory" );
 412 #endif
 413 }
 414
 415 /***********************************************************************
 416  *           KeAcquireSpinLockAtDpcLevel (NTOSKRNL.EXE.@)
 417  */
 418 void WINAPI KeAcquireSpinLockAtDpcLevel( KSPIN_LOCK *lock )
 419 {
 420     TRACE("lock %p.\n", lock);
 421     while (!InterlockedCompareExchangePointer( (void **)lock, (void *)1, (void *)0 ))
 422         small_pause();
 423 }
 424
 425 /***********************************************************************
 426  *           KeReleaseSpinLockFromDpcLevel (NTOSKRNL.EXE.@)
 427  */
 428 void WINAPI KeReleaseSpinLockFromDpcLevel( KSPIN_LOCK *lock )
 429 {
 430     TRACE("lock %p.\n", lock);
 431     InterlockedExchangePointer( (void **)lock, 0 );
 432 }
 433
 434 #define QUEUED_SPINLOCK_OWNED   0x2
 435
 436 /***********************************************************************
 437  *           KeAcquireInStackQueuedSpinLockAtDpcLevel  (NTOSKRNL.EXE.@)
 438  */
 439 DEFINE_FASTCALL_WRAPPER( KeAcquireInStackQueuedSpinLockAtDpcLevel, 8 )
 440 void WINAPI KeAcquireInStackQueuedSpinLockAtDpcLevel( KSPIN_LOCK *lock, KLOCK_QUEUE_HANDLE *queue )
 441 {
 442     KSPIN_LOCK_QUEUE *tail;
 443
 444     TRACE("lock %p, queue %p.\n", lock, queue);
 445
 446     queue->LockQueue.Next = NULL;
 447
 448     if (!(tail = InterlockedExchangePointer( (void **)lock, &queue->LockQueue )))
 449         queue->LockQueue.Lock = (KSPIN_LOCK *)((ULONG_PTR)lock | QUEUED_SPINLOCK_OWNED);
 450     else
 451     {
 452         queue->LockQueue.Lock = lock;
 453         InterlockedExchangePointer( (void **)&tail->Next, &queue->LockQueue );
 454
 455         while (!((ULONG_PTR)InterlockedCompareExchangePointer( (void **)&queue->LockQueue.Lock, 0, 0 )
 456                  & QUEUED_SPINLOCK_OWNED))
 457         {
 458             small_pause();
 459         }
 460     }
 461 }
 462
 463 /***********************************************************************
 464  *           KeReleaseInStackQueuedSpinLockFromDpcLevel  (NTOSKRNL.EXE.@)
 465  */
 466 DEFINE_FASTCALL1_WRAPPER( KeReleaseInStackQueuedSpinLockFromDpcLevel )
 467 void WINAPI KeReleaseInStackQueuedSpinLockFromDpcLevel( KLOCK_QUEUE_HANDLE *queue )
 468 {
 469     KSPIN_LOCK *lock = (KSPIN_LOCK *)((ULONG_PTR)queue->LockQueue.Lock & ~QUEUED_SPINLOCK_OWNED);
 470     KSPIN_LOCK_QUEUE *next;
 471
 472     TRACE("lock %p, queue %p.\n", lock, queue);
 473
 474     queue->LockQueue.Lock = NULL;
 475
 476     if (!(next = queue->LockQueue.Next))
 477     {
 478         /* If we are truly the last in the queue, the lock will point to us. */
 479         if (InterlockedCompareExchangePointer( (void **)lock, NULL, &queue->LockQueue ) == queue)
 480             return;
 481
 482         /* Otherwise, someone just queued themselves, but hasn't yet set
 483          * themselves as successor. Spin waiting for them to do so. */
 484         while (!(next = queue->LockQueue.Next))
 485             small_pause();
 486     }
 487
 488     InterlockedExchangePointer( (void **)&next->Lock, (KSPIN_LOCK *)((ULONG_PTR)lock | QUEUED_SPINLOCK_OWNED) );
 489 }
 490
 491 #ifndef __i386__
 492 /***********************************************************************
 493  *           KeReleaseSpinLock (NTOSKRNL.EXE.@)
 494  */
 495 void WINAPI KeReleaseSpinLock( KSPIN_LOCK *lock, KIRQL irql )
 496 {
 497     TRACE("lock %p, irql %u.\n", lock, irql);
 498     KeReleaseSpinLockFromDpcLevel( lock );
 499 }
 500
 501 /***********************************************************************
 502  *           KeAcquireSpinLockRaiseToDpc (NTOSKRNL.EXE.@)
 503  */
 504 KIRQL WINAPI KeAcquireSpinLockRaiseToDpc( KSPIN_LOCK *lock )
 505 {
 506     TRACE("lock %p.\n", lock);
 507     KeAcquireSpinLockAtDpcLevel( lock );
 508     return 0;
 509 }
 510
 511 /***********************************************************************
 512  *           KeAcquireInStackQueuedSpinLock (NTOSKRNL.EXE.@)
 513  */
 514 void WINAPI KeAcquireInStackQueuedSpinLock( KSPIN_LOCK *lock, KLOCK_QUEUE_HANDLE *queue )
 515 {
 516     TRACE("lock %p, queue %p.\n", lock, queue);
 517     KeAcquireInStackQueuedSpinLockAtDpcLevel( lock, queue );
 518 }
 519
 520 /***********************************************************************
 521  *           KeReleaseInStackQueuedSpinLock (NTOSKRNL.EXE.@)
 522  */
 523 void WINAPI KeReleaseInStackQueuedSpinLock( KLOCK_QUEUE_HANDLE *queue )
 524 {
 525     TRACE("queue %p.\n", queue);
 526     KeReleaseInStackQueuedSpinLockFromDpcLevel( queue );
 527 }
 528 #endif
 529
 530 static KSPIN_LOCK cancel_lock;
 531
 532 /***********************************************************************
 533  *           IoAcquireCancelSpinLock  (NTOSKRNL.EXE.@)
 534  */
 535 void WINAPI IoAcquireCancelSpinLock( KIRQL *irql )
 536 {
 537     TRACE("irql %p.\n", irql);
 538     KeAcquireSpinLock( &cancel_lock, irql );
 539 }
 540
 541 /***********************************************************************
 542  *           IoReleaseCancelSpinLock  (NTOSKRNL.EXE.@)
 543  */
 544 void WINAPI IoReleaseCancelSpinLock( KIRQL irql )
 545 {
 546     TRACE("irql %u.\n", irql);
 547     KeReleaseSpinLock( &cancel_lock, irql );
 548 }
 549
 550 /***********************************************************************
 551  *           ExfInterlockedRemoveHeadList  (NTOSKRNL.EXE.@)
 552  */
 553 DEFINE_FASTCALL_WRAPPER( ExfInterlockedRemoveHeadList, 8 )
 554 PLIST_ENTRY WINAPI ExfInterlockedRemoveHeadList( LIST_ENTRY *list, KSPIN_LOCK *lock )
 555 {
 556     return ExInterlockedRemoveHeadList( list, lock );
 557 }
 558
 559 /***********************************************************************
 560  *           ExInterlockedRemoveHeadList  (NTOSKRNL.EXE.@)
 561  */
 562 LIST_ENTRY * WINAPI ExInterlockedRemoveHeadList( LIST_ENTRY *list, KSPIN_LOCK *lock )
 563 {
 564     LIST_ENTRY *ret;
 565     KIRQL irql;
 566
 567     TRACE("list %p, lock %p.\n", list, lock);
 568
 569     KeAcquireSpinLock( lock, &irql );
 570     ret = RemoveHeadList( list );
 571     KeReleaseSpinLock( lock, irql );
 572
 573     return ret;
 574 }
 575
 576
 577 /***********************************************************************
 578  *           InterlockedPopEntrySList   (NTOSKRNL.EXE.@)
 579  */
 580 DEFINE_FASTCALL1_WRAPPER( NTOSKRNL_InterlockedPopEntrySList )
 581 PSLIST_ENTRY WINAPI NTOSKRNL_InterlockedPopEntrySList( PSLIST_HEADER list )
 582 {
 583     return RtlInterlockedPopEntrySList( list );
 584 }
 585
 586
 587 /***********************************************************************
 588  *           InterlockedPushEntrySList   (NTOSKRNL.EXE.@)
 589  */
 590 DEFINE_FASTCALL_WRAPPER( NTOSKRNL_InterlockedPushEntrySList, 8 )
 591 PSLIST_ENTRY WINAPI NTOSKRNL_InterlockedPushEntrySList( PSLIST_HEADER list, PSLIST_ENTRY entry )
 592 {
 593     return RtlInterlockedPushEntrySList( list, entry );
 594 }
 595
 596
 597 /***********************************************************************
 598  *           ExInterlockedPopEntrySList   (NTOSKRNL.EXE.@)
 599  */
 600 DEFINE_FASTCALL_WRAPPER( NTOSKRNL_ExInterlockedPopEntrySList, 8 )
 601 PSLIST_ENTRY WINAPI NTOSKRNL_ExInterlockedPopEntrySList( PSLIST_HEADER list, PKSPIN_LOCK lock )
 602 {
 603     return RtlInterlockedPopEntrySList( list );
 604 }
 605
 606
 607 /***********************************************************************
 608  *           ExInterlockedPushEntrySList   (NTOSKRNL.EXE.@)
 609  */
 610 DEFINE_FASTCALL_WRAPPER( NTOSKRNL_ExInterlockedPushEntrySList, 12 )
 611 PSLIST_ENTRY WINAPI NTOSKRNL_ExInterlockedPushEntrySList( PSLIST_HEADER list, PSLIST_ENTRY entry, PKSPIN_LOCK lock )
 612 {
 613     return RtlInterlockedPushEntrySList( list, entry );
 614 }
 615
 616
 617 /***********************************************************************
 618  *           ExAcquireFastMutexUnsafe  (NTOSKRNL.EXE.@)
 619  */
 620 DEFINE_FASTCALL1_WRAPPER(ExAcquireFastMutexUnsafe)
 621 void WINAPI ExAcquireFastMutexUnsafe( FAST_MUTEX *mutex )
 622 {
 623     LONG count;
 624
 625     TRACE("mutex %p.\n", mutex);
 626
 627     count = InterlockedDecrement( &mutex->Count );
 628     if (count < 0)
 629         KeWaitForSingleObject( &mutex->Event, Executive, KernelMode, FALSE, NULL );
 630 }
 631
 632 /***********************************************************************
 633  *           ExReleaseFastMutexUnsafe  (NTOSKRNL.EXE.@)
 634  */
 635 DEFINE_FASTCALL1_WRAPPER(ExReleaseFastMutexUnsafe)
 636 void WINAPI ExReleaseFastMutexUnsafe( FAST_MUTEX *mutex )
 637 {
 638     LONG count;
 639
 640     TRACE("mutex %p.\n", mutex);
 641
 642     count = InterlockedIncrement( &mutex->Count );
 643     if (count < 1)
 644         KeSetEvent( &mutex->Event, IO_NO_INCREMENT, FALSE );
 645 }