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 <limits.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 #include "ddk/ntifs.h"
  32
  33 #include "wine/asm.h"
  34 #include "wine/debug.h"
  35 #include "wine/heap.h"
  36
  37 #include "ntoskrnl_private.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(ntoskrnl);
  40
  41 enum object_type
  42 {
  43     TYPE_MANUAL_EVENT = 0,
  44     TYPE_AUTO_EVENT = 1,
  45     TYPE_MUTEX = 2,
  46     TYPE_SEMAPHORE = 5,
  47     TYPE_MANUAL_TIMER = 8,
  48     TYPE_AUTO_TIMER = 9,
  49 };
  50
  51 DECLARE_CRITICAL_SECTION(sync_cs);
  52
  53 /***********************************************************************
  54  *           KeWaitForMultipleObjects   (NTOSKRNL.EXE.@)
  55  */
  56 NTSTATUS WINAPI KeWaitForMultipleObjects(ULONG count, void *pobjs[],
  57     WAIT_TYPE wait_type, KWAIT_REASON reason, KPROCESSOR_MODE mode,
  58     BOOLEAN alertable, LARGE_INTEGER *timeout, KWAIT_BLOCK *wait_blocks)
  59 {
  60     DISPATCHER_HEADER **objs = (DISPATCHER_HEADER **)pobjs;
  61     HANDLE handles[MAXIMUM_WAIT_OBJECTS];
  62     NTSTATUS ret;
  63     ULONG i;
  64
  65     TRACE("count %u, objs %p, wait_type %u, reason %u, mode %d, alertable %u, timeout %p, wait_blocks %p.\n",
  66         count, objs, wait_type, reason, mode, alertable, timeout, wait_blocks);
  67
  68     /* We co-opt DISPATCHER_HEADER.WaitListHead:
  69      * Blink stores a handle to the synchronization object,
  70      * Flink stores the number of threads currently waiting on this object. */
  71
  72     EnterCriticalSection( &sync_cs );
  73     for (i = 0; i < count; i++)
  74     {
  75         if (objs[i]->WaitListHead.Blink == INVALID_HANDLE_VALUE)
  76         {
  77             ObOpenObjectByPointer( objs[i], OBJ_KERNEL_HANDLE, NULL, SYNCHRONIZE, NULL, KernelMode, &handles[i] );
  78             continue;
  79         }
  80
  81         ++*((ULONG_PTR *)&objs[i]->WaitListHead.Flink);
  82         if (!objs[i]->WaitListHead.Blink)
  83         {
  84             switch (objs[i]->Type)
  85             {
  86             case TYPE_MANUAL_EVENT:
  87                 objs[i]->WaitListHead.Blink = CreateEventW( NULL, TRUE, objs[i]->SignalState, NULL );
  88                 break;
  89             case TYPE_AUTO_EVENT:
  90                 objs[i]->WaitListHead.Blink = CreateEventW( NULL, FALSE, objs[i]->SignalState, NULL );
  91                 break;
  92             case TYPE_MUTEX:
  93                 objs[i]->WaitListHead.Blink = CreateMutexW( NULL, FALSE, NULL );
  94                 break;
  95             case TYPE_SEMAPHORE:
  96             {
  97                 KSEMAPHORE *semaphore = CONTAINING_RECORD(objs[i], KSEMAPHORE, Header);
  98                 objs[i]->WaitListHead.Blink = CreateSemaphoreW( NULL,
  99                     semaphore->Header.SignalState, semaphore->Limit, NULL );
 100                 break;
 101             }
 102             case TYPE_MANUAL_TIMER:
 103             case TYPE_AUTO_TIMER:
 104                 break;
 105             }
 106         }
 107
 108         handles[i] = objs[i]->WaitListHead.Blink;
 109     }
 110     LeaveCriticalSection( &sync_cs );
 111
 112     ret = NtWaitForMultipleObjects( count, handles, (wait_type == WaitAny), alertable, timeout );
 113
 114     EnterCriticalSection( &sync_cs );
 115     for (i = 0; i < count; i++)
 116     {
 117         if (ret == i || (!ret && wait_type == WaitAll))
 118         {
 119             switch (objs[i]->Type)
 120             {
 121             case TYPE_AUTO_EVENT:
 122             case TYPE_AUTO_TIMER:
 123                 objs[i]->SignalState = FALSE;
 124                 break;
 125             case TYPE_MUTEX:
 126             case TYPE_SEMAPHORE:
 127                 --objs[i]->SignalState;
 128                 break;
 129             }
 130         }
 131
 132         if (objs[i]->WaitListHead.Blink == INVALID_HANDLE_VALUE)
 133         {
 134             NtClose( handles[i] );
 135         }
 136         else if (!--*((ULONG_PTR *)&objs[i]->WaitListHead.Flink))
 137         {
 138             switch (objs[i]->Type)
 139             {
 140             case TYPE_MANUAL_EVENT:
 141             case TYPE_AUTO_EVENT:
 142             case TYPE_SEMAPHORE:
 143                 CloseHandle(objs[i]->WaitListHead.Blink);
 144                 objs[i]->WaitListHead.Blink = NULL;
 145                 break;
 146             case TYPE_MUTEX:
 147                 /* Native will panic if a mutex is destroyed while held, so we
 148                  * don't have to worry about leaking the handle here. */
 149                 if (objs[i]->SignalState == 1)
 150                 {
 151                     CloseHandle(objs[i]->WaitListHead.Blink);
 152                     objs[i]->WaitListHead.Blink = NULL;
 153                 }
 154                 break;
 155             }
 156         }
 157     }
 158     LeaveCriticalSection( &sync_cs );
 159
 160     return ret;
 161 }
 162
 163 /***********************************************************************
 164  *           KeWaitForSingleObject   (NTOSKRNL.EXE.@)
 165  */
 166 NTSTATUS WINAPI KeWaitForSingleObject( void *obj, KWAIT_REASON reason,
 167     KPROCESSOR_MODE mode, BOOLEAN alertable, LARGE_INTEGER *timeout )
 168 {
 169     return KeWaitForMultipleObjects( 1, &obj, WaitAny, reason, mode, alertable, timeout, NULL );
 170 }
 171
 172 /***********************************************************************
 173  *           KeWaitForMutexObject   (NTOSKRNL.EXE.@)
 174  */
 175 NTSTATUS WINAPI KeWaitForMutexObject( PRKMUTEX mutex, KWAIT_REASON reason,
 176     KPROCESSOR_MODE mode, BOOLEAN alertable, LARGE_INTEGER *timeout)
 177 {
 178     return KeWaitForSingleObject( mutex, reason, mode, alertable, timeout );
 179 }
 180
 181
 182 /***********************************************************************
 183  *           KeInitializeEvent   (NTOSKRNL.EXE.@)
 184  */
 185 void WINAPI KeInitializeEvent( PRKEVENT event, EVENT_TYPE type, BOOLEAN state )
 186 {
 187     TRACE("event %p, type %u, state %u.\n", event, type, state);
 188
 189     event->Header.Type = type;
 190     event->Header.SignalState = state;
 191     event->Header.WaitListHead.Blink = NULL;
 192     event->Header.WaitListHead.Flink = NULL;
 193 }
 194
 195 static void *create_event_object( HANDLE handle )
 196 {
 197     EVENT_BASIC_INFORMATION info;
 198     KEVENT *event;
 199
 200     if (!(event = alloc_kernel_object( ExEventObjectType, handle, sizeof(*event), 0 ))) return NULL;
 201
 202     if (!NtQueryEvent( handle, EventBasicInformation, &info, sizeof(info), NULL ))
 203         KeInitializeEvent( event, info.EventType, info.EventState );
 204     event->Header.WaitListHead.Blink = INVALID_HANDLE_VALUE; /* mark as kernel object */
 205     return event;
 206 }
 207
 208 static const WCHAR event_type_name[] = {'E','v','e','n','t',0};
 209
 210 static struct _OBJECT_TYPE event_type = {
 211     event_type_name,
 212     create_event_object
 213 };
 214
 215 POBJECT_TYPE ExEventObjectType = &event_type;
 216
 217 /***********************************************************************
 218  *           IoCreateSynchronizationEvent (NTOSKRNL.EXE.@)
 219  */
 220 PKEVENT WINAPI IoCreateSynchronizationEvent( UNICODE_STRING *name, HANDLE *ret_handle )
 221 {
 222     OBJECT_ATTRIBUTES attr;
 223     HANDLE handle;
 224     KEVENT *event;
 225     NTSTATUS ret;
 226
 227     TRACE( "(%p %p)\n", name, ret_handle );
 228
 229     InitializeObjectAttributes( &attr, name, 0, 0, NULL );
 230     ret = NtCreateEvent( &handle, EVENT_ALL_ACCESS, &attr, SynchronizationEvent, TRUE );
 231     if (ret) return NULL;
 232
 233     if (kernel_object_from_handle( handle, ExEventObjectType, (void**)&event ))
 234     {
 235         NtClose( handle);
 236         return NULL;
 237     }
 238
 239     *ret_handle = handle;
 240     return event;
 241 }
 242
 243 /***********************************************************************
 244  *           KeSetEvent   (NTOSKRNL.EXE.@)
 245  */
 246 LONG WINAPI KeSetEvent( PRKEVENT event, KPRIORITY increment, BOOLEAN wait )
 247 {
 248     HANDLE handle;
 249     LONG ret = 0;
 250
 251     TRACE("event %p, increment %d, wait %u.\n", event, increment, wait);
 252
 253     if (event->Header.WaitListHead.Blink != INVALID_HANDLE_VALUE)
 254     {
 255         EnterCriticalSection( &sync_cs );
 256         ret = InterlockedExchange( &event->Header.SignalState, TRUE );
 257         if ((handle = event->Header.WaitListHead.Blink))
 258             SetEvent( handle );
 259         LeaveCriticalSection( &sync_cs );
 260     }
 261     else
 262     {
 263         if (!ObOpenObjectByPointer( event, OBJ_KERNEL_HANDLE, NULL, EVENT_MODIFY_STATE, NULL, KernelMode, &handle ))
 264         {
 265             NtSetEvent( handle, &ret );
 266             NtClose( handle );
 267         }
 268         event->Header.SignalState = TRUE;
 269     }
 270
 271     return ret;
 272 }
 273
 274 /***********************************************************************
 275  *           KeResetEvent   (NTOSKRNL.EXE.@)
 276  */
 277 LONG WINAPI KeResetEvent( PRKEVENT event )
 278 {
 279     HANDLE handle;
 280     LONG ret = 0;
 281
 282     TRACE("event %p.\n", event);
 283
 284     if (event->Header.WaitListHead.Blink != INVALID_HANDLE_VALUE)
 285     {
 286         EnterCriticalSection( &sync_cs );
 287         ret = InterlockedExchange( &event->Header.SignalState, FALSE );
 288         if ((handle = event->Header.WaitListHead.Blink))
 289             ResetEvent( handle );
 290         LeaveCriticalSection( &sync_cs );
 291     }
 292     else
 293     {
 294         if (!ObOpenObjectByPointer( event, OBJ_KERNEL_HANDLE, NULL, EVENT_MODIFY_STATE, NULL, KernelMode, &handle ))
 295         {
 296             NtResetEvent( handle, &ret );
 297             NtClose( handle );
 298         }
 299         event->Header.SignalState = FALSE;
 300     }
 301
 302     return ret;
 303 }
 304
 305 /***********************************************************************
 306  *           KeClearEvent (NTOSKRNL.EXE.@)
 307  */
 308 void WINAPI KeClearEvent( PRKEVENT event )
 309 {
 310     KeResetEvent( event );
 311 }
 312
 313 /***********************************************************************
 314  *           KeInitializeSemaphore   (NTOSKRNL.EXE.@)
 315  */
 316 void WINAPI KeInitializeSemaphore( PRKSEMAPHORE semaphore, LONG count, LONG limit )
 317 {
 318     TRACE("semaphore %p, count %d, limit %d.\n", semaphore, count, limit);
 319
 320     semaphore->Header.Type = TYPE_SEMAPHORE;
 321     semaphore->Header.SignalState = count;
 322     semaphore->Header.WaitListHead.Blink = NULL;
 323     semaphore->Header.WaitListHead.Flink = NULL;
 324     semaphore->Limit = limit;
 325 }
 326
 327 /***********************************************************************
 328  *           KeReleaseSemaphore   (NTOSKRNL.EXE.@)
 329  */
 330 LONG WINAPI KeReleaseSemaphore( PRKSEMAPHORE semaphore, KPRIORITY increment,
 331                                 LONG count, BOOLEAN wait )
 332 {
 333     HANDLE handle;
 334     LONG ret;
 335
 336     TRACE("semaphore %p, increment %d, count %d, wait %u.\n",
 337         semaphore, increment, count, wait);
 338
 339     EnterCriticalSection( &sync_cs );
 340     ret = InterlockedExchangeAdd( &semaphore->Header.SignalState, count );
 341     if ((handle = semaphore->Header.WaitListHead.Blink))
 342         ReleaseSemaphore( handle, count, NULL );
 343     LeaveCriticalSection( &sync_cs );
 344
 345     return ret;
 346 }
 347
 348 static const WCHAR semaphore_type_name[] = {'S','e','m','a','p','h','o','r','e',0};
 349
 350 static struct _OBJECT_TYPE semaphore_type =
 351 {
 352     semaphore_type_name
 353 };
 354
 355 POBJECT_TYPE ExSemaphoreObjectType = &semaphore_type;
 356
 357 /***********************************************************************
 358  *           KeInitializeMutex   (NTOSKRNL.EXE.@)
 359  */
 360 void WINAPI KeInitializeMutex( PRKMUTEX mutex, ULONG level )
 361 {
 362     TRACE("mutex %p, level %u.\n", mutex, level);
 363
 364     mutex->Header.Type = TYPE_MUTEX;
 365     mutex->Header.SignalState = 1;
 366     mutex->Header.WaitListHead.Blink = NULL;
 367     mutex->Header.WaitListHead.Flink = NULL;
 368 }
 369
 370 /***********************************************************************
 371  *           KeReleaseMutex   (NTOSKRNL.EXE.@)
 372  */
 373 LONG WINAPI KeReleaseMutex( PRKMUTEX mutex, BOOLEAN wait )
 374 {
 375     LONG ret;
 376
 377     TRACE("mutex %p, wait %u.\n", mutex, wait);
 378
 379     EnterCriticalSection( &sync_cs );
 380     ret = mutex->Header.SignalState++;
 381     if (!ret && !mutex->Header.WaitListHead.Flink)
 382     {
 383         CloseHandle( mutex->Header.WaitListHead.Blink );
 384         mutex->Header.WaitListHead.Blink = NULL;
 385     }
 386     LeaveCriticalSection( &sync_cs );
 387
 388     return ret;
 389 }
 390
 391 /***********************************************************************
 392  *           KeInitializeTimerEx   (NTOSKRNL.EXE.@)
 393  */
 394 void WINAPI KeInitializeTimerEx( KTIMER *timer, TIMER_TYPE type )
 395 {
 396     TRACE("timer %p, type %u.\n", timer, type);
 397
 398     RtlZeroMemory(timer, sizeof(KTIMER));
 399     timer->Header.Type = (type == NotificationTimer) ? TYPE_MANUAL_TIMER : TYPE_AUTO_TIMER;
 400     timer->Header.SignalState = FALSE;
 401     timer->Header.Inserted = FALSE;
 402     timer->Header.WaitListHead.Blink = NULL;
 403     timer->Header.WaitListHead.Flink = NULL;
 404 }
 405
 406 /***********************************************************************
 407  *           KeInitializeTimer   (NTOSKRNL.EXE.@)
 408  */
 409 void WINAPI KeInitializeTimer( KTIMER *timer )
 410 {
 411     KeInitializeTimerEx(timer, NotificationTimer);
 412 }
 413
 414 /***********************************************************************
 415  *           KeSetTimerEx (NTOSKRNL.EXE.@)
 416  */
 417 BOOLEAN WINAPI KeSetTimerEx( KTIMER *timer, LARGE_INTEGER duetime, LONG period, KDPC *dpc )
 418 {
 419     BOOL ret;
 420
 421     TRACE("timer %p, duetime %s, period %d, dpc %p.\n",
 422         timer, wine_dbgstr_longlong(duetime.QuadPart), period, dpc);
 423
 424     if (dpc)
 425     {
 426         FIXME("Unhandled DPC %p.\n", dpc);
 427         return FALSE;
 428     }
 429
 430     EnterCriticalSection( &sync_cs );
 431
 432     ret = timer->Header.Inserted;
 433     timer->Header.Inserted = TRUE;
 434     timer->Header.WaitListHead.Blink = CreateWaitableTimerW( NULL, timer->Header.Type == TYPE_MANUAL_TIMER, NULL );
 435     SetWaitableTimer( timer->Header.WaitListHead.Blink, &duetime, period, NULL, NULL, FALSE );
 436
 437     LeaveCriticalSection( &sync_cs );
 438
 439     return ret;
 440 }
 441
 442 BOOLEAN WINAPI KeCancelTimer( KTIMER *timer )
 443 {
 444     BOOL ret;
 445
 446     TRACE("timer %p.\n", timer);
 447
 448     EnterCriticalSection( &sync_cs );
 449     ret = timer->Header.Inserted;
 450     timer->Header.Inserted = FALSE;
 451     CloseHandle(timer->Header.WaitListHead.Blink);
 452     timer->Header.WaitListHead.Blink = NULL;
 453     LeaveCriticalSection( &sync_cs );
 454
 455     return ret;
 456 }
 457
 458 /***********************************************************************
 459  *           KeDelayExecutionThread  (NTOSKRNL.EXE.@)
 460  */
 461 NTSTATUS WINAPI KeDelayExecutionThread( KPROCESSOR_MODE mode, BOOLEAN alertable, LARGE_INTEGER *timeout )
 462 {
 463     TRACE("mode %d, alertable %u, timeout %p.\n", mode, alertable, timeout);
 464     return NtDelayExecution( alertable, timeout );
 465 }
 466
 467 /***********************************************************************
 468  *           KeInitializeSpinLock   (NTOSKRNL.EXE.@)
 469  */
 470 void WINAPI KeInitializeSpinLock( KSPIN_LOCK *lock )
 471 {
 472     TRACE("lock %p.\n", lock);
 473     *lock = 0;
 474 }
 475
 476 static inline void small_pause(void)
 477 {
 478 #ifdef __x86_64__
 479     __asm__ __volatile__( "rep;nop" : : : "memory" );
 480 #else
 481     __asm__ __volatile__( "" : : : "memory" );
 482 #endif
 483 }
 484
 485 /***********************************************************************
 486  *           KeAcquireSpinLockAtDpcLevel (NTOSKRNL.EXE.@)
 487  */
 488 void WINAPI KeAcquireSpinLockAtDpcLevel( KSPIN_LOCK *lock )
 489 {
 490     TRACE("lock %p.\n", lock);
 491     while (!InterlockedCompareExchangePointer( (void **)lock, (void *)1, (void *)0 ))
 492         small_pause();
 493 }
 494
 495 /***********************************************************************
 496  *           KeReleaseSpinLockFromDpcLevel (NTOSKRNL.EXE.@)
 497  */
 498 void WINAPI KeReleaseSpinLockFromDpcLevel( KSPIN_LOCK *lock )
 499 {
 500     TRACE("lock %p.\n", lock);
 501     InterlockedExchangePointer( (void **)lock, 0 );
 502 }
 503
 504 #define QUEUED_SPINLOCK_OWNED   0x2
 505
 506 /***********************************************************************
 507  *           KeAcquireInStackQueuedSpinLockAtDpcLevel  (NTOSKRNL.EXE.@)
 508  */
 509 DEFINE_FASTCALL_WRAPPER( KeAcquireInStackQueuedSpinLockAtDpcLevel, 8 )
 510 void FASTCALL KeAcquireInStackQueuedSpinLockAtDpcLevel( KSPIN_LOCK *lock, KLOCK_QUEUE_HANDLE *queue )
 511 {
 512     KSPIN_LOCK_QUEUE *tail;
 513
 514     TRACE("lock %p, queue %p.\n", lock, queue);
 515
 516     queue->LockQueue.Next = NULL;
 517
 518     if (!(tail = InterlockedExchangePointer( (void **)lock, &queue->LockQueue )))
 519         queue->LockQueue.Lock = (KSPIN_LOCK *)((ULONG_PTR)lock | QUEUED_SPINLOCK_OWNED);
 520     else
 521     {
 522         queue->LockQueue.Lock = lock;
 523         InterlockedExchangePointer( (void **)&tail->Next, &queue->LockQueue );
 524
 525         while (!((ULONG_PTR)InterlockedCompareExchangePointer( (void **)&queue->LockQueue.Lock, 0, 0 )
 526                  & QUEUED_SPINLOCK_OWNED))
 527         {
 528             small_pause();
 529         }
 530     }
 531 }
 532
 533 /***********************************************************************
 534  *           KeReleaseInStackQueuedSpinLockFromDpcLevel  (NTOSKRNL.EXE.@)
 535  */
 536 DEFINE_FASTCALL1_WRAPPER( KeReleaseInStackQueuedSpinLockFromDpcLevel )
 537 void FASTCALL KeReleaseInStackQueuedSpinLockFromDpcLevel( KLOCK_QUEUE_HANDLE *queue )
 538 {
 539     KSPIN_LOCK *lock = (KSPIN_LOCK *)((ULONG_PTR)queue->LockQueue.Lock & ~QUEUED_SPINLOCK_OWNED);
 540     KSPIN_LOCK_QUEUE *next;
 541
 542     TRACE("lock %p, queue %p.\n", lock, queue);
 543
 544     queue->LockQueue.Lock = NULL;
 545
 546     if (!(next = queue->LockQueue.Next))
 547     {
 548         /* If we are truly the last in the queue, the lock will point to us. */
 549         if (InterlockedCompareExchangePointer( (void **)lock, NULL, &queue->LockQueue ) == queue)
 550             return;
 551
 552         /* Otherwise, someone just queued themselves, but hasn't yet set
 553          * themselves as successor. Spin waiting for them to do so. */
 554         while (!(next = queue->LockQueue.Next))
 555             small_pause();
 556     }
 557
 558     InterlockedExchangePointer( (void **)&next->Lock, (KSPIN_LOCK *)((ULONG_PTR)lock | QUEUED_SPINLOCK_OWNED) );
 559 }
 560
 561 #ifndef __i386__
 562 /***********************************************************************
 563  *           KeReleaseSpinLock (NTOSKRNL.EXE.@)
 564  */
 565 void WINAPI KeReleaseSpinLock( KSPIN_LOCK *lock, KIRQL irql )
 566 {
 567     TRACE("lock %p, irql %u.\n", lock, irql);
 568     KeReleaseSpinLockFromDpcLevel( lock );
 569 }
 570
 571 /***********************************************************************
 572  *           KeAcquireSpinLockRaiseToDpc (NTOSKRNL.EXE.@)
 573  */
 574 KIRQL WINAPI KeAcquireSpinLockRaiseToDpc( KSPIN_LOCK *lock )
 575 {
 576     TRACE("lock %p.\n", lock);
 577     KeAcquireSpinLockAtDpcLevel( lock );
 578     return 0;
 579 }
 580
 581 /***********************************************************************
 582  *           KeAcquireInStackQueuedSpinLock (NTOSKRNL.EXE.@)
 583  */
 584 void WINAPI KeAcquireInStackQueuedSpinLock( KSPIN_LOCK *lock, KLOCK_QUEUE_HANDLE *queue )
 585 {
 586     TRACE("lock %p, queue %p.\n", lock, queue);
 587     KeAcquireInStackQueuedSpinLockAtDpcLevel( lock, queue );
 588 }
 589
 590 /***********************************************************************
 591  *           KeReleaseInStackQueuedSpinLock (NTOSKRNL.EXE.@)
 592  */
 593 void WINAPI KeReleaseInStackQueuedSpinLock( KLOCK_QUEUE_HANDLE *queue )
 594 {
 595     TRACE("queue %p.\n", queue);
 596     KeReleaseInStackQueuedSpinLockFromDpcLevel( queue );
 597 }
 598 #endif
 599
 600 static KSPIN_LOCK cancel_lock;
 601
 602 /***********************************************************************
 603  *           IoAcquireCancelSpinLock  (NTOSKRNL.EXE.@)
 604  */
 605 void WINAPI IoAcquireCancelSpinLock( KIRQL *irql )
 606 {
 607     TRACE("irql %p.\n", irql);
 608     KeAcquireSpinLock( &cancel_lock, irql );
 609 }
 610
 611 /***********************************************************************
 612  *           IoReleaseCancelSpinLock  (NTOSKRNL.EXE.@)
 613  */
 614 void WINAPI IoReleaseCancelSpinLock( KIRQL irql )
 615 {
 616     TRACE("irql %u.\n", irql);
 617     KeReleaseSpinLock( &cancel_lock, irql );
 618 }
 619
 620 /***********************************************************************
 621  *           ExfInterlockedRemoveHeadList  (NTOSKRNL.EXE.@)
 622  */
 623 DEFINE_FASTCALL_WRAPPER( ExfInterlockedRemoveHeadList, 8 )
 624 PLIST_ENTRY FASTCALL ExfInterlockedRemoveHeadList( LIST_ENTRY *list, KSPIN_LOCK *lock )
 625 {
 626     return ExInterlockedRemoveHeadList( list, lock );
 627 }
 628
 629 /***********************************************************************
 630  *           ExInterlockedRemoveHeadList  (NTOSKRNL.EXE.@)
 631  */
 632 LIST_ENTRY * WINAPI ExInterlockedRemoveHeadList( LIST_ENTRY *list, KSPIN_LOCK *lock )
 633 {
 634     LIST_ENTRY *ret;
 635     KIRQL irql;
 636
 637     TRACE("list %p, lock %p.\n", list, lock);
 638
 639     KeAcquireSpinLock( lock, &irql );
 640     ret = RemoveHeadList( list );
 641     KeReleaseSpinLock( lock, irql );
 642
 643     return ret;
 644 }
 645
 646
 647 /***********************************************************************
 648  *           InterlockedPopEntrySList   (NTOSKRNL.EXE.@)
 649  */
 650 DEFINE_FASTCALL1_WRAPPER( NTOSKRNL_InterlockedPopEntrySList )
 651 PSLIST_ENTRY FASTCALL NTOSKRNL_InterlockedPopEntrySList( PSLIST_HEADER list )
 652 {
 653     return RtlInterlockedPopEntrySList( list );
 654 }
 655
 656
 657 /***********************************************************************
 658  *           InterlockedPushEntrySList   (NTOSKRNL.EXE.@)
 659  */
 660 DEFINE_FASTCALL_WRAPPER( NTOSKRNL_InterlockedPushEntrySList, 8 )
 661 PSLIST_ENTRY FASTCALL NTOSKRNL_InterlockedPushEntrySList( PSLIST_HEADER list, PSLIST_ENTRY entry )
 662 {
 663     return RtlInterlockedPushEntrySList( list, entry );
 664 }
 665
 666
 667 /***********************************************************************
 668  *           ExInterlockedPopEntrySList   (NTOSKRNL.EXE.@)
 669  */
 670 DEFINE_FASTCALL_WRAPPER( NTOSKRNL_ExInterlockedPopEntrySList, 8 )
 671 PSLIST_ENTRY FASTCALL NTOSKRNL_ExInterlockedPopEntrySList( PSLIST_HEADER list, PKSPIN_LOCK lock )
 672 {
 673     return RtlInterlockedPopEntrySList( list );
 674 }
 675
 676
 677 /***********************************************************************
 678  *           ExInterlockedPushEntrySList   (NTOSKRNL.EXE.@)
 679  */
 680 DEFINE_FASTCALL_WRAPPER( NTOSKRNL_ExInterlockedPushEntrySList, 12 )
 681 PSLIST_ENTRY FASTCALL NTOSKRNL_ExInterlockedPushEntrySList( PSLIST_HEADER list, PSLIST_ENTRY entry, PKSPIN_LOCK lock )
 682 {
 683     return RtlInterlockedPushEntrySList( list, entry );
 684 }
 685
 686
 687 /***********************************************************************
 688  *           ExInterlockedFlushSList   (NTOSKRNL.EXE.@)
 689  */
 690 DEFINE_FASTCALL1_WRAPPER( NTOSKRNL_ExInterlockedFlushSList )
 691 PSLIST_ENTRY FASTCALL NTOSKRNL_ExInterlockedFlushSList( PSLIST_HEADER list )
 692 {
 693     return RtlInterlockedFlushSList( list );
 694 }
 695
 696
 697 /***********************************************************************
 698  *           ExAcquireFastMutexUnsafe  (NTOSKRNL.EXE.@)
 699  */
 700 DEFINE_FASTCALL1_WRAPPER(ExAcquireFastMutexUnsafe)
 701 void FASTCALL ExAcquireFastMutexUnsafe( FAST_MUTEX *mutex )
 702 {
 703     LONG count;
 704
 705     TRACE("mutex %p.\n", mutex);
 706
 707     count = InterlockedDecrement( &mutex->Count );
 708     if (count < 0)
 709         KeWaitForSingleObject( &mutex->Event, Executive, KernelMode, FALSE, NULL );
 710 }
 711
 712 /***********************************************************************
 713  *           ExReleaseFastMutexUnsafe  (NTOSKRNL.EXE.@)
 714  */
 715 DEFINE_FASTCALL1_WRAPPER(ExReleaseFastMutexUnsafe)
 716 void FASTCALL ExReleaseFastMutexUnsafe( FAST_MUTEX *mutex )
 717 {
 718     LONG count;
 719
 720     TRACE("mutex %p.\n", mutex);
 721
 722     count = InterlockedIncrement( &mutex->Count );
 723     if (count < 1)
 724         KeSetEvent( &mutex->Event, IO_NO_INCREMENT, FALSE );
 725 }
 726
 727 #ifndef __i386__
 728
 729 /***********************************************************************
 730  *           ExAcquireFastMutex    (NTOSKRNL.@)
 731  */
 732 void WINAPI ExAcquireFastMutex( FAST_MUTEX *mutex )
 733 {
 734     /* FIXME: lower IRQL */
 735     ExAcquireFastMutexUnsafe( mutex );
 736 }
 737
 738 /***********************************************************************
 739  *           ExReleaseFastMutex    (NTOSKRNL.@)
 740  */
 741 void WINAPI ExReleaseFastMutex( FAST_MUTEX *mutex )
 742 {
 743     ExReleaseFastMutexUnsafe( mutex );
 744     /* FIXME: restore IRQL */
 745 }
 746
 747 #endif /* __i386__ */
 748
 749 /* Use of the fields of an ERESOURCE structure seems to vary wildly between
 750  * Windows versions. The below implementation uses them as follows:
 751  *
 752  * OwnerTable - contains a list of shared owners, including threads which do
 753  *              not currently own the resource
 754  * OwnerTable[i].OwnerThread - shared owner TID
 755  * OwnerTable[i].OwnerCount - recursion count of this shared owner (may be 0)
 756  * OwnerEntry.OwnerThread - the owner TID if exclusively owned
 757  * OwnerEntry.TableSize - the number of entries in OwnerTable, including threads
 758  *                        which do not currently own the resource
 759  * ActiveEntries - total number of acquisitions (incl. recursive ones)
 760  */
 761
 762 /***********************************************************************
 763  *           ExInitializeResourceLite   (NTOSKRNL.EXE.@)
 764  */
 765 NTSTATUS WINAPI ExInitializeResourceLite( ERESOURCE *resource )
 766 {
 767     TRACE("resource %p.\n", resource);
 768     memset(resource, 0, sizeof(*resource));
 769     return STATUS_SUCCESS;
 770 }
 771
 772 /***********************************************************************
 773  *           ExDeleteResourceLite   (NTOSKRNL.EXE.@)
 774  */
 775 NTSTATUS WINAPI ExDeleteResourceLite( ERESOURCE *resource )
 776 {
 777     TRACE("resource %p.\n", resource);
 778     heap_free(resource->OwnerTable);
 779     heap_free(resource->ExclusiveWaiters);
 780     heap_free(resource->SharedWaiters);
 781     return STATUS_SUCCESS;
 782 }
 783
 784 /* Find an existing entry in the shared owner list, or create a new one. */
 785 static OWNER_ENTRY *resource_get_shared_entry( ERESOURCE *resource, ERESOURCE_THREAD thread )
 786 {
 787     ULONG i, count;
 788
 789     for (i = 0; i < resource->OwnerEntry.TableSize; ++i)
 790     {
 791         if (resource->OwnerTable[i].OwnerThread == thread)
 792             return &resource->OwnerTable[i];
 793     }
 794
 795     count = ++resource->OwnerEntry.TableSize;
 796     resource->OwnerTable = heap_realloc(resource->OwnerTable, count * sizeof(*resource->OwnerTable));
 797     resource->OwnerTable[count - 1].OwnerThread = thread;
 798     resource->OwnerTable[count - 1].OwnerCount = 0;
 799
 800     return &resource->OwnerTable[count - 1];
 801 }
 802
 803 /***********************************************************************
 804  *           ExAcquireResourceExclusiveLite  (NTOSKRNL.EXE.@)
 805  */
 806 BOOLEAN WINAPI ExAcquireResourceExclusiveLite( ERESOURCE *resource, BOOLEAN wait )
 807 {
 808     KIRQL irql;
 809
 810     TRACE("resource %p, wait %u.\n", resource, wait);
 811
 812     KeAcquireSpinLock( &resource->SpinLock, &irql );
 813
 814     if (resource->OwnerEntry.OwnerThread == (ERESOURCE_THREAD)KeGetCurrentThread())
 815     {
 816         resource->ActiveEntries++;
 817         KeReleaseSpinLock( &resource->SpinLock, irql );
 818         return TRUE;
 819     }
 820     /* In order to avoid a race between waiting for the ExclusiveWaiters event
 821      * and grabbing the lock, do not grab the resource if it is unclaimed but
 822      * has waiters; instead queue ourselves. */
 823     else if (!resource->ActiveEntries && !resource->NumberOfExclusiveWaiters && !resource->NumberOfSharedWaiters)
 824     {
 825         resource->Flag |= ResourceOwnedExclusive;
 826         resource->OwnerEntry.OwnerThread = (ERESOURCE_THREAD)KeGetCurrentThread();
 827         resource->ActiveEntries++;
 828         KeReleaseSpinLock( &resource->SpinLock, irql );
 829         return TRUE;
 830     }
 831     else if (!wait)
 832     {
 833         KeReleaseSpinLock( &resource->SpinLock, irql );
 834         return FALSE;
 835     }
 836
 837     if (!resource->ExclusiveWaiters)
 838     {
 839         resource->ExclusiveWaiters = heap_alloc( sizeof(*resource->ExclusiveWaiters) );
 840         KeInitializeEvent( resource->ExclusiveWaiters, SynchronizationEvent, FALSE );
 841     }
 842     resource->NumberOfExclusiveWaiters++;
 843
 844     KeReleaseSpinLock( &resource->SpinLock, irql );
 845
 846     KeWaitForSingleObject( resource->ExclusiveWaiters, Executive, KernelMode, FALSE, NULL );
 847
 848     KeAcquireSpinLock( &resource->SpinLock, &irql );
 849
 850     resource->Flag |= ResourceOwnedExclusive;
 851     resource->OwnerEntry.OwnerThread = (ERESOURCE_THREAD)KeGetCurrentThread();
 852     resource->ActiveEntries++;
 853     resource->NumberOfExclusiveWaiters--;
 854
 855     KeReleaseSpinLock( &resource->SpinLock, irql );
 856
 857     return TRUE;
 858 }
 859
 860 /***********************************************************************
 861  *           ExAcquireResourceSharedLite  (NTOSKRNL.EXE.@)
 862  */
 863 BOOLEAN WINAPI ExAcquireResourceSharedLite( ERESOURCE *resource, BOOLEAN wait )
 864 {
 865     OWNER_ENTRY *entry;
 866     KIRQL irql;
 867
 868     TRACE("resource %p, wait %u.\n", resource, wait);
 869
 870     KeAcquireSpinLock( &resource->SpinLock, &irql );
 871
 872     entry = resource_get_shared_entry( resource, (ERESOURCE_THREAD)KeGetCurrentThread() );
 873
 874     if (resource->Flag & ResourceOwnedExclusive)
 875     {
 876         if (resource->OwnerEntry.OwnerThread == (ERESOURCE_THREAD)KeGetCurrentThread())
 877         {
 878             /* We own the resource exclusively, so increase recursion. */
 879             resource->ActiveEntries++;
 880             KeReleaseSpinLock( &resource->SpinLock, irql );
 881             return TRUE;
 882         }
 883     }
 884     else if (entry->OwnerCount || !resource->NumberOfExclusiveWaiters)
 885     {
 886         /* Either we already own the resource shared, or there are no exclusive
 887          * owners or waiters, so we can grab it shared. */
 888         entry->OwnerCount++;
 889         resource->ActiveEntries++;
 890         KeReleaseSpinLock( &resource->SpinLock, irql );
 891         return TRUE;
 892     }
 893
 894     if (!wait)
 895     {
 896         KeReleaseSpinLock( &resource->SpinLock, irql );
 897         return FALSE;
 898     }
 899
 900     if (!resource->SharedWaiters)
 901     {
 902         resource->SharedWaiters = heap_alloc( sizeof(*resource->SharedWaiters) );
 903         KeInitializeSemaphore( resource->SharedWaiters, 0, INT_MAX );
 904     }
 905     resource->NumberOfSharedWaiters++;
 906
 907     KeReleaseSpinLock( &resource->SpinLock, irql );
 908
 909     KeWaitForSingleObject( resource->SharedWaiters, Executive, KernelMode, FALSE, NULL );
 910
 911     KeAcquireSpinLock( &resource->SpinLock, &irql );
 912
 913     entry->OwnerCount++;
 914     resource->ActiveEntries++;
 915     resource->NumberOfSharedWaiters--;
 916
 917     KeReleaseSpinLock( &resource->SpinLock, irql );
 918
 919     return TRUE;
 920 }
 921
 922 /***********************************************************************
 923  *           ExAcquireSharedStarveExclusive  (NTOSKRNL.EXE.@)
 924  */
 925 BOOLEAN WINAPI ExAcquireSharedStarveExclusive( ERESOURCE *resource, BOOLEAN wait )
 926 {
 927     OWNER_ENTRY *entry;
 928     KIRQL irql;
 929
 930     TRACE("resource %p, wait %u.\n", resource, wait);
 931
 932     KeAcquireSpinLock( &resource->SpinLock, &irql );
 933
 934     entry = resource_get_shared_entry( resource, (ERESOURCE_THREAD)KeGetCurrentThread() );
 935
 936     if (resource->Flag & ResourceOwnedExclusive)
 937     {
 938         if (resource->OwnerEntry.OwnerThread == (ERESOURCE_THREAD)KeGetCurrentThread())
 939         {
 940             resource->ActiveEntries++;
 941             KeReleaseSpinLock( &resource->SpinLock, irql );
 942             return TRUE;
 943         }
 944     }
 945     /* We are starving exclusive waiters, but we cannot steal the resource out
 946      * from under an exclusive waiter who is about to acquire it. (Because of
 947      * locking, and because exclusive waiters are always waked first, this is
 948      * guaranteed to be the case if the resource is unowned and there are
 949      * exclusive waiters.) */
 950     else if (!(!resource->ActiveEntries && resource->NumberOfExclusiveWaiters))
 951     {
 952         entry->OwnerCount++;
 953         resource->ActiveEntries++;
 954         KeReleaseSpinLock( &resource->SpinLock, irql );
 955         return TRUE;
 956     }
 957
 958     if (!wait)
 959     {
 960         KeReleaseSpinLock( &resource->SpinLock, irql );
 961         return FALSE;
 962     }
 963
 964     if (!resource->SharedWaiters)
 965     {
 966         resource->SharedWaiters = heap_alloc( sizeof(*resource->SharedWaiters) );
 967         KeInitializeSemaphore( resource->SharedWaiters, 0, INT_MAX );
 968     }
 969     resource->NumberOfSharedWaiters++;
 970
 971     KeReleaseSpinLock( &resource->SpinLock, irql );
 972
 973     KeWaitForSingleObject( resource->SharedWaiters, Executive, KernelMode, FALSE, NULL );
 974
 975     KeAcquireSpinLock( &resource->SpinLock, &irql );
 976
 977     entry->OwnerCount++;
 978     resource->ActiveEntries++;
 979     resource->NumberOfSharedWaiters--;
 980
 981     KeReleaseSpinLock( &resource->SpinLock, irql );
 982
 983     return TRUE;
 984 }
 985
 986 /***********************************************************************
 987  *           ExAcquireSharedWaitForExclusive  (NTOSKRNL.EXE.@)
 988  */
 989 BOOLEAN WINAPI ExAcquireSharedWaitForExclusive( ERESOURCE *resource, BOOLEAN wait )
 990 {
 991     OWNER_ENTRY *entry;
 992     KIRQL irql;
 993
 994     TRACE("resource %p, wait %u.\n", resource, wait);
 995
 996     KeAcquireSpinLock( &resource->SpinLock, &irql );
 997
 998     entry = resource_get_shared_entry( resource, (ERESOURCE_THREAD)KeGetCurrentThread() );
 999
1000     if (resource->Flag & ResourceOwnedExclusive)
1001     {
1002         if (resource->OwnerEntry.OwnerThread == (ERESOURCE_THREAD)KeGetCurrentThread())
1003         {
1004             /* We own the resource exclusively, so increase recursion. */
1005             resource->ActiveEntries++;
1006             KeReleaseSpinLock( &resource->SpinLock, irql );
1007             return TRUE;
1008         }
1009     }
1010     /* We may only grab the resource if there are no exclusive waiters, even if
1011      * we already own it shared. */
1012     else if (!resource->NumberOfExclusiveWaiters)
1013     {
1014         entry->OwnerCount++;
1015         resource->ActiveEntries++;
1016         KeReleaseSpinLock( &resource->SpinLock, irql );
1017         return TRUE;
1018     }
1019
1020     if (!wait)
1021     {
1022         KeReleaseSpinLock( &resource->SpinLock, irql );
1023         return FALSE;
1024     }
1025
1026     if (!resource->SharedWaiters)
1027     {
1028         resource->SharedWaiters = heap_alloc( sizeof(*resource->SharedWaiters) );
1029         KeInitializeSemaphore( resource->SharedWaiters, 0, INT_MAX );
1030     }
1031     resource->NumberOfSharedWaiters++;
1032
1033     KeReleaseSpinLock( &resource->SpinLock, irql );
1034
1035     KeWaitForSingleObject( resource->SharedWaiters, Executive, KernelMode, FALSE, NULL );
1036
1037     KeAcquireSpinLock( &resource->SpinLock, &irql );
1038
1039     entry->OwnerCount++;
1040     resource->ActiveEntries++;
1041     resource->NumberOfSharedWaiters--;
1042
1043     KeReleaseSpinLock( &resource->SpinLock, irql );
1044
1045     return TRUE;
1046 }
1047
1048 /***********************************************************************
1049  *           ExReleaseResourceForThreadLite   (NTOSKRNL.EXE.@)
1050  */
1051 void WINAPI ExReleaseResourceForThreadLite( ERESOURCE *resource, ERESOURCE_THREAD thread )
1052 {
1053     OWNER_ENTRY *entry;
1054     KIRQL irql;
1055
1056     TRACE("resource %p, thread %#lx.\n", resource, thread);
1057
1058     KeAcquireSpinLock( &resource->SpinLock, &irql );
1059
1060     if (resource->Flag & ResourceOwnedExclusive)
1061     {
1062         if (resource->OwnerEntry.OwnerThread == thread)
1063         {
1064             if (!--resource->ActiveEntries)
1065             {
1066                 resource->OwnerEntry.OwnerThread = 0;
1067                 resource->Flag &= ~ResourceOwnedExclusive;
1068             }
1069         }
1070         else
1071         {
1072             ERR("Trying to release %p for thread %#lx, but resource is exclusively owned by %#lx.\n",
1073                     resource, thread, resource->OwnerEntry.OwnerThread);
1074             return;
1075         }
1076     }
1077     else
1078     {
1079         entry = resource_get_shared_entry( resource, thread );
1080         if (entry->OwnerCount)
1081         {
1082             entry->OwnerCount--;
1083             resource->ActiveEntries--;
1084         }
1085         else
1086         {
1087             ERR("Trying to release %p for thread %#lx, but resource is not owned by that thread.\n", resource, thread);
1088             return;
1089         }
1090     }
1091
1092     if (!resource->ActiveEntries)
1093     {
1094         if (resource->NumberOfExclusiveWaiters)
1095         {
1096             KeSetEvent( resource->ExclusiveWaiters, IO_NO_INCREMENT, FALSE );
1097         }
1098         else if (resource->NumberOfSharedWaiters)
1099         {
1100             KeReleaseSemaphore( resource->SharedWaiters, IO_NO_INCREMENT,
1101                     resource->NumberOfSharedWaiters, FALSE );
1102         }
1103     }
1104
1105     KeReleaseSpinLock( &resource->SpinLock, irql );
1106 }
1107
1108 /***********************************************************************
1109  *           ExReleaseResourceLite  (NTOSKRNL.EXE.@)
1110  */
1111 DEFINE_FASTCALL1_WRAPPER( ExReleaseResourceLite )
1112 void FASTCALL ExReleaseResourceLite( ERESOURCE *resource )
1113 {
1114     ExReleaseResourceForThreadLite( resource, (ERESOURCE_THREAD)KeGetCurrentThread() );
1115 }
1116
1117 /***********************************************************************
1118  *           ExGetExclusiveWaiterCount   (NTOSKRNL.EXE.@)
1119  */
1120 ULONG WINAPI ExGetExclusiveWaiterCount( ERESOURCE *resource )
1121 {
1122     ULONG count;
1123     KIRQL irql;
1124
1125     TRACE("resource %p.\n", resource);
1126
1127     KeAcquireSpinLock( &resource->SpinLock, &irql );
1128
1129     count = resource->NumberOfExclusiveWaiters;
1130
1131     KeReleaseSpinLock( &resource->SpinLock, irql );
1132
1133     return count;
1134 }
1135
1136 /***********************************************************************
1137  *           ExGetSharedWaiterCount   (NTOSKRNL.EXE.@)
1138  */
1139 ULONG WINAPI ExGetSharedWaiterCount( ERESOURCE *resource )
1140 {
1141     ULONG count;
1142     KIRQL irql;
1143
1144     TRACE("resource %p.\n", resource);
1145
1146     KeAcquireSpinLock( &resource->SpinLock, &irql );
1147
1148     count = resource->NumberOfSharedWaiters;
1149
1150     KeReleaseSpinLock( &resource->SpinLock, irql );
1151
1152     return count;
1153 }
1154
1155 /***********************************************************************
1156  *           ExIsResourceAcquiredExclusiveLite   (NTOSKRNL.EXE.@)
1157  */
1158 BOOLEAN WINAPI ExIsResourceAcquiredExclusiveLite( ERESOURCE *resource )
1159 {
1160     BOOLEAN ret;
1161     KIRQL irql;
1162
1163     TRACE("resource %p.\n", resource);
1164
1165     KeAcquireSpinLock( &resource->SpinLock, &irql );
1166
1167     ret = (resource->OwnerEntry.OwnerThread == (ERESOURCE_THREAD)KeGetCurrentThread());
1168
1169     KeReleaseSpinLock( &resource->SpinLock, irql );
1170
1171     return ret;
1172 }
1173
1174 /***********************************************************************
1175  *           ExIsResourceAcquiredSharedLite   (NTOSKRNL.EXE.@)
1176  */
1177 ULONG WINAPI ExIsResourceAcquiredSharedLite( ERESOURCE *resource )
1178 {
1179     ULONG ret;
1180     KIRQL irql;
1181
1182     TRACE("resource %p.\n", resource);
1183
1184     KeAcquireSpinLock( &resource->SpinLock, &irql );
1185
1186     if (resource->OwnerEntry.OwnerThread == (ERESOURCE_THREAD)KeGetCurrentThread())
1187         ret = resource->ActiveEntries;
1188     else
1189     {
1190         OWNER_ENTRY *entry = resource_get_shared_entry( resource, (ERESOURCE_THREAD)KeGetCurrentThread() );
1191         ret = entry->OwnerCount;
1192     }
1193
1194     KeReleaseSpinLock( &resource->SpinLock, irql );
1195
1196     return ret;
1197 }
1198
1199 /***********************************************************************
1200  *           IoInitializeRemoveLockEx   (NTOSKRNL.EXE.@)
1201  */
1202 void WINAPI IoInitializeRemoveLockEx( IO_REMOVE_LOCK *lock, ULONG tag,
1203         ULONG max_minutes, ULONG max_count, ULONG size )
1204 {
1205     TRACE("lock %p, tag %#x, max_minutes %u, max_count %u, size %u.\n",
1206             lock, tag, max_minutes, max_count, size);
1207
1208     KeInitializeEvent( &lock->Common.RemoveEvent, NotificationEvent, FALSE );
1209     lock->Common.Removed = FALSE;
1210     lock->Common.IoCount = 0;
1211 }
1212
1213 /***********************************************************************
1214  *           IoAcquireRemoveLockEx   (NTOSKRNL.EXE.@)
1215  */
1216 NTSTATUS WINAPI IoAcquireRemoveLockEx( IO_REMOVE_LOCK *lock, void *tag,
1217         const char *file, ULONG line, ULONG size )
1218 {
1219     TRACE("lock %p, tag %p, file %s, line %u, size %u.\n", lock, tag, debugstr_a(file), line, size);
1220
1221     if (lock->Common.Removed)
1222         return STATUS_DELETE_PENDING;
1223
1224     InterlockedIncrement( &lock->Common.IoCount );
1225     return STATUS_SUCCESS;
1226 }
1227
1228 /***********************************************************************
1229  *           IoReleaseRemoveLockEx   (NTOSKRNL.EXE.@)
1230  */
1231 void WINAPI IoReleaseRemoveLockEx( IO_REMOVE_LOCK *lock, void *tag, ULONG size )
1232 {
1233     LONG count;
1234
1235     TRACE("lock %p, tag %p, size %u.\n", lock, tag, size);
1236
1237     if (!(count = InterlockedDecrement( &lock->Common.IoCount )) && lock->Common.Removed)
1238         KeSetEvent( &lock->Common.RemoveEvent, IO_NO_INCREMENT, FALSE );
1239     else if (count < 0)
1240         ERR("Lock %p is not acquired!\n", lock);
1241 }
1242
1243 /***********************************************************************
1244  *           IoReleaseRemoveLockAndWaitEx   (NTOSKRNL.EXE.@)
1245  */
1246 void WINAPI IoReleaseRemoveLockAndWaitEx( IO_REMOVE_LOCK *lock, void *tag, ULONG size )
1247 {
1248     LONG count;
1249
1250     TRACE("lock %p, tag %p, size %u.\n", lock, tag, size);
1251
1252     lock->Common.Removed = TRUE;
1253
1254     if (!(count = InterlockedDecrement( &lock->Common.IoCount )))
1255         KeSetEvent( &lock->Common.RemoveEvent, IO_NO_INCREMENT, FALSE );
1256     else if (count < 0)
1257         ERR("Lock %p is not acquired!\n", lock);
1258     else if (count > 0)
1259         KeWaitForSingleObject( &lock->Common.RemoveEvent, Executive, KernelMode, FALSE, NULL );
1260 }