dlls/msvcrt/lock.c

   1 /*
   2  * Copyright (c) 2002, TransGaming Technologies Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20 #include "wine/port.h"
  21
  22 #include <stdarg.h>
  23
  24 #include "wine/debug.h"
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winternl.h"
  28 #include "wine/heap.h"
  29 #include "msvcrt.h"
  30 #include "cppexcept.h"
  31 #include "mtdll.h"
  32 #include "cxx.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  35
  36 typedef struct
  37 {
  38   BOOL             bInit;
  39   CRITICAL_SECTION crit;
  40 } LOCKTABLEENTRY;
  41
  42 static LOCKTABLEENTRY lock_table[ _TOTAL_LOCKS ];
  43
  44 static inline void msvcrt_mlock_set_entry_initialized( int locknum, BOOL initialized )
  45 {
  46   lock_table[ locknum ].bInit = initialized;
  47 }
  48
  49 static inline void msvcrt_initialize_mlock( int locknum )
  50 {
  51   InitializeCriticalSection( &(lock_table[ locknum ].crit) );
  52   lock_table[ locknum ].crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": LOCKTABLEENTRY.crit");
  53   msvcrt_mlock_set_entry_initialized( locknum, TRUE );
  54 }
  55
  56 static inline void msvcrt_uninitialize_mlock( int locknum )
  57 {
  58   lock_table[ locknum ].crit.DebugInfo->Spare[0] = 0;
  59   DeleteCriticalSection( &(lock_table[ locknum ].crit) );
  60   msvcrt_mlock_set_entry_initialized( locknum, FALSE );
  61 }
  62
  63 /**********************************************************************
  64  *     msvcrt_init_mt_locks (internal)
  65  *
  66  * Initialize the table lock. All other locks will be initialized
  67  * upon first use.
  68  *
  69  */
  70 void msvcrt_init_mt_locks(void)
  71 {
  72   int i;
  73
  74   TRACE( "initializing mtlocks\n" );
  75
  76   /* Initialize the table */
  77   for( i=0; i < _TOTAL_LOCKS; i++ )
  78   {
  79     msvcrt_mlock_set_entry_initialized( i, FALSE );
  80   }
  81
  82   /* Initialize our lock table lock */
  83   msvcrt_initialize_mlock( _LOCKTAB_LOCK );
  84 }
  85
  86 /**********************************************************************
  87  *              _lock (MSVCRT.@)
  88  */
  89 void CDECL _lock( int locknum )
  90 {
  91   TRACE( "(%d)\n", locknum );
  92
  93   /* If the lock doesn't exist yet, create it */
  94   if( lock_table[ locknum ].bInit == FALSE )
  95   {
  96     /* Lock while we're changing the lock table */
  97     _lock( _LOCKTAB_LOCK );
  98
  99     /* Check again if we've got a bit of a race on lock creation */
 100     if( lock_table[ locknum ].bInit == FALSE )
 101     {
 102       TRACE( ": creating lock #%d\n", locknum );
 103       msvcrt_initialize_mlock( locknum );
 104     }
 105
 106     /* Unlock ourselves */
 107     _unlock( _LOCKTAB_LOCK );
 108   }
 109
 110   EnterCriticalSection( &(lock_table[ locknum ].crit) );
 111 }
 112
 113 /**********************************************************************
 114  *              _unlock (MSVCRT.@)
 115  *
 116  * NOTE: There is no error detection to make sure the lock exists and is acquired.
 117  */
 118 void CDECL _unlock( int locknum )
 119 {
 120   TRACE( "(%d)\n", locknum );
 121
 122   LeaveCriticalSection( &(lock_table[ locknum ].crit) );
 123 }
 124
 125 #if _MSVCR_VER >= 100
 126 typedef enum
 127 {
 128     SPINWAIT_INIT,
 129     SPINWAIT_SPIN,
 130     SPINWAIT_YIELD,
 131     SPINWAIT_DONE
 132 } SpinWait_state;
 133
 134 typedef void (__cdecl *yield_func)(void);
 135
 136 typedef struct
 137 {
 138     ULONG spin;
 139     ULONG unknown;
 140     SpinWait_state state;
 141     yield_func yield_func;
 142 } SpinWait;
 143
 144 /* ?_Value@_SpinCount@details@Concurrency@@SAIXZ */
 145 unsigned int __cdecl SpinCount__Value(void)
 146 {
 147     static unsigned int val = -1;
 148
 149     TRACE("()\n");
 150
 151     if(val == -1) {
 152         SYSTEM_INFO si;
 153
 154         GetSystemInfo(&si);
 155         val = si.dwNumberOfProcessors>1 ? 4000 : 0;
 156     }
 157
 158     return val;
 159 }
 160
 161 /* ??0?$_SpinWait@$00@details@Concurrency@@QAE@P6AXXZ@Z */
 162 /* ??0?$_SpinWait@$00@details@Concurrency@@QEAA@P6AXXZ@Z */
 163 DEFINE_THISCALL_WRAPPER(SpinWait_ctor_yield, 8)
 164 SpinWait*  __thiscall SpinWait_ctor_yield(SpinWait *this, yield_func yf)
 165 {
 166     TRACE("(%p %p)\n", this, yf);
 167
 168     this->state = SPINWAIT_INIT;
 169     this->unknown = 1;
 170     this->yield_func = yf;
 171     return this;
 172 }
 173
 174 /* ??0?$_SpinWait@$0A@@details@Concurrency@@QAE@P6AXXZ@Z */
 175 /* ??0?$_SpinWait@$0A@@details@Concurrency@@QEAA@P6AXXZ@Z */
 176 DEFINE_THISCALL_WRAPPER(SpinWait_ctor, 8)
 177 SpinWait* __thiscall SpinWait_ctor(SpinWait *this, yield_func yf)
 178 {
 179     TRACE("(%p %p)\n", this, yf);
 180
 181     this->state = SPINWAIT_INIT;
 182     this->unknown = 0;
 183     this->yield_func = yf;
 184     return this;
 185 }
 186
 187 /* ??_F?$_SpinWait@$00@details@Concurrency@@QAEXXZ */
 188 /* ??_F?$_SpinWait@$00@details@Concurrency@@QEAAXXZ */
 189 /* ??_F?$_SpinWait@$0A@@details@Concurrency@@QAEXXZ */
 190 /* ??_F?$_SpinWait@$0A@@details@Concurrency@@QEAAXXZ */
 191 DEFINE_THISCALL_WRAPPER(SpinWait_dtor, 4)
 192 void __thiscall SpinWait_dtor(SpinWait *this)
 193 {
 194     TRACE("(%p)\n", this);
 195 }
 196
 197 /* ?_DoYield@?$_SpinWait@$00@details@Concurrency@@IAEXXZ */
 198 /* ?_DoYield@?$_SpinWait@$00@details@Concurrency@@IEAAXXZ */
 199 /* ?_DoYield@?$_SpinWait@$0A@@details@Concurrency@@IAEXXZ */
 200 /* ?_DoYield@?$_SpinWait@$0A@@details@Concurrency@@IEAAXXZ */
 201 DEFINE_THISCALL_WRAPPER(SpinWait__DoYield, 4)
 202 void __thiscall SpinWait__DoYield(SpinWait *this)
 203 {
 204     TRACE("(%p)\n", this);
 205
 206     if(this->unknown)
 207         this->yield_func();
 208 }
 209
 210 /* ?_NumberOfSpins@?$_SpinWait@$00@details@Concurrency@@IAEKXZ */
 211 /* ?_NumberOfSpins@?$_SpinWait@$00@details@Concurrency@@IEAAKXZ */
 212 /* ?_NumberOfSpins@?$_SpinWait@$0A@@details@Concurrency@@IAEKXZ */
 213 /* ?_NumberOfSpins@?$_SpinWait@$0A@@details@Concurrency@@IEAAKXZ */
 214 DEFINE_THISCALL_WRAPPER(SpinWait__NumberOfSpins, 4)
 215 ULONG __thiscall SpinWait__NumberOfSpins(SpinWait *this)
 216 {
 217     TRACE("(%p)\n", this);
 218     return 1;
 219 }
 220
 221 /* ?_SetSpinCount@?$_SpinWait@$00@details@Concurrency@@QAEXI@Z */
 222 /* ?_SetSpinCount@?$_SpinWait@$00@details@Concurrency@@QEAAXI@Z */
 223 /* ?_SetSpinCount@?$_SpinWait@$0A@@details@Concurrency@@QAEXI@Z */
 224 /* ?_SetSpinCount@?$_SpinWait@$0A@@details@Concurrency@@QEAAXI@Z */
 225 DEFINE_THISCALL_WRAPPER(SpinWait__SetSpinCount, 8)
 226 void __thiscall SpinWait__SetSpinCount(SpinWait *this, unsigned int spin)
 227 {
 228     TRACE("(%p %d)\n", this, spin);
 229
 230     this->spin = spin;
 231     this->state = spin ? SPINWAIT_SPIN : SPINWAIT_YIELD;
 232 }
 233
 234 /* ?_Reset@?$_SpinWait@$00@details@Concurrency@@IAEXXZ */
 235 /* ?_Reset@?$_SpinWait@$00@details@Concurrency@@IEAAXXZ */
 236 /* ?_Reset@?$_SpinWait@$0A@@details@Concurrency@@IAEXXZ */
 237 /* ?_Reset@?$_SpinWait@$0A@@details@Concurrency@@IEAAXXZ */
 238 DEFINE_THISCALL_WRAPPER(SpinWait__Reset, 4)
 239 void __thiscall SpinWait__Reset(SpinWait *this)
 240 {
 241     SpinWait__SetSpinCount(this, SpinCount__Value());
 242 }
 243
 244 /* ?_ShouldSpinAgain@?$_SpinWait@$00@details@Concurrency@@IAE_NXZ */
 245 /* ?_ShouldSpinAgain@?$_SpinWait@$00@details@Concurrency@@IEAA_NXZ */
 246 /* ?_ShouldSpinAgain@?$_SpinWait@$0A@@details@Concurrency@@IAE_NXZ */
 247 /* ?_ShouldSpinAgain@?$_SpinWait@$0A@@details@Concurrency@@IEAA_NXZ */
 248 DEFINE_THISCALL_WRAPPER(SpinWait__ShouldSpinAgain, 4)
 249 MSVCRT_bool __thiscall SpinWait__ShouldSpinAgain(SpinWait *this)
 250 {
 251     TRACE("(%p)\n", this);
 252
 253     this->spin--;
 254     return this->spin > 0;
 255 }
 256
 257 /* ?_SpinOnce@?$_SpinWait@$00@details@Concurrency@@QAE_NXZ */
 258 /* ?_SpinOnce@?$_SpinWait@$00@details@Concurrency@@QEAA_NXZ */
 259 /* ?_SpinOnce@?$_SpinWait@$0A@@details@Concurrency@@QAE_NXZ */
 260 /* ?_SpinOnce@?$_SpinWait@$0A@@details@Concurrency@@QEAA_NXZ */
 261 DEFINE_THISCALL_WRAPPER(SpinWait__SpinOnce, 4)
 262 MSVCRT_bool __thiscall SpinWait__SpinOnce(SpinWait *this)
 263 {
 264     switch(this->state) {
 265     case SPINWAIT_INIT:
 266         SpinWait__Reset(this);
 267         /* fall through */
 268     case SPINWAIT_SPIN:
 269         InterlockedDecrement((LONG*)&this->spin);
 270         if(!this->spin)
 271             this->state = this->unknown ? SPINWAIT_YIELD : SPINWAIT_DONE;
 272         return TRUE;
 273     case SPINWAIT_YIELD:
 274         this->state = SPINWAIT_DONE;
 275         this->yield_func();
 276         return TRUE;
 277     default:
 278         SpinWait__Reset(this);
 279         return FALSE;
 280     }
 281 }
 282
 283 static HANDLE keyed_event;
 284
 285 /* keep in sync with msvcp90/msvcp90.h */
 286 typedef struct cs_queue
 287 {
 288     struct cs_queue *next;
 289 #if _MSVCR_VER >= 110
 290     BOOL free;
 291     int unknown;
 292 #endif
 293 } cs_queue;
 294
 295 typedef struct
 296 {
 297     ULONG_PTR unk_thread_id;
 298     cs_queue unk_active;
 299 #if _MSVCR_VER >= 110
 300     void *unknown[2];
 301 #else
 302     void *unknown[1];
 303 #endif
 304     cs_queue *head;
 305     void *tail;
 306 } critical_section;
 307
 308 /* ??0critical_section@Concurrency@@QAE@XZ */
 309 /* ??0critical_section@Concurrency@@QEAA@XZ */
 310 DEFINE_THISCALL_WRAPPER(critical_section_ctor, 4)
 311 critical_section* __thiscall critical_section_ctor(critical_section *this)
 312 {
 313     TRACE("(%p)\n", this);
 314
 315     if(!keyed_event) {
 316         HANDLE event;
 317
 318         NtCreateKeyedEvent(&event, GENERIC_READ|GENERIC_WRITE, NULL, 0);
 319         if(InterlockedCompareExchangePointer(&keyed_event, event, NULL) != NULL)
 320             NtClose(event);
 321     }
 322
 323     this->unk_thread_id = 0;
 324     this->head = this->tail = NULL;
 325     return this;
 326 }
 327
 328 /* ??1critical_section@Concurrency@@QAE@XZ */
 329 /* ??1critical_section@Concurrency@@QEAA@XZ */
 330 DEFINE_THISCALL_WRAPPER(critical_section_dtor, 4)
 331 void __thiscall critical_section_dtor(critical_section *this)
 332 {
 333     TRACE("(%p)\n", this);
 334 }
 335
 336 static void __cdecl spin_wait_yield(void)
 337 {
 338     Sleep(0);
 339 }
 340
 341 static inline void spin_wait_for_next_cs(cs_queue *q)
 342 {
 343     SpinWait sw;
 344
 345     if(q->next) return;
 346
 347     SpinWait_ctor(&sw, &spin_wait_yield);
 348     SpinWait__Reset(&sw);
 349     while(!q->next)
 350         SpinWait__SpinOnce(&sw);
 351     SpinWait_dtor(&sw);
 352 }
 353
 354 static inline void cs_set_head(critical_section *cs, cs_queue *q)
 355 {
 356     cs->unk_thread_id = GetCurrentThreadId();
 357     cs->unk_active.next = q->next;
 358     cs->head = &cs->unk_active;
 359 }
 360
 361 static inline void cs_lock(critical_section *cs, cs_queue *q)
 362 {
 363     cs_queue *last;
 364
 365     if(cs->unk_thread_id == GetCurrentThreadId())
 366         throw_exception(EXCEPTION_IMPROPER_LOCK, 0, "Already locked");
 367
 368     memset(q, 0, sizeof(*q));
 369     last = InterlockedExchangePointer(&cs->tail, q);
 370     if(last) {
 371         last->next = q;
 372         NtWaitForKeyedEvent(keyed_event, q, 0, NULL);
 373     }
 374
 375     cs_set_head(cs, q);
 376     if(InterlockedCompareExchangePointer(&cs->tail, &cs->unk_active, q) != q) {
 377         spin_wait_for_next_cs(q);
 378         cs->unk_active.next = q->next;
 379     }
 380 }
 381
 382 /* ?lock@critical_section@Concurrency@@QAEXXZ */
 383 /* ?lock@critical_section@Concurrency@@QEAAXXZ */
 384 DEFINE_THISCALL_WRAPPER(critical_section_lock, 4)
 385 void __thiscall critical_section_lock(critical_section *this)
 386 {
 387     cs_queue q;
 388
 389     TRACE("(%p)\n", this);
 390     cs_lock(this, &q);
 391 }
 392
 393 /* ?try_lock@critical_section@Concurrency@@QAE_NXZ */
 394 /* ?try_lock@critical_section@Concurrency@@QEAA_NXZ */
 395 DEFINE_THISCALL_WRAPPER(critical_section_try_lock, 4)
 396 MSVCRT_bool __thiscall critical_section_try_lock(critical_section *this)
 397 {
 398     cs_queue q;
 399
 400     TRACE("(%p)\n", this);
 401
 402     if(this->unk_thread_id == GetCurrentThreadId())
 403         return FALSE;
 404
 405     memset(&q, 0, sizeof(q));
 406     if(!InterlockedCompareExchangePointer(&this->tail, &q, NULL)) {
 407         cs_set_head(this, &q);
 408         if(InterlockedCompareExchangePointer(&this->tail, &this->unk_active, &q) != &q) {
 409             spin_wait_for_next_cs(&q);
 410             this->unk_active.next = q.next;
 411         }
 412         return TRUE;
 413     }
 414     return FALSE;
 415 }
 416
 417 /* ?unlock@critical_section@Concurrency@@QAEXXZ */
 418 /* ?unlock@critical_section@Concurrency@@QEAAXXZ */
 419 DEFINE_THISCALL_WRAPPER(critical_section_unlock, 4)
 420 void __thiscall critical_section_unlock(critical_section *this)
 421 {
 422     TRACE("(%p)\n", this);
 423
 424     this->unk_thread_id = 0;
 425     this->head = NULL;
 426     if(InterlockedCompareExchangePointer(&this->tail, NULL, &this->unk_active)
 427             == &this->unk_active) return;
 428     spin_wait_for_next_cs(&this->unk_active);
 429
 430 #if _MSVCR_VER >= 110
 431     while(1) {
 432         cs_queue *next;
 433
 434         if(!InterlockedExchange(&this->unk_active.next->free, TRUE))
 435             break;
 436
 437         next = this->unk_active.next;
 438         if(InterlockedCompareExchangePointer(&this->tail, NULL, next) == next) {
 439             HeapFree(GetProcessHeap(), 0, next);
 440             return;
 441         }
 442         spin_wait_for_next_cs(next);
 443
 444         this->unk_active.next = next->next;
 445         HeapFree(GetProcessHeap(), 0, next);
 446     }
 447 #endif
 448
 449     NtReleaseKeyedEvent(keyed_event, this->unk_active.next, 0, NULL);
 450 }
 451
 452 /* ?native_handle@critical_section@Concurrency@@QAEAAV12@XZ */
 453 /* ?native_handle@critical_section@Concurrency@@QEAAAEAV12@XZ */
 454 DEFINE_THISCALL_WRAPPER(critical_section_native_handle, 4)
 455 critical_section* __thiscall critical_section_native_handle(critical_section *this)
 456 {
 457     TRACE("(%p)\n", this);
 458     return this;
 459 }
 460
 461 #if _MSVCR_VER >= 110
 462 /* ?try_lock_for@critical_section@Concurrency@@QAE_NI@Z */
 463 /* ?try_lock_for@critical_section@Concurrency@@QEAA_NI@Z */
 464 DEFINE_THISCALL_WRAPPER(critical_section_try_lock_for, 8)
 465 MSVCRT_bool __thiscall critical_section_try_lock_for(
 466         critical_section *this, unsigned int timeout)
 467 {
 468     cs_queue *q, *last;
 469
 470     TRACE("(%p %d)\n", this, timeout);
 471
 472     if(this->unk_thread_id == GetCurrentThreadId())
 473         throw_exception(EXCEPTION_IMPROPER_LOCK, 0, "Already locked");
 474
 475     if(!(q = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*q))))
 476         return critical_section_try_lock(this);
 477
 478     last = InterlockedExchangePointer(&this->tail, q);
 479     if(last) {
 480         LARGE_INTEGER to;
 481         NTSTATUS status;
 482         FILETIME ft;
 483
 484         last->next = q;
 485         GetSystemTimeAsFileTime(&ft);
 486         to.QuadPart = ((LONGLONG)ft.dwHighDateTime<<32) +
 487             ft.dwLowDateTime + (LONGLONG)timeout*10000;
 488         status = NtWaitForKeyedEvent(keyed_event, q, 0, &to);
 489         if(status == STATUS_TIMEOUT) {
 490             if(!InterlockedExchange(&q->free, TRUE))
 491                 return FALSE;
 492             /* A thread has signaled the event and is block waiting. */
 493             /* We need to catch the event to wake the thread.        */
 494             NtWaitForKeyedEvent(keyed_event, q, 0, NULL);
 495         }
 496     }
 497
 498     cs_set_head(this, q);
 499     if(InterlockedCompareExchangePointer(&this->tail, &this->unk_active, q) != q) {
 500         spin_wait_for_next_cs(q);
 501         this->unk_active.next = q->next;
 502     }
 503
 504     HeapFree(GetProcessHeap(), 0, q);
 505     return TRUE;
 506 }
 507 #endif
 508
 509 typedef struct
 510 {
 511     critical_section *cs;
 512     union {
 513         cs_queue q;
 514         struct {
 515             void *unknown[4];
 516             int unknown2[2];
 517         } unknown;
 518     } lock;
 519 } critical_section_scoped_lock;
 520
 521 /* ??0scoped_lock@critical_section@Concurrency@@QAE@AAV12@@Z */
 522 /* ??0scoped_lock@critical_section@Concurrency@@QEAA@AEAV12@@Z */
 523 DEFINE_THISCALL_WRAPPER(critical_section_scoped_lock_ctor, 8)
 524 critical_section_scoped_lock* __thiscall critical_section_scoped_lock_ctor(
 525         critical_section_scoped_lock *this, critical_section *cs)
 526 {
 527     TRACE("(%p %p)\n", this, cs);
 528     this->cs = cs;
 529     cs_lock(this->cs, &this->lock.q);
 530     return this;
 531 }
 532
 533 /* ??1scoped_lock@critical_section@Concurrency@@QAE@XZ */
 534 /* ??1scoped_lock@critical_section@Concurrency@@QEAA@XZ */
 535 DEFINE_THISCALL_WRAPPER(critical_section_scoped_lock_dtor, 4)
 536 void __thiscall critical_section_scoped_lock_dtor(critical_section_scoped_lock *this)
 537 {
 538     TRACE("(%p)\n", this);
 539     critical_section_unlock(this->cs);
 540 }
 541
 542 typedef struct
 543 {
 544     critical_section cs;
 545 } _NonReentrantPPLLock;
 546
 547 /* ??0_NonReentrantPPLLock@details@Concurrency@@QAE@XZ */
 548 /* ??0_NonReentrantPPLLock@details@Concurrency@@QEAA@XZ */
 549 DEFINE_THISCALL_WRAPPER(_NonReentrantPPLLock_ctor, 4)
 550 _NonReentrantPPLLock* __thiscall _NonReentrantPPLLock_ctor(_NonReentrantPPLLock *this)
 551 {
 552     TRACE("(%p)\n", this);
 553
 554     critical_section_ctor(&this->cs);
 555     return this;
 556 }
 557
 558 /* ?_Acquire@_NonReentrantPPLLock@details@Concurrency@@QAEXPAX@Z */
 559 /* ?_Acquire@_NonReentrantPPLLock@details@Concurrency@@QEAAXPEAX@Z */
 560 DEFINE_THISCALL_WRAPPER(_NonReentrantPPLLock__Acquire, 8)
 561 void __thiscall _NonReentrantPPLLock__Acquire(_NonReentrantPPLLock *this, cs_queue *q)
 562 {
 563     TRACE("(%p %p)\n", this, q);
 564     cs_lock(&this->cs, q);
 565 }
 566
 567 /* ?_Release@_NonReentrantPPLLock@details@Concurrency@@QAEXXZ */
 568 /* ?_Release@_NonReentrantPPLLock@details@Concurrency@@QEAAXXZ */
 569 DEFINE_THISCALL_WRAPPER(_NonReentrantPPLLock__Release, 4)
 570 void __thiscall _NonReentrantPPLLock__Release(_NonReentrantPPLLock *this)
 571 {
 572     TRACE("(%p)\n", this);
 573     critical_section_unlock(&this->cs);
 574 }
 575
 576 typedef struct
 577 {
 578     _NonReentrantPPLLock *lock;
 579     union {
 580         cs_queue q;
 581         struct {
 582             void *unknown[4];
 583             int unknown2[2];
 584         } unknown;
 585     } wait;
 586 } _NonReentrantPPLLock__Scoped_lock;
 587
 588 /* ??0_Scoped_lock@_NonReentrantPPLLock@details@Concurrency@@QAE@AAV123@@Z */
 589 /* ??0_Scoped_lock@_NonReentrantPPLLock@details@Concurrency@@QEAA@AEAV123@@Z */
 590 DEFINE_THISCALL_WRAPPER(_NonReentrantPPLLock__Scoped_lock_ctor, 8)
 591 _NonReentrantPPLLock__Scoped_lock* __thiscall _NonReentrantPPLLock__Scoped_lock_ctor(
 592         _NonReentrantPPLLock__Scoped_lock *this, _NonReentrantPPLLock *lock)
 593 {
 594     TRACE("(%p %p)\n", this, lock);
 595
 596     this->lock = lock;
 597     _NonReentrantPPLLock__Acquire(this->lock, &this->wait.q);
 598     return this;
 599 }
 600
 601 /* ??1_Scoped_lock@_NonReentrantPPLLock@details@Concurrency@@QAE@XZ */
 602 /* ??1_Scoped_lock@_NonReentrantPPLLock@details@Concurrency@@QEAA@XZ */
 603 DEFINE_THISCALL_WRAPPER(_NonReentrantPPLLock__Scoped_lock_dtor, 4)
 604 void __thiscall _NonReentrantPPLLock__Scoped_lock_dtor(_NonReentrantPPLLock__Scoped_lock *this)
 605 {
 606     TRACE("(%p)\n", this);
 607
 608     _NonReentrantPPLLock__Release(this->lock);
 609 }
 610
 611 typedef struct
 612 {
 613     critical_section cs;
 614     LONG count;
 615     LONG owner;
 616 } _ReentrantPPLLock;
 617
 618 /* ??0_ReentrantPPLLock@details@Concurrency@@QAE@XZ */
 619 /* ??0_ReentrantPPLLock@details@Concurrency@@QEAA@XZ */
 620 DEFINE_THISCALL_WRAPPER(_ReentrantPPLLock_ctor, 4)
 621 _ReentrantPPLLock* __thiscall _ReentrantPPLLock_ctor(_ReentrantPPLLock *this)
 622 {
 623     TRACE("(%p)\n", this);
 624
 625     critical_section_ctor(&this->cs);
 626     this->count = 0;
 627     this->owner = -1;
 628     return this;
 629 }
 630
 631 /* ?_Acquire@_ReentrantPPLLock@details@Concurrency@@QAEXPAX@Z */
 632 /* ?_Acquire@_ReentrantPPLLock@details@Concurrency@@QEAAXPEAX@Z */
 633 DEFINE_THISCALL_WRAPPER(_ReentrantPPLLock__Acquire, 8)
 634 void __thiscall _ReentrantPPLLock__Acquire(_ReentrantPPLLock *this, cs_queue *q)
 635 {
 636     TRACE("(%p %p)\n", this, q);
 637
 638     if(this->owner == GetCurrentThreadId()) {
 639         this->count++;
 640         return;
 641     }
 642
 643     cs_lock(&this->cs, q);
 644     this->count++;
 645     this->owner = GetCurrentThreadId();
 646 }
 647
 648 /* ?_Release@_ReentrantPPLLock@details@Concurrency@@QAEXXZ */
 649 /* ?_Release@_ReentrantPPLLock@details@Concurrency@@QEAAXXZ */
 650 DEFINE_THISCALL_WRAPPER(_ReentrantPPLLock__Release, 4)
 651 void __thiscall _ReentrantPPLLock__Release(_ReentrantPPLLock *this)
 652 {
 653     TRACE("(%p)\n", this);
 654
 655     this->count--;
 656     if(this->count)
 657         return;
 658
 659     this->owner = -1;
 660     critical_section_unlock(&this->cs);
 661 }
 662
 663 typedef struct
 664 {
 665     _ReentrantPPLLock *lock;
 666     union {
 667         cs_queue q;
 668         struct {
 669             void *unknown[4];
 670             int unknown2[2];
 671         } unknown;
 672     } wait;
 673 } _ReentrantPPLLock__Scoped_lock;
 674
 675 /* ??0_Scoped_lock@_ReentrantPPLLock@details@Concurrency@@QAE@AAV123@@Z */
 676 /* ??0_Scoped_lock@_ReentrantPPLLock@details@Concurrency@@QEAA@AEAV123@@Z */
 677 DEFINE_THISCALL_WRAPPER(_ReentrantPPLLock__Scoped_lock_ctor, 8)
 678 _ReentrantPPLLock__Scoped_lock* __thiscall _ReentrantPPLLock__Scoped_lock_ctor(
 679         _ReentrantPPLLock__Scoped_lock *this, _ReentrantPPLLock *lock)
 680 {
 681     TRACE("(%p %p)\n", this, lock);
 682
 683     this->lock = lock;
 684     _ReentrantPPLLock__Acquire(this->lock, &this->wait.q);
 685     return this;
 686 }
 687
 688 /* ??1_Scoped_lock@_ReentrantPPLLock@details@Concurrency@@QAE@XZ */
 689 /* ??1_Scoped_lock@_ReentrantPPLLock@details@Concurrency@@QEAA@XZ */
 690 DEFINE_THISCALL_WRAPPER(_ReentrantPPLLock__Scoped_lock_dtor, 4)
 691 void __thiscall _ReentrantPPLLock__Scoped_lock_dtor(_ReentrantPPLLock__Scoped_lock *this)
 692 {
 693     TRACE("(%p)\n", this);
 694
 695     _ReentrantPPLLock__Release(this->lock);
 696 }
 697
 698 /* ?_GetConcurrency@details@Concurrency@@YAIXZ */
 699 unsigned int __cdecl _GetConcurrency(void)
 700 {
 701     static unsigned int val = -1;
 702
 703     TRACE("()\n");
 704
 705     if(val == -1) {
 706         SYSTEM_INFO si;
 707
 708         GetSystemInfo(&si);
 709         val = si.dwNumberOfProcessors;
 710     }
 711
 712     return val;
 713 }
 714
 715 #define EVT_RUNNING     (void*)1
 716 #define EVT_WAITING     NULL
 717
 718 struct thread_wait;
 719 typedef struct thread_wait_entry
 720 {
 721     struct thread_wait *wait;
 722     struct thread_wait_entry *next;
 723     struct thread_wait_entry *prev;
 724 } thread_wait_entry;
 725
 726 typedef struct thread_wait
 727 {
 728     void *signaled;
 729     int pending_waits;
 730     thread_wait_entry entries[1];
 731 } thread_wait;
 732
 733 typedef struct
 734 {
 735     thread_wait_entry *waiters;
 736     INT_PTR signaled;
 737     critical_section cs;
 738 } event;
 739
 740 static inline PLARGE_INTEGER evt_timeout(PLARGE_INTEGER pTime, unsigned int timeout)
 741 {
 742     if(timeout == COOPERATIVE_TIMEOUT_INFINITE) return NULL;
 743     pTime->QuadPart = (ULONGLONG)timeout * -10000;
 744     return pTime;
 745 }
 746
 747 static void evt_add_queue(thread_wait_entry **head, thread_wait_entry *entry)
 748 {
 749     entry->next = *head;
 750     entry->prev = NULL;
 751     if(*head) (*head)->prev = entry;
 752     *head = entry;
 753 }
 754
 755 static void evt_remove_queue(thread_wait_entry **head, thread_wait_entry *entry)
 756 {
 757     if(entry == *head)
 758         *head = entry->next;
 759     else if(entry->prev)
 760         entry->prev->next = entry->next;
 761     if(entry->next) entry->next->prev = entry->prev;
 762 }
 763
 764 static MSVCRT_size_t evt_end_wait(thread_wait *wait, event **events, int count)
 765 {
 766     MSVCRT_size_t i, ret = COOPERATIVE_WAIT_TIMEOUT;
 767
 768     for(i = 0; i < count; i++) {
 769         critical_section_lock(&events[i]->cs);
 770         if(events[i] == wait->signaled) ret = i;
 771         evt_remove_queue(&events[i]->waiters, &wait->entries[i]);
 772         critical_section_unlock(&events[i]->cs);
 773     }
 774
 775     return ret;
 776 }
 777
 778 static inline int evt_transition(void **state, void *from, void *to)
 779 {
 780     return InterlockedCompareExchangePointer(state, to, from) == from;
 781 }
 782
 783 static MSVCRT_size_t evt_wait(thread_wait *wait, event **events, int count, MSVCRT_bool wait_all, unsigned int timeout)
 784 {
 785     int i;
 786     NTSTATUS status;
 787     LARGE_INTEGER ntto;
 788
 789     wait->signaled = EVT_RUNNING;
 790     wait->pending_waits = wait_all ? count : 1;
 791     for(i = 0; i < count; i++) {
 792         wait->entries[i].wait = wait;
 793
 794         critical_section_lock(&events[i]->cs);
 795         evt_add_queue(&events[i]->waiters, &wait->entries[i]);
 796         if(events[i]->signaled) {
 797             if(!InterlockedDecrement(&wait->pending_waits)) {
 798                 wait->signaled = events[i];
 799                 critical_section_unlock(&events[i]->cs);
 800
 801                 return evt_end_wait(wait, events, i+1);
 802             }
 803         }
 804         critical_section_unlock(&events[i]->cs);
 805     }
 806
 807     if(!timeout)
 808         return evt_end_wait(wait, events, count);
 809
 810     if(!evt_transition(&wait->signaled, EVT_RUNNING, EVT_WAITING))
 811         return evt_end_wait(wait, events, count);
 812
 813     status = NtWaitForKeyedEvent(keyed_event, wait, 0, evt_timeout(&ntto, timeout));
 814
 815     if(status && !evt_transition(&wait->signaled, EVT_WAITING, EVT_RUNNING))
 816         NtWaitForKeyedEvent(keyed_event, wait, 0, NULL);
 817
 818     return evt_end_wait(wait, events, count);
 819 }
 820
 821 /* ??0event@Concurrency@@QAE@XZ */
 822 /* ??0event@Concurrency@@QEAA@XZ */
 823 DEFINE_THISCALL_WRAPPER(event_ctor, 4)
 824 event* __thiscall event_ctor(event *this)
 825 {
 826     TRACE("(%p)\n", this);
 827
 828     this->waiters = NULL;
 829     this->signaled = FALSE;
 830     critical_section_ctor(&this->cs);
 831
 832     return this;
 833 }
 834
 835 /* ??1event@Concurrency@@QAE@XZ */
 836 /* ??1event@Concurrency@@QEAA@XZ */
 837 DEFINE_THISCALL_WRAPPER(event_dtor, 4)
 838 void __thiscall event_dtor(event *this)
 839 {
 840     TRACE("(%p)\n", this);
 841     critical_section_dtor(&this->cs);
 842     if(this->waiters)
 843         ERR("there's a wait on destroyed event\n");
 844 }
 845
 846 /* ?reset@event@Concurrency@@QAEXXZ */
 847 /* ?reset@event@Concurrency@@QEAAXXZ */
 848 DEFINE_THISCALL_WRAPPER(event_reset, 4)
 849 void __thiscall event_reset(event *this)
 850 {
 851     thread_wait_entry *entry;
 852
 853     TRACE("(%p)\n", this);
 854
 855     critical_section_lock(&this->cs);
 856     if(this->signaled) {
 857         this->signaled = FALSE;
 858         for(entry=this->waiters; entry; entry = entry->next)
 859             InterlockedIncrement(&entry->wait->pending_waits);
 860     }
 861     critical_section_unlock(&this->cs);
 862 }
 863
 864 /* ?set@event@Concurrency@@QAEXXZ */
 865 /* ?set@event@Concurrency@@QEAAXXZ */
 866 DEFINE_THISCALL_WRAPPER(event_set, 4)
 867 void __thiscall event_set(event *this)
 868 {
 869     thread_wait_entry *wakeup = NULL;
 870     thread_wait_entry *entry, *next;
 871
 872     TRACE("(%p)\n", this);
 873
 874     critical_section_lock(&this->cs);
 875     if(!this->signaled) {
 876         this->signaled = TRUE;
 877         for(entry=this->waiters; entry; entry=next) {
 878             next = entry->next;
 879             if(!InterlockedDecrement(&entry->wait->pending_waits)) {
 880                 if(InterlockedExchangePointer(&entry->wait->signaled, this) == EVT_WAITING) {
 881                     evt_remove_queue(&this->waiters, entry);
 882                     evt_add_queue(&wakeup, entry);
 883                 }
 884             }
 885         }
 886     }
 887     critical_section_unlock(&this->cs);
 888
 889     for(entry=wakeup; entry; entry=next) {
 890         next = entry->next;
 891         entry->next = entry->prev = NULL;
 892         NtReleaseKeyedEvent(keyed_event, entry->wait, 0, NULL);
 893     }
 894 }
 895
 896 /* ?wait@event@Concurrency@@QAEII@Z */
 897 /* ?wait@event@Concurrency@@QEAA_KI@Z */
 898 DEFINE_THISCALL_WRAPPER(event_wait, 8)
 899 MSVCRT_size_t __thiscall event_wait(event *this, unsigned int timeout)
 900 {
 901     thread_wait wait;
 902     MSVCRT_size_t signaled;
 903
 904     TRACE("(%p %u)\n", this, timeout);
 905
 906     critical_section_lock(&this->cs);
 907     signaled = this->signaled;
 908     critical_section_unlock(&this->cs);
 909
 910     if(!timeout) return signaled ? 0 : COOPERATIVE_WAIT_TIMEOUT;
 911     return signaled ? 0 : evt_wait(&wait, &this, 1, FALSE, timeout);
 912 }
 913
 914 /* ?wait_for_multiple@event@Concurrency@@SAIPAPAV12@I_NI@Z */
 915 /* ?wait_for_multiple@event@Concurrency@@SA_KPEAPEAV12@_K_NI@Z */
 916 int __cdecl event_wait_for_multiple(event **events, MSVCRT_size_t count, MSVCRT_bool wait_all, unsigned int timeout)
 917 {
 918     thread_wait *wait;
 919     MSVCRT_size_t ret;
 920
 921     TRACE("(%p %ld %d %u)\n", events, count, wait_all, timeout);
 922
 923     if(count == 0)
 924         return 0;
 925
 926     wait = heap_alloc(FIELD_OFFSET(thread_wait, entries[count]));
 927     if(!wait)
 928         throw_exception(EXCEPTION_BAD_ALLOC, 0, "bad allocation");
 929     ret = evt_wait(wait, events, count, wait_all, timeout);
 930     heap_free(wait);
 931
 932     return ret;
 933 }
 934 #endif
 935
 936 #if _MSVCR_VER >= 110
 937 typedef struct cv_queue {
 938     struct cv_queue *next;
 939     BOOL expired;
 940 } cv_queue;
 941
 942 typedef struct {
 943     /* cv_queue structure is not binary compatible */
 944     cv_queue *queue;
 945     critical_section lock;
 946 } _Condition_variable;
 947
 948 /* ??0_Condition_variable@details@Concurrency@@QAE@XZ */
 949 /* ??0_Condition_variable@details@Concurrency@@QEAA@XZ */
 950 DEFINE_THISCALL_WRAPPER(_Condition_variable_ctor, 4)
 951 _Condition_variable* __thiscall _Condition_variable_ctor(_Condition_variable *this)
 952 {
 953     TRACE("(%p)\n", this);
 954
 955     this->queue = NULL;
 956     critical_section_ctor(&this->lock);
 957     return this;
 958 }
 959
 960 /* ??1_Condition_variable@details@Concurrency@@QAE@XZ */
 961 /* ??1_Condition_variable@details@Concurrency@@QEAA@XZ */
 962 DEFINE_THISCALL_WRAPPER(_Condition_variable_dtor, 4)
 963 void __thiscall _Condition_variable_dtor(_Condition_variable *this)
 964 {
 965     TRACE("(%p)\n", this);
 966
 967     while(this->queue) {
 968         cv_queue *next = this->queue->next;
 969         if(!this->queue->expired)
 970             ERR("there's an active wait\n");
 971         HeapFree(GetProcessHeap(), 0, this->queue);
 972         this->queue = next;
 973     }
 974     critical_section_dtor(&this->lock);
 975 }
 976
 977 /* ?wait@_Condition_variable@details@Concurrency@@QAEXAAVcritical_section@3@@Z */
 978 /* ?wait@_Condition_variable@details@Concurrency@@QEAAXAEAVcritical_section@3@@Z */
 979 DEFINE_THISCALL_WRAPPER(_Condition_variable_wait, 8)
 980 void __thiscall _Condition_variable_wait(_Condition_variable *this, critical_section *cs)
 981 {
 982     cv_queue q;
 983
 984     TRACE("(%p, %p)\n", this, cs);
 985
 986     critical_section_lock(&this->lock);
 987     q.next = this->queue;
 988     q.expired = FALSE;
 989     this->queue = &q;
 990     critical_section_unlock(&this->lock);
 991
 992     critical_section_unlock(cs);
 993     NtWaitForKeyedEvent(keyed_event, &q, 0, NULL);
 994     critical_section_lock(cs);
 995 }
 996
 997 /* ?wait_for@_Condition_variable@details@Concurrency@@QAE_NAAVcritical_section@3@I@Z */
 998 /* ?wait_for@_Condition_variable@details@Concurrency@@QEAA_NAEAVcritical_section@3@I@Z */
 999 DEFINE_THISCALL_WRAPPER(_Condition_variable_wait_for, 12)
1000 MSVCRT_bool __thiscall _Condition_variable_wait_for(_Condition_variable *this,
1001         critical_section *cs, unsigned int timeout)
1002 {
1003     LARGE_INTEGER to;
1004     NTSTATUS status;
1005     FILETIME ft;
1006     cv_queue *q;
1007
1008     TRACE("(%p %p %d)\n", this, cs, timeout);
1009
1010     if(!(q = HeapAlloc(GetProcessHeap(), 0, sizeof(cv_queue)))) {
1011         throw_exception(EXCEPTION_BAD_ALLOC, 0, "bad allocation");
1012     }
1013
1014     critical_section_lock(&this->lock);
1015     q->next = this->queue;
1016     q->expired = FALSE;
1017     this->queue = q;
1018     critical_section_unlock(&this->lock);
1019
1020     critical_section_unlock(cs);
1021
1022     GetSystemTimeAsFileTime(&ft);
1023     to.QuadPart = ((LONGLONG)ft.dwHighDateTime << 32) +
1024         ft.dwLowDateTime + (LONGLONG)timeout * 10000;
1025     status = NtWaitForKeyedEvent(keyed_event, q, 0, &to);
1026     if(status == STATUS_TIMEOUT) {
1027         if(!InterlockedExchange(&q->expired, TRUE)) {
1028             critical_section_lock(cs);
1029             return FALSE;
1030         }
1031         else
1032             NtWaitForKeyedEvent(keyed_event, q, 0, 0);
1033     }
1034
1035     HeapFree(GetProcessHeap(), 0, q);
1036     critical_section_lock(cs);
1037     return TRUE;
1038 }
1039
1040 /* ?notify_one@_Condition_variable@details@Concurrency@@QAEXXZ */
1041 /* ?notify_one@_Condition_variable@details@Concurrency@@QEAAXXZ */
1042 DEFINE_THISCALL_WRAPPER(_Condition_variable_notify_one, 4)
1043 void __thiscall _Condition_variable_notify_one(_Condition_variable *this)
1044 {
1045     cv_queue *node;
1046
1047     TRACE("(%p)\n", this);
1048
1049     if(!this->queue)
1050         return;
1051
1052     while(1) {
1053         critical_section_lock(&this->lock);
1054         node = this->queue;
1055         if(!node) {
1056             critical_section_unlock(&this->lock);
1057             return;
1058         }
1059         this->queue = node->next;
1060         critical_section_unlock(&this->lock);
1061
1062         if(!InterlockedExchange(&node->expired, TRUE)) {
1063             NtReleaseKeyedEvent(keyed_event, node, 0, NULL);
1064             return;
1065         } else {
1066             HeapFree(GetProcessHeap(), 0, node);
1067         }
1068     }
1069 }
1070
1071 /* ?notify_all@_Condition_variable@details@Concurrency@@QAEXXZ */
1072 /* ?notify_all@_Condition_variable@details@Concurrency@@QEAAXXZ */
1073 DEFINE_THISCALL_WRAPPER(_Condition_variable_notify_all, 4)
1074 void __thiscall _Condition_variable_notify_all(_Condition_variable *this)
1075 {
1076     cv_queue *ptr;
1077
1078     TRACE("(%p)\n", this);
1079
1080     if(!this->queue)
1081         return;
1082
1083     critical_section_lock(&this->lock);
1084     ptr = this->queue;
1085     this->queue = NULL;
1086     critical_section_unlock(&this->lock);
1087
1088     while(ptr) {
1089         cv_queue *next = ptr->next;
1090
1091         if(!InterlockedExchange(&ptr->expired, TRUE))
1092             NtReleaseKeyedEvent(keyed_event, ptr, 0, NULL);
1093         else
1094             HeapFree(GetProcessHeap(), 0, ptr);
1095         ptr = next;
1096     }
1097 }
1098 #endif
1099
1100 #if _MSVCR_VER >= 100
1101 typedef struct rwl_queue
1102 {
1103     struct rwl_queue *next;
1104 } rwl_queue;
1105
1106 #define WRITER_WAITING 0x80000000
1107 /* FIXME: reader_writer_lock structure is not binary compatible
1108  * it can't exceed 28/56 bytes */
1109 typedef struct
1110 {
1111     LONG count;
1112     LONG thread_id;
1113     rwl_queue active;
1114     rwl_queue *writer_head;
1115     rwl_queue *writer_tail;
1116     rwl_queue *reader_head;
1117 } reader_writer_lock;
1118
1119 /* ??0reader_writer_lock@Concurrency@@QAE@XZ */
1120 /* ??0reader_writer_lock@Concurrency@@QEAA@XZ */
1121 DEFINE_THISCALL_WRAPPER(reader_writer_lock_ctor, 4)
1122 reader_writer_lock* __thiscall reader_writer_lock_ctor(reader_writer_lock *this)
1123 {
1124     TRACE("(%p)\n", this);
1125
1126     if (!keyed_event) {
1127         HANDLE event;
1128
1129         NtCreateKeyedEvent(&event, GENERIC_READ|GENERIC_WRITE, NULL, 0);
1130         if (InterlockedCompareExchangePointer(&keyed_event, event, NULL) != NULL)
1131             NtClose(event);
1132     }
1133
1134     memset(this, 0, sizeof(*this));
1135     return this;
1136 }
1137
1138 /* ??1reader_writer_lock@Concurrency@@QAE@XZ */
1139 /* ??1reader_writer_lock@Concurrency@@QEAA@XZ */
1140 DEFINE_THISCALL_WRAPPER(reader_writer_lock_dtor, 4)
1141 void __thiscall reader_writer_lock_dtor(reader_writer_lock *this)
1142 {
1143     TRACE("(%p)\n", this);
1144
1145     if (this->thread_id != 0 || this->count)
1146         WARN("destroying locked reader_writer_lock\n");
1147 }
1148
1149 static inline void spin_wait_for_next_rwl(rwl_queue *q)
1150 {
1151     SpinWait sw;
1152
1153     if(q->next) return;
1154
1155     SpinWait_ctor(&sw, &spin_wait_yield);
1156     SpinWait__Reset(&sw);
1157     while(!q->next)
1158         SpinWait__SpinOnce(&sw);
1159     SpinWait_dtor(&sw);
1160 }
1161
1162 /* Remove when proper InterlockedOr implementation is added to wine */
1163 static LONG InterlockedOr(LONG *d, LONG v)
1164 {
1165     LONG l;
1166     while (~(l = *d) & v)
1167         if (InterlockedCompareExchange(d, l|v, l) == l) break;
1168     return l;
1169 }
1170
1171 static LONG InterlockedAnd(LONG *d, LONG v)
1172 {
1173     LONG l = *d, old;
1174     while ((l & v) != l) {
1175         if((old = InterlockedCompareExchange(d, l&v, l)) == l) break;
1176         l = old;
1177     }
1178     return l;
1179 }
1180
1181 /* ?lock@reader_writer_lock@Concurrency@@QAEXXZ */
1182 /* ?lock@reader_writer_lock@Concurrency@@QEAAXXZ */
1183 DEFINE_THISCALL_WRAPPER(reader_writer_lock_lock, 4)
1184 void __thiscall reader_writer_lock_lock(reader_writer_lock *this)
1185 {
1186     rwl_queue q = { NULL }, *last;
1187
1188     TRACE("(%p)\n", this);
1189
1190     if (this->thread_id == GetCurrentThreadId())
1191         throw_exception(EXCEPTION_IMPROPER_LOCK, 0, "Already locked");
1192
1193     last = InterlockedExchangePointer((void**)&this->writer_tail, &q);
1194     if (last) {
1195         last->next = &q;
1196         NtWaitForKeyedEvent(keyed_event, &q, 0, NULL);
1197     } else {
1198         this->writer_head = &q;
1199         if (InterlockedOr(&this->count, WRITER_WAITING))
1200             NtWaitForKeyedEvent(keyed_event, &q, 0, NULL);
1201     }
1202
1203     this->thread_id = GetCurrentThreadId();
1204     this->writer_head = &this->active;
1205     this->active.next = NULL;
1206     if (InterlockedCompareExchangePointer((void**)&this->writer_tail, &this->active, &q) != &q) {
1207         spin_wait_for_next_rwl(&q);
1208         this->active.next = q.next;
1209     }
1210 }
1211
1212 /* ?lock_read@reader_writer_lock@Concurrency@@QAEXXZ */
1213 /* ?lock_read@reader_writer_lock@Concurrency@@QEAAXXZ */
1214 DEFINE_THISCALL_WRAPPER(reader_writer_lock_lock_read, 4)
1215 void __thiscall reader_writer_lock_lock_read(reader_writer_lock *this)
1216 {
1217     rwl_queue q;
1218
1219     TRACE("(%p)\n", this);
1220
1221     if (this->thread_id == GetCurrentThreadId())
1222         throw_exception(EXCEPTION_IMPROPER_LOCK, 0, "Already locked as writer");
1223
1224     do {
1225         q.next = this->reader_head;
1226     } while(InterlockedCompareExchangePointer((void**)&this->reader_head, &q, q.next) != q.next);
1227
1228     if (!q.next) {
1229         rwl_queue *head;
1230         LONG count;
1231
1232         while (!((count = this->count) & WRITER_WAITING))
1233             if (InterlockedCompareExchange(&this->count, count+1, count) == count) break;
1234
1235         if (count & WRITER_WAITING)
1236             NtWaitForKeyedEvent(keyed_event, &q, 0, NULL);
1237
1238         head = InterlockedExchangePointer((void**)&this->reader_head, NULL);
1239         while(head && head != &q) {
1240             rwl_queue *next = head->next;
1241             InterlockedIncrement(&this->count);
1242             NtReleaseKeyedEvent(keyed_event, head, 0, NULL);
1243             head = next;
1244         }
1245     } else {
1246         NtWaitForKeyedEvent(keyed_event, &q, 0, NULL);
1247     }
1248 }
1249
1250 /* ?try_lock@reader_writer_lock@Concurrency@@QAE_NXZ */
1251 /* ?try_lock@reader_writer_lock@Concurrency@@QEAA_NXZ */
1252 DEFINE_THISCALL_WRAPPER(reader_writer_lock_try_lock, 4)
1253 MSVCRT_bool __thiscall reader_writer_lock_try_lock(reader_writer_lock *this)
1254 {
1255     rwl_queue q = { NULL };
1256
1257     TRACE("(%p)\n", this);
1258
1259     if (this->thread_id == GetCurrentThreadId())
1260         return FALSE;
1261
1262     if (InterlockedCompareExchangePointer((void**)&this->writer_tail, &q, NULL))
1263         return FALSE;
1264     this->writer_head = &q;
1265     if (!InterlockedCompareExchange(&this->count, WRITER_WAITING, 0)) {
1266         this->thread_id = GetCurrentThreadId();
1267         this->writer_head = &this->active;
1268         this->active.next = NULL;
1269         if (InterlockedCompareExchangePointer((void**)&this->writer_tail, &this->active, &q) != &q) {
1270             spin_wait_for_next_rwl(&q);
1271             this->active.next = q.next;
1272         }
1273         return TRUE;
1274     }
1275
1276     if (InterlockedCompareExchangePointer((void**)&this->writer_tail, NULL, &q) == &q)
1277         return FALSE;
1278     spin_wait_for_next_rwl(&q);
1279     this->writer_head = q.next;
1280     if (!InterlockedOr(&this->count, WRITER_WAITING)) {
1281         this->thread_id = GetCurrentThreadId();
1282         this->writer_head = &this->active;
1283         this->active.next = q.next;
1284         return TRUE;
1285     }
1286     return FALSE;
1287 }
1288
1289 /* ?try_lock_read@reader_writer_lock@Concurrency@@QAE_NXZ */
1290 /* ?try_lock_read@reader_writer_lock@Concurrency@@QEAA_NXZ */
1291 DEFINE_THISCALL_WRAPPER(reader_writer_lock_try_lock_read, 4)
1292 MSVCRT_bool __thiscall reader_writer_lock_try_lock_read(reader_writer_lock *this)
1293 {
1294     LONG count;
1295
1296     TRACE("(%p)\n", this);
1297
1298     while (!((count = this->count) & WRITER_WAITING))
1299         if (InterlockedCompareExchange(&this->count, count+1, count) == count) return TRUE;
1300     return FALSE;
1301 }
1302
1303 /* ?unlock@reader_writer_lock@Concurrency@@QAEXXZ */
1304 /* ?unlock@reader_writer_lock@Concurrency@@QEAAXXZ */
1305 DEFINE_THISCALL_WRAPPER(reader_writer_lock_unlock, 4)
1306 void __thiscall reader_writer_lock_unlock(reader_writer_lock *this)
1307 {
1308     LONG count;
1309     rwl_queue *head, *next;
1310
1311     TRACE("(%p)\n", this);
1312
1313     if ((count = this->count) & ~WRITER_WAITING) {
1314         count = InterlockedDecrement(&this->count);
1315         if (count != WRITER_WAITING)
1316             return;
1317         NtReleaseKeyedEvent(keyed_event, this->writer_head, 0, NULL);
1318         return;
1319     }
1320
1321     this->thread_id = 0;
1322     next = this->writer_head->next;
1323     if (next) {
1324         NtReleaseKeyedEvent(keyed_event, next, 0, NULL);
1325         return;
1326     }
1327     InterlockedAnd(&this->count, ~WRITER_WAITING);
1328     head = InterlockedExchangePointer((void**)&this->reader_head, NULL);
1329     while (head) {
1330         next = head->next;
1331         InterlockedIncrement(&this->count);
1332         NtReleaseKeyedEvent(keyed_event, head, 0, NULL);
1333         head = next;
1334     }
1335
1336     if (InterlockedCompareExchangePointer((void**)&this->writer_tail, NULL, this->writer_head) == this->writer_head)
1337         return;
1338     InterlockedOr(&this->count, WRITER_WAITING);
1339 }
1340
1341 typedef struct {
1342     reader_writer_lock *lock;
1343 } reader_writer_lock_scoped_lock;
1344
1345 /* ??0scoped_lock@reader_writer_lock@Concurrency@@QAE@AAV12@@Z */
1346 /* ??0scoped_lock@reader_writer_lock@Concurrency@@QEAA@AEAV12@@Z */
1347 DEFINE_THISCALL_WRAPPER(reader_writer_lock_scoped_lock_ctor, 8)
1348 reader_writer_lock_scoped_lock* __thiscall reader_writer_lock_scoped_lock_ctor(
1349         reader_writer_lock_scoped_lock *this, reader_writer_lock *lock)
1350 {
1351     TRACE("(%p %p)\n", this, lock);
1352
1353     this->lock = lock;
1354     reader_writer_lock_lock(lock);
1355     return this;
1356 }
1357
1358 /* ??1scoped_lock@reader_writer_lock@Concurrency@@QAE@XZ */
1359 /* ??1scoped_lock@reader_writer_lock@Concurrency@@QEAA@XZ */
1360 DEFINE_THISCALL_WRAPPER(reader_writer_lock_scoped_lock_dtor, 4)
1361 void __thiscall reader_writer_lock_scoped_lock_dtor(reader_writer_lock_scoped_lock *this)
1362 {
1363     TRACE("(%p)\n", this);
1364     reader_writer_lock_unlock(this->lock);
1365 }
1366
1367 /* ??0scoped_lock_read@reader_writer_lock@Concurrency@@QAE@AAV12@@Z */
1368 /* ??0scoped_lock_read@reader_writer_lock@Concurrency@@QEAA@AEAV12@@Z */
1369 DEFINE_THISCALL_WRAPPER(reader_writer_lock_scoped_lock_read_ctor, 8)
1370 reader_writer_lock_scoped_lock* __thiscall reader_writer_lock_scoped_lock_read_ctor(
1371         reader_writer_lock_scoped_lock *this, reader_writer_lock *lock)
1372 {
1373     TRACE("(%p %p)\n", this, lock);
1374
1375     this->lock = lock;
1376     reader_writer_lock_lock_read(lock);
1377     return this;
1378 }
1379
1380 /* ??1scoped_lock_read@reader_writer_lock@Concurrency@@QAE@XZ */
1381 /* ??1scoped_lock_read@reader_writer_lock@Concurrency@@QEAA@XZ */
1382 DEFINE_THISCALL_WRAPPER(reader_writer_lock_scoped_lock_read_dtor, 4)
1383 void __thiscall reader_writer_lock_scoped_lock_read_dtor(reader_writer_lock_scoped_lock *this)
1384 {
1385     TRACE("(%p)\n", this);
1386     reader_writer_lock_unlock(this->lock);
1387 }
1388
1389 typedef struct {
1390     CRITICAL_SECTION cs;
1391 } _ReentrantBlockingLock;
1392
1393 /* ??0_ReentrantBlockingLock@details@Concurrency@@QAE@XZ */
1394 /* ??0_ReentrantBlockingLock@details@Concurrency@@QEAA@XZ */
1395 DEFINE_THISCALL_WRAPPER(_ReentrantBlockingLock_ctor, 4)
1396 _ReentrantBlockingLock* __thiscall _ReentrantBlockingLock_ctor(_ReentrantBlockingLock *this)
1397 {
1398     TRACE("(%p)\n", this);
1399
1400     InitializeCriticalSection(&this->cs);
1401     this->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": _ReentrantBlockingLock");
1402     return this;
1403 }
1404
1405 /* ??1_ReentrantBlockingLock@details@Concurrency@@QAE@XZ */
1406 /* ??1_ReentrantBlockingLock@details@Concurrency@@QEAA@XZ */
1407 DEFINE_THISCALL_WRAPPER(_ReentrantBlockingLock_dtor, 4)
1408 void __thiscall _ReentrantBlockingLock_dtor(_ReentrantBlockingLock *this)
1409 {
1410     TRACE("(%p)\n", this);
1411
1412     this->cs.DebugInfo->Spare[0] = 0;
1413     DeleteCriticalSection(&this->cs);
1414 }
1415
1416 /* ?_Acquire@_ReentrantBlockingLock@details@Concurrency@@QAEXXZ */
1417 /* ?_Acquire@_ReentrantBlockingLock@details@Concurrency@@QEAAXXZ */
1418 DEFINE_THISCALL_WRAPPER(_ReentrantBlockingLock__Acquire, 4)
1419 void __thiscall _ReentrantBlockingLock__Acquire(_ReentrantBlockingLock *this)
1420 {
1421     TRACE("(%p)\n", this);
1422     EnterCriticalSection(&this->cs);
1423 }
1424
1425 /* ?_Release@_ReentrantBlockingLock@details@Concurrency@@QAEXXZ */
1426 /* ?_Release@_ReentrantBlockingLock@details@Concurrency@@QEAAXXZ */
1427 DEFINE_THISCALL_WRAPPER(_ReentrantBlockingLock__Release, 4)
1428 void __thiscall _ReentrantBlockingLock__Release(_ReentrantBlockingLock *this)
1429 {
1430     TRACE("(%p)\n", this);
1431     LeaveCriticalSection(&this->cs);
1432 }
1433
1434 /* ?_TryAcquire@_ReentrantBlockingLock@details@Concurrency@@QAE_NXZ */
1435 /* ?_TryAcquire@_ReentrantBlockingLock@details@Concurrency@@QEAA_NXZ */
1436 DEFINE_THISCALL_WRAPPER(_ReentrantBlockingLock__TryAcquire, 4)
1437 MSVCRT_bool __thiscall _ReentrantBlockingLock__TryAcquire(_ReentrantBlockingLock *this)
1438 {
1439     TRACE("(%p)\n", this);
1440     return TryEnterCriticalSection(&this->cs);
1441 }
1442
1443 /* ?wait@Concurrency@@YAXI@Z */
1444 void __cdecl Concurrency_wait(unsigned int time)
1445 {
1446     static int once;
1447
1448     if (!once++) FIXME("(%d) stub!\n", time);
1449
1450     Sleep(time);
1451 }
1452 #endif
1453
1454 #if _MSVCR_VER == 110
1455 static LONG shared_ptr_lock;
1456
1457 void __cdecl _Lock_shared_ptr_spin_lock(void)
1458 {
1459     LONG l = 0;
1460
1461     while(InterlockedCompareExchange(&shared_ptr_lock, 1, 0) != 0) {
1462         if(l++ == 1000) {
1463             Sleep(0);
1464             l = 0;
1465         }
1466     }
1467 }
1468
1469 void __cdecl _Unlock_shared_ptr_spin_lock(void)
1470 {
1471     shared_ptr_lock = 0;
1472 }
1473 #endif
1474
1475 /**********************************************************************
1476  *     msvcrt_free_locks (internal)
1477  *
1478  * Uninitialize all mt locks. Assume that neither _lock or _unlock will
1479  * be called once we're calling this routine (ie _LOCKTAB_LOCK can be deleted)
1480  *
1481  */
1482 void msvcrt_free_locks(void)
1483 {
1484   int i;
1485
1486   TRACE( ": uninitializing all mtlocks\n" );
1487
1488   /* Uninitialize the table */
1489   for( i=0; i < _TOTAL_LOCKS; i++ )
1490   {
1491     if( lock_table[ i ].bInit )
1492     {
1493       msvcrt_uninitialize_mlock( i );
1494     }
1495   }
1496
1497 #if _MSVCR_VER >= 100
1498   if(keyed_event)
1499       NtClose(keyed_event);
1500 #endif
1501 }