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     critical_section cs;
 579     LONG count;
 580     LONG owner;
 581 } _ReentrantPPLLock;
 582
 583 /* ??0_ReentrantPPLLock@details@Concurrency@@QAE@XZ */
 584 /* ??0_ReentrantPPLLock@details@Concurrency@@QEAA@XZ */
 585 DEFINE_THISCALL_WRAPPER(_ReentrantPPLLock_ctor, 4)
 586 _ReentrantPPLLock* __thiscall _ReentrantPPLLock_ctor(_ReentrantPPLLock *this)
 587 {
 588     TRACE("(%p)\n", this);
 589
 590     critical_section_ctor(&this->cs);
 591     this->count = 0;
 592     this->owner = -1;
 593     return this;
 594 }
 595
 596 /* ?_Acquire@_ReentrantPPLLock@details@Concurrency@@QAEXPAX@Z */
 597 /* ?_Acquire@_ReentrantPPLLock@details@Concurrency@@QEAAXPEAX@Z */
 598 DEFINE_THISCALL_WRAPPER(_ReentrantPPLLock__Acquire, 8)
 599 void __thiscall _ReentrantPPLLock__Acquire(_ReentrantPPLLock *this, cs_queue *q)
 600 {
 601     TRACE("(%p %p)\n", this, q);
 602
 603     if(this->owner == GetCurrentThreadId()) {
 604         this->count++;
 605         return;
 606     }
 607
 608     cs_lock(&this->cs, q);
 609     this->count++;
 610     this->owner = GetCurrentThreadId();
 611 }
 612
 613 /* ?_Release@_ReentrantPPLLock@details@Concurrency@@QAEXXZ */
 614 /* ?_Release@_ReentrantPPLLock@details@Concurrency@@QEAAXXZ */
 615 DEFINE_THISCALL_WRAPPER(_ReentrantPPLLock__Release, 4)
 616 void __thiscall _ReentrantPPLLock__Release(_ReentrantPPLLock *this)
 617 {
 618     TRACE("(%p)\n", this);
 619
 620     this->count--;
 621     if(this->count)
 622         return;
 623
 624     this->owner = -1;
 625     critical_section_unlock(&this->cs);
 626 }
 627
 628 /* ?_GetConcurrency@details@Concurrency@@YAIXZ */
 629 unsigned int __cdecl _GetConcurrency(void)
 630 {
 631     static unsigned int val = -1;
 632
 633     TRACE("()\n");
 634
 635     if(val == -1) {
 636         SYSTEM_INFO si;
 637
 638         GetSystemInfo(&si);
 639         val = si.dwNumberOfProcessors;
 640     }
 641
 642     return val;
 643 }
 644
 645 #define EVT_RUNNING     (void*)1
 646 #define EVT_WAITING     NULL
 647
 648 struct thread_wait;
 649 typedef struct thread_wait_entry
 650 {
 651     struct thread_wait *wait;
 652     struct thread_wait_entry *next;
 653     struct thread_wait_entry *prev;
 654 } thread_wait_entry;
 655
 656 typedef struct thread_wait
 657 {
 658     void *signaled;
 659     int pending_waits;
 660     thread_wait_entry entries[1];
 661 } thread_wait;
 662
 663 typedef struct
 664 {
 665     thread_wait_entry *waiters;
 666     INT_PTR signaled;
 667     critical_section cs;
 668 } event;
 669
 670 static inline PLARGE_INTEGER evt_timeout(PLARGE_INTEGER pTime, unsigned int timeout)
 671 {
 672     if(timeout == COOPERATIVE_TIMEOUT_INFINITE) return NULL;
 673     pTime->QuadPart = (ULONGLONG)timeout * -10000;
 674     return pTime;
 675 }
 676
 677 static void evt_add_queue(thread_wait_entry **head, thread_wait_entry *entry)
 678 {
 679     entry->next = *head;
 680     entry->prev = NULL;
 681     if(*head) (*head)->prev = entry;
 682     *head = entry;
 683 }
 684
 685 static void evt_remove_queue(thread_wait_entry **head, thread_wait_entry *entry)
 686 {
 687     if(entry == *head)
 688         *head = entry->next;
 689     else if(entry->prev)
 690         entry->prev->next = entry->next;
 691     if(entry->next) entry->next->prev = entry->prev;
 692 }
 693
 694 static MSVCRT_size_t evt_end_wait(thread_wait *wait, event **events, int count)
 695 {
 696     MSVCRT_size_t i, ret = COOPERATIVE_WAIT_TIMEOUT;
 697
 698     for(i = 0; i < count; i++) {
 699         critical_section_lock(&events[i]->cs);
 700         if(events[i] == wait->signaled) ret = i;
 701         evt_remove_queue(&events[i]->waiters, &wait->entries[i]);
 702         critical_section_unlock(&events[i]->cs);
 703     }
 704
 705     return ret;
 706 }
 707
 708 static inline int evt_transition(void **state, void *from, void *to)
 709 {
 710     return InterlockedCompareExchangePointer(state, to, from) == from;
 711 }
 712
 713 static MSVCRT_size_t evt_wait(thread_wait *wait, event **events, int count, MSVCRT_bool wait_all, unsigned int timeout)
 714 {
 715     int i;
 716     NTSTATUS status;
 717     LARGE_INTEGER ntto;
 718
 719     wait->signaled = EVT_RUNNING;
 720     wait->pending_waits = wait_all ? count : 1;
 721     for(i = 0; i < count; i++) {
 722         wait->entries[i].wait = wait;
 723
 724         critical_section_lock(&events[i]->cs);
 725         evt_add_queue(&events[i]->waiters, &wait->entries[i]);
 726         if(events[i]->signaled) {
 727             if(!InterlockedDecrement(&wait->pending_waits)) {
 728                 wait->signaled = events[i];
 729                 critical_section_unlock(&events[i]->cs);
 730
 731                 return evt_end_wait(wait, events, i+1);
 732             }
 733         }
 734         critical_section_unlock(&events[i]->cs);
 735     }
 736
 737     if(!timeout)
 738         return evt_end_wait(wait, events, count);
 739
 740     if(!evt_transition(&wait->signaled, EVT_RUNNING, EVT_WAITING))
 741         return evt_end_wait(wait, events, count);
 742
 743     status = NtWaitForKeyedEvent(keyed_event, wait, 0, evt_timeout(&ntto, timeout));
 744
 745     if(status && !evt_transition(&wait->signaled, EVT_WAITING, EVT_RUNNING))
 746         NtWaitForKeyedEvent(keyed_event, wait, 0, NULL);
 747
 748     return evt_end_wait(wait, events, count);
 749 }
 750
 751 /* ??0event@Concurrency@@QAE@XZ */
 752 /* ??0event@Concurrency@@QEAA@XZ */
 753 DEFINE_THISCALL_WRAPPER(event_ctor, 4)
 754 event* __thiscall event_ctor(event *this)
 755 {
 756     TRACE("(%p)\n", this);
 757
 758     this->waiters = NULL;
 759     this->signaled = FALSE;
 760     critical_section_ctor(&this->cs);
 761
 762     return this;
 763 }
 764
 765 /* ??1event@Concurrency@@QAE@XZ */
 766 /* ??1event@Concurrency@@QEAA@XZ */
 767 DEFINE_THISCALL_WRAPPER(event_dtor, 4)
 768 void __thiscall event_dtor(event *this)
 769 {
 770     TRACE("(%p)\n", this);
 771     critical_section_dtor(&this->cs);
 772     if(this->waiters)
 773         ERR("there's a wait on destroyed event\n");
 774 }
 775
 776 /* ?reset@event@Concurrency@@QAEXXZ */
 777 /* ?reset@event@Concurrency@@QEAAXXZ */
 778 DEFINE_THISCALL_WRAPPER(event_reset, 4)
 779 void __thiscall event_reset(event *this)
 780 {
 781     thread_wait_entry *entry;
 782
 783     TRACE("(%p)\n", this);
 784
 785     critical_section_lock(&this->cs);
 786     if(this->signaled) {
 787         this->signaled = FALSE;
 788         for(entry=this->waiters; entry; entry = entry->next)
 789             InterlockedIncrement(&entry->wait->pending_waits);
 790     }
 791     critical_section_unlock(&this->cs);
 792 }
 793
 794 /* ?set@event@Concurrency@@QAEXXZ */
 795 /* ?set@event@Concurrency@@QEAAXXZ */
 796 DEFINE_THISCALL_WRAPPER(event_set, 4)
 797 void __thiscall event_set(event *this)
 798 {
 799     thread_wait_entry *wakeup = NULL;
 800     thread_wait_entry *entry, *next;
 801
 802     TRACE("(%p)\n", this);
 803
 804     critical_section_lock(&this->cs);
 805     if(!this->signaled) {
 806         this->signaled = TRUE;
 807         for(entry=this->waiters; entry; entry=next) {
 808             next = entry->next;
 809             if(!InterlockedDecrement(&entry->wait->pending_waits)) {
 810                 if(InterlockedExchangePointer(&entry->wait->signaled, this) == EVT_WAITING) {
 811                     evt_remove_queue(&this->waiters, entry);
 812                     evt_add_queue(&wakeup, entry);
 813                 }
 814             }
 815         }
 816     }
 817     critical_section_unlock(&this->cs);
 818
 819     for(entry=wakeup; entry; entry=next) {
 820         next = entry->next;
 821         entry->next = entry->prev = NULL;
 822         NtReleaseKeyedEvent(keyed_event, entry->wait, 0, NULL);
 823     }
 824 }
 825
 826 /* ?wait@event@Concurrency@@QAEII@Z */
 827 /* ?wait@event@Concurrency@@QEAA_KI@Z */
 828 DEFINE_THISCALL_WRAPPER(event_wait, 8)
 829 MSVCRT_size_t __thiscall event_wait(event *this, unsigned int timeout)
 830 {
 831     thread_wait wait;
 832     MSVCRT_size_t signaled;
 833
 834     TRACE("(%p %u)\n", this, timeout);
 835
 836     critical_section_lock(&this->cs);
 837     signaled = this->signaled;
 838     critical_section_unlock(&this->cs);
 839
 840     if(!timeout) return signaled ? 0 : COOPERATIVE_WAIT_TIMEOUT;
 841     return signaled ? 0 : evt_wait(&wait, &this, 1, FALSE, timeout);
 842 }
 843
 844 /* ?wait_for_multiple@event@Concurrency@@SAIPAPAV12@I_NI@Z */
 845 /* ?wait_for_multiple@event@Concurrency@@SA_KPEAPEAV12@_K_NI@Z */
 846 int __cdecl event_wait_for_multiple(event **events, MSVCRT_size_t count, MSVCRT_bool wait_all, unsigned int timeout)
 847 {
 848     thread_wait *wait;
 849     MSVCRT_size_t ret;
 850
 851     TRACE("(%p %ld %d %u)\n", events, count, wait_all, timeout);
 852
 853     if(count == 0)
 854         return 0;
 855
 856     wait = heap_alloc(FIELD_OFFSET(thread_wait, entries[count]));
 857     if(!wait)
 858         throw_exception(EXCEPTION_BAD_ALLOC, 0, "bad allocation");
 859     ret = evt_wait(wait, events, count, wait_all, timeout);
 860     heap_free(wait);
 861
 862     return ret;
 863 }
 864 #endif
 865
 866 #if _MSVCR_VER >= 110
 867 typedef struct cv_queue {
 868     struct cv_queue *next;
 869     BOOL expired;
 870 } cv_queue;
 871
 872 typedef struct {
 873     /* cv_queue structure is not binary compatible */
 874     cv_queue *queue;
 875     critical_section lock;
 876 } _Condition_variable;
 877
 878 /* ??0_Condition_variable@details@Concurrency@@QAE@XZ */
 879 /* ??0_Condition_variable@details@Concurrency@@QEAA@XZ */
 880 DEFINE_THISCALL_WRAPPER(_Condition_variable_ctor, 4)
 881 _Condition_variable* __thiscall _Condition_variable_ctor(_Condition_variable *this)
 882 {
 883     TRACE("(%p)\n", this);
 884
 885     this->queue = NULL;
 886     critical_section_ctor(&this->lock);
 887     return this;
 888 }
 889
 890 /* ??1_Condition_variable@details@Concurrency@@QAE@XZ */
 891 /* ??1_Condition_variable@details@Concurrency@@QEAA@XZ */
 892 DEFINE_THISCALL_WRAPPER(_Condition_variable_dtor, 4)
 893 void __thiscall _Condition_variable_dtor(_Condition_variable *this)
 894 {
 895     TRACE("(%p)\n", this);
 896
 897     while(this->queue) {
 898         cv_queue *next = this->queue->next;
 899         if(!this->queue->expired)
 900             ERR("there's an active wait\n");
 901         HeapFree(GetProcessHeap(), 0, this->queue);
 902         this->queue = next;
 903     }
 904     critical_section_dtor(&this->lock);
 905 }
 906
 907 /* ?wait@_Condition_variable@details@Concurrency@@QAEXAAVcritical_section@3@@Z */
 908 /* ?wait@_Condition_variable@details@Concurrency@@QEAAXAEAVcritical_section@3@@Z */
 909 DEFINE_THISCALL_WRAPPER(_Condition_variable_wait, 8)
 910 void __thiscall _Condition_variable_wait(_Condition_variable *this, critical_section *cs)
 911 {
 912     cv_queue q;
 913
 914     TRACE("(%p, %p)\n", this, cs);
 915
 916     critical_section_lock(&this->lock);
 917     q.next = this->queue;
 918     q.expired = FALSE;
 919     this->queue = &q;
 920     critical_section_unlock(&this->lock);
 921
 922     critical_section_unlock(cs);
 923     NtWaitForKeyedEvent(keyed_event, &q, 0, NULL);
 924     critical_section_lock(cs);
 925 }
 926
 927 /* ?wait_for@_Condition_variable@details@Concurrency@@QAE_NAAVcritical_section@3@I@Z */
 928 /* ?wait_for@_Condition_variable@details@Concurrency@@QEAA_NAEAVcritical_section@3@I@Z */
 929 DEFINE_THISCALL_WRAPPER(_Condition_variable_wait_for, 12)
 930 MSVCRT_bool __thiscall _Condition_variable_wait_for(_Condition_variable *this,
 931         critical_section *cs, unsigned int timeout)
 932 {
 933     LARGE_INTEGER to;
 934     NTSTATUS status;
 935     FILETIME ft;
 936     cv_queue *q;
 937
 938     TRACE("(%p %p %d)\n", this, cs, timeout);
 939
 940     if(!(q = HeapAlloc(GetProcessHeap(), 0, sizeof(cv_queue)))) {
 941         throw_exception(EXCEPTION_BAD_ALLOC, 0, "bad allocation");
 942     }
 943
 944     critical_section_lock(&this->lock);
 945     q->next = this->queue;
 946     q->expired = FALSE;
 947     this->queue = q;
 948     critical_section_unlock(&this->lock);
 949
 950     critical_section_unlock(cs);
 951
 952     GetSystemTimeAsFileTime(&ft);
 953     to.QuadPart = ((LONGLONG)ft.dwHighDateTime << 32) +
 954         ft.dwLowDateTime + (LONGLONG)timeout * 10000;
 955     status = NtWaitForKeyedEvent(keyed_event, q, 0, &to);
 956     if(status == STATUS_TIMEOUT) {
 957         if(!InterlockedExchange(&q->expired, TRUE)) {
 958             critical_section_lock(cs);
 959             return FALSE;
 960         }
 961         else
 962             NtWaitForKeyedEvent(keyed_event, q, 0, 0);
 963     }
 964
 965     HeapFree(GetProcessHeap(), 0, q);
 966     critical_section_lock(cs);
 967     return TRUE;
 968 }
 969
 970 /* ?notify_one@_Condition_variable@details@Concurrency@@QAEXXZ */
 971 /* ?notify_one@_Condition_variable@details@Concurrency@@QEAAXXZ */
 972 DEFINE_THISCALL_WRAPPER(_Condition_variable_notify_one, 4)
 973 void __thiscall _Condition_variable_notify_one(_Condition_variable *this)
 974 {
 975     cv_queue *node;
 976
 977     TRACE("(%p)\n", this);
 978
 979     if(!this->queue)
 980         return;
 981
 982     while(1) {
 983         critical_section_lock(&this->lock);
 984         node = this->queue;
 985         if(!node) {
 986             critical_section_unlock(&this->lock);
 987             return;
 988         }
 989         this->queue = node->next;
 990         critical_section_unlock(&this->lock);
 991
 992         if(!InterlockedExchange(&node->expired, TRUE)) {
 993             NtReleaseKeyedEvent(keyed_event, node, 0, NULL);
 994             return;
 995         } else {
 996             HeapFree(GetProcessHeap(), 0, node);
 997         }
 998     }
 999 }
1000
1001 /* ?notify_all@_Condition_variable@details@Concurrency@@QAEXXZ */
1002 /* ?notify_all@_Condition_variable@details@Concurrency@@QEAAXXZ */
1003 DEFINE_THISCALL_WRAPPER(_Condition_variable_notify_all, 4)
1004 void __thiscall _Condition_variable_notify_all(_Condition_variable *this)
1005 {
1006     cv_queue *ptr;
1007
1008     TRACE("(%p)\n", this);
1009
1010     if(!this->queue)
1011         return;
1012
1013     critical_section_lock(&this->lock);
1014     ptr = this->queue;
1015     this->queue = NULL;
1016     critical_section_unlock(&this->lock);
1017
1018     while(ptr) {
1019         cv_queue *next = ptr->next;
1020
1021         if(!InterlockedExchange(&ptr->expired, TRUE))
1022             NtReleaseKeyedEvent(keyed_event, ptr, 0, NULL);
1023         else
1024             HeapFree(GetProcessHeap(), 0, ptr);
1025         ptr = next;
1026     }
1027 }
1028 #endif
1029
1030 #if _MSVCR_VER >= 100
1031 typedef struct rwl_queue
1032 {
1033     struct rwl_queue *next;
1034 } rwl_queue;
1035
1036 #define WRITER_WAITING 0x80000000
1037 /* FIXME: reader_writer_lock structure is not binary compatible
1038  * it can't exceed 28/56 bytes */
1039 typedef struct
1040 {
1041     LONG count;
1042     LONG thread_id;
1043     rwl_queue active;
1044     rwl_queue *writer_head;
1045     rwl_queue *writer_tail;
1046     rwl_queue *reader_head;
1047 } reader_writer_lock;
1048
1049 /* ??0reader_writer_lock@Concurrency@@QAE@XZ */
1050 /* ??0reader_writer_lock@Concurrency@@QEAA@XZ */
1051 DEFINE_THISCALL_WRAPPER(reader_writer_lock_ctor, 4)
1052 reader_writer_lock* __thiscall reader_writer_lock_ctor(reader_writer_lock *this)
1053 {
1054     TRACE("(%p)\n", this);
1055
1056     if (!keyed_event) {
1057         HANDLE event;
1058
1059         NtCreateKeyedEvent(&event, GENERIC_READ|GENERIC_WRITE, NULL, 0);
1060         if (InterlockedCompareExchangePointer(&keyed_event, event, NULL) != NULL)
1061             NtClose(event);
1062     }
1063
1064     memset(this, 0, sizeof(*this));
1065     return this;
1066 }
1067
1068 /* ??1reader_writer_lock@Concurrency@@QAE@XZ */
1069 /* ??1reader_writer_lock@Concurrency@@QEAA@XZ */
1070 DEFINE_THISCALL_WRAPPER(reader_writer_lock_dtor, 4)
1071 void __thiscall reader_writer_lock_dtor(reader_writer_lock *this)
1072 {
1073     TRACE("(%p)\n", this);
1074
1075     if (this->thread_id != 0 || this->count)
1076         WARN("destroying locked reader_writer_lock\n");
1077 }
1078
1079 static inline void spin_wait_for_next_rwl(rwl_queue *q)
1080 {
1081     SpinWait sw;
1082
1083     if(q->next) return;
1084
1085     SpinWait_ctor(&sw, &spin_wait_yield);
1086     SpinWait__Reset(&sw);
1087     while(!q->next)
1088         SpinWait__SpinOnce(&sw);
1089     SpinWait_dtor(&sw);
1090 }
1091
1092 /* Remove when proper InterlockedOr implementation is added to wine */
1093 static LONG InterlockedOr(LONG *d, LONG v)
1094 {
1095     LONG l;
1096     while (~(l = *d) & v)
1097         if (InterlockedCompareExchange(d, l|v, l) == l) break;
1098     return l;
1099 }
1100
1101 static LONG InterlockedAnd(LONG *d, LONG v)
1102 {
1103     LONG l = *d, old;
1104     while ((l & v) != l) {
1105         if((old = InterlockedCompareExchange(d, l&v, l)) == l) break;
1106         l = old;
1107     }
1108     return l;
1109 }
1110
1111 /* ?lock@reader_writer_lock@Concurrency@@QAEXXZ */
1112 /* ?lock@reader_writer_lock@Concurrency@@QEAAXXZ */
1113 DEFINE_THISCALL_WRAPPER(reader_writer_lock_lock, 4)
1114 void __thiscall reader_writer_lock_lock(reader_writer_lock *this)
1115 {
1116     rwl_queue q = { NULL }, *last;
1117
1118     TRACE("(%p)\n", this);
1119
1120     if (this->thread_id == GetCurrentThreadId())
1121         throw_exception(EXCEPTION_IMPROPER_LOCK, 0, "Already locked");
1122
1123     last = InterlockedExchangePointer((void**)&this->writer_tail, &q);
1124     if (last) {
1125         last->next = &q;
1126         NtWaitForKeyedEvent(keyed_event, &q, 0, NULL);
1127     } else {
1128         this->writer_head = &q;
1129         if (InterlockedOr(&this->count, WRITER_WAITING))
1130             NtWaitForKeyedEvent(keyed_event, &q, 0, NULL);
1131     }
1132
1133     this->thread_id = GetCurrentThreadId();
1134     this->writer_head = &this->active;
1135     this->active.next = NULL;
1136     if (InterlockedCompareExchangePointer((void**)&this->writer_tail, &this->active, &q) != &q) {
1137         spin_wait_for_next_rwl(&q);
1138         this->active.next = q.next;
1139     }
1140 }
1141
1142 /* ?lock_read@reader_writer_lock@Concurrency@@QAEXXZ */
1143 /* ?lock_read@reader_writer_lock@Concurrency@@QEAAXXZ */
1144 DEFINE_THISCALL_WRAPPER(reader_writer_lock_lock_read, 4)
1145 void __thiscall reader_writer_lock_lock_read(reader_writer_lock *this)
1146 {
1147     rwl_queue q;
1148
1149     TRACE("(%p)\n", this);
1150
1151     if (this->thread_id == GetCurrentThreadId())
1152         throw_exception(EXCEPTION_IMPROPER_LOCK, 0, "Already locked as writer");
1153
1154     do {
1155         q.next = this->reader_head;
1156     } while(InterlockedCompareExchangePointer((void**)&this->reader_head, &q, q.next) != q.next);
1157
1158     if (!q.next) {
1159         rwl_queue *head;
1160         LONG count;
1161
1162         while (!((count = this->count) & WRITER_WAITING))
1163             if (InterlockedCompareExchange(&this->count, count+1, count) == count) break;
1164
1165         if (count & WRITER_WAITING)
1166             NtWaitForKeyedEvent(keyed_event, &q, 0, NULL);
1167
1168         head = InterlockedExchangePointer((void**)&this->reader_head, NULL);
1169         while(head && head != &q) {
1170             rwl_queue *next = head->next;
1171             InterlockedIncrement(&this->count);
1172             NtReleaseKeyedEvent(keyed_event, head, 0, NULL);
1173             head = next;
1174         }
1175     } else {
1176         NtWaitForKeyedEvent(keyed_event, &q, 0, NULL);
1177     }
1178 }
1179
1180 /* ?try_lock@reader_writer_lock@Concurrency@@QAE_NXZ */
1181 /* ?try_lock@reader_writer_lock@Concurrency@@QEAA_NXZ */
1182 DEFINE_THISCALL_WRAPPER(reader_writer_lock_try_lock, 4)
1183 MSVCRT_bool __thiscall reader_writer_lock_try_lock(reader_writer_lock *this)
1184 {
1185     rwl_queue q = { NULL };
1186
1187     TRACE("(%p)\n", this);
1188
1189     if (this->thread_id == GetCurrentThreadId())
1190         return FALSE;
1191
1192     if (InterlockedCompareExchangePointer((void**)&this->writer_tail, &q, NULL))
1193         return FALSE;
1194     this->writer_head = &q;
1195     if (!InterlockedCompareExchange(&this->count, WRITER_WAITING, 0)) {
1196         this->thread_id = GetCurrentThreadId();
1197         this->writer_head = &this->active;
1198         this->active.next = NULL;
1199         if (InterlockedCompareExchangePointer((void**)&this->writer_tail, &this->active, &q) != &q) {
1200             spin_wait_for_next_rwl(&q);
1201             this->active.next = q.next;
1202         }
1203         return TRUE;
1204     }
1205
1206     if (InterlockedCompareExchangePointer((void**)&this->writer_tail, NULL, &q) == &q)
1207         return FALSE;
1208     spin_wait_for_next_rwl(&q);
1209     this->writer_head = q.next;
1210     if (!InterlockedOr(&this->count, WRITER_WAITING)) {
1211         this->thread_id = GetCurrentThreadId();
1212         this->writer_head = &this->active;
1213         this->active.next = q.next;
1214         return TRUE;
1215     }
1216     return FALSE;
1217 }
1218
1219 /* ?try_lock_read@reader_writer_lock@Concurrency@@QAE_NXZ */
1220 /* ?try_lock_read@reader_writer_lock@Concurrency@@QEAA_NXZ */
1221 DEFINE_THISCALL_WRAPPER(reader_writer_lock_try_lock_read, 4)
1222 MSVCRT_bool __thiscall reader_writer_lock_try_lock_read(reader_writer_lock *this)
1223 {
1224     LONG count;
1225
1226     TRACE("(%p)\n", this);
1227
1228     while (!((count = this->count) & WRITER_WAITING))
1229         if (InterlockedCompareExchange(&this->count, count+1, count) == count) return TRUE;
1230     return FALSE;
1231 }
1232
1233 /* ?unlock@reader_writer_lock@Concurrency@@QAEXXZ */
1234 /* ?unlock@reader_writer_lock@Concurrency@@QEAAXXZ */
1235 DEFINE_THISCALL_WRAPPER(reader_writer_lock_unlock, 4)
1236 void __thiscall reader_writer_lock_unlock(reader_writer_lock *this)
1237 {
1238     LONG count;
1239     rwl_queue *head, *next;
1240
1241     TRACE("(%p)\n", this);
1242
1243     if ((count = this->count) & ~WRITER_WAITING) {
1244         count = InterlockedDecrement(&this->count);
1245         if (count != WRITER_WAITING)
1246             return;
1247         NtReleaseKeyedEvent(keyed_event, this->writer_head, 0, NULL);
1248         return;
1249     }
1250
1251     this->thread_id = 0;
1252     next = this->writer_head->next;
1253     if (next) {
1254         NtReleaseKeyedEvent(keyed_event, next, 0, NULL);
1255         return;
1256     }
1257     InterlockedAnd(&this->count, ~WRITER_WAITING);
1258     head = InterlockedExchangePointer((void**)&this->reader_head, NULL);
1259     while (head) {
1260         next = head->next;
1261         InterlockedIncrement(&this->count);
1262         NtReleaseKeyedEvent(keyed_event, head, 0, NULL);
1263         head = next;
1264     }
1265
1266     if (InterlockedCompareExchangePointer((void**)&this->writer_tail, NULL, this->writer_head) == this->writer_head)
1267         return;
1268     InterlockedOr(&this->count, WRITER_WAITING);
1269 }
1270
1271 typedef struct {
1272     reader_writer_lock *lock;
1273 } reader_writer_lock_scoped_lock;
1274
1275 /* ??0scoped_lock@reader_writer_lock@Concurrency@@QAE@AAV12@@Z */
1276 /* ??0scoped_lock@reader_writer_lock@Concurrency@@QEAA@AEAV12@@Z */
1277 DEFINE_THISCALL_WRAPPER(reader_writer_lock_scoped_lock_ctor, 8)
1278 reader_writer_lock_scoped_lock* __thiscall reader_writer_lock_scoped_lock_ctor(
1279         reader_writer_lock_scoped_lock *this, reader_writer_lock *lock)
1280 {
1281     TRACE("(%p %p)\n", this, lock);
1282
1283     this->lock = lock;
1284     reader_writer_lock_lock(lock);
1285     return this;
1286 }
1287
1288 /* ??1scoped_lock@reader_writer_lock@Concurrency@@QAE@XZ */
1289 /* ??1scoped_lock@reader_writer_lock@Concurrency@@QEAA@XZ */
1290 DEFINE_THISCALL_WRAPPER(reader_writer_lock_scoped_lock_dtor, 4)
1291 void __thiscall reader_writer_lock_scoped_lock_dtor(reader_writer_lock_scoped_lock *this)
1292 {
1293     TRACE("(%p)\n", this);
1294     reader_writer_lock_unlock(this->lock);
1295 }
1296
1297 /* ??0scoped_lock_read@reader_writer_lock@Concurrency@@QAE@AAV12@@Z */
1298 /* ??0scoped_lock_read@reader_writer_lock@Concurrency@@QEAA@AEAV12@@Z */
1299 DEFINE_THISCALL_WRAPPER(reader_writer_lock_scoped_lock_read_ctor, 8)
1300 reader_writer_lock_scoped_lock* __thiscall reader_writer_lock_scoped_lock_read_ctor(
1301         reader_writer_lock_scoped_lock *this, reader_writer_lock *lock)
1302 {
1303     TRACE("(%p %p)\n", this, lock);
1304
1305     this->lock = lock;
1306     reader_writer_lock_lock_read(lock);
1307     return this;
1308 }
1309
1310 /* ??1scoped_lock_read@reader_writer_lock@Concurrency@@QAE@XZ */
1311 /* ??1scoped_lock_read@reader_writer_lock@Concurrency@@QEAA@XZ */
1312 DEFINE_THISCALL_WRAPPER(reader_writer_lock_scoped_lock_read_dtor, 4)
1313 void __thiscall reader_writer_lock_scoped_lock_read_dtor(reader_writer_lock_scoped_lock *this)
1314 {
1315     TRACE("(%p)\n", this);
1316     reader_writer_lock_unlock(this->lock);
1317 }
1318
1319 typedef struct {
1320     CRITICAL_SECTION cs;
1321 } _ReentrantBlockingLock;
1322
1323 /* ??0_ReentrantBlockingLock@details@Concurrency@@QAE@XZ */
1324 /* ??0_ReentrantBlockingLock@details@Concurrency@@QEAA@XZ */
1325 DEFINE_THISCALL_WRAPPER(_ReentrantBlockingLock_ctor, 4)
1326 _ReentrantBlockingLock* __thiscall _ReentrantBlockingLock_ctor(_ReentrantBlockingLock *this)
1327 {
1328     TRACE("(%p)\n", this);
1329
1330     InitializeCriticalSection(&this->cs);
1331     this->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": _ReentrantBlockingLock");
1332     return this;
1333 }
1334
1335 /* ??1_ReentrantBlockingLock@details@Concurrency@@QAE@XZ */
1336 /* ??1_ReentrantBlockingLock@details@Concurrency@@QEAA@XZ */
1337 DEFINE_THISCALL_WRAPPER(_ReentrantBlockingLock_dtor, 4)
1338 void __thiscall _ReentrantBlockingLock_dtor(_ReentrantBlockingLock *this)
1339 {
1340     TRACE("(%p)\n", this);
1341
1342     this->cs.DebugInfo->Spare[0] = 0;
1343     DeleteCriticalSection(&this->cs);
1344 }
1345
1346 /* ?_Acquire@_ReentrantBlockingLock@details@Concurrency@@QAEXXZ */
1347 /* ?_Acquire@_ReentrantBlockingLock@details@Concurrency@@QEAAXXZ */
1348 DEFINE_THISCALL_WRAPPER(_ReentrantBlockingLock__Acquire, 4)
1349 void __thiscall _ReentrantBlockingLock__Acquire(_ReentrantBlockingLock *this)
1350 {
1351     TRACE("(%p)\n", this);
1352     EnterCriticalSection(&this->cs);
1353 }
1354
1355 /* ?_Release@_ReentrantBlockingLock@details@Concurrency@@QAEXXZ */
1356 /* ?_Release@_ReentrantBlockingLock@details@Concurrency@@QEAAXXZ */
1357 DEFINE_THISCALL_WRAPPER(_ReentrantBlockingLock__Release, 4)
1358 void __thiscall _ReentrantBlockingLock__Release(_ReentrantBlockingLock *this)
1359 {
1360     TRACE("(%p)\n", this);
1361     LeaveCriticalSection(&this->cs);
1362 }
1363
1364 /* ?_TryAcquire@_ReentrantBlockingLock@details@Concurrency@@QAE_NXZ */
1365 /* ?_TryAcquire@_ReentrantBlockingLock@details@Concurrency@@QEAA_NXZ */
1366 DEFINE_THISCALL_WRAPPER(_ReentrantBlockingLock__TryAcquire, 4)
1367 MSVCRT_bool __thiscall _ReentrantBlockingLock__TryAcquire(_ReentrantBlockingLock *this)
1368 {
1369     TRACE("(%p)\n", this);
1370     return TryEnterCriticalSection(&this->cs);
1371 }
1372 #endif
1373
1374 #if _MSVCR_VER == 110
1375 static LONG shared_ptr_lock;
1376
1377 void __cdecl _Lock_shared_ptr_spin_lock(void)
1378 {
1379     LONG l = 0;
1380
1381     while(InterlockedCompareExchange(&shared_ptr_lock, 1, 0) != 0) {
1382         if(l++ == 1000) {
1383             Sleep(0);
1384             l = 0;
1385         }
1386     }
1387 }
1388
1389 void __cdecl _Unlock_shared_ptr_spin_lock(void)
1390 {
1391     shared_ptr_lock = 0;
1392 }
1393 #endif
1394
1395 /**********************************************************************
1396  *     msvcrt_free_locks (internal)
1397  *
1398  * Uninitialize all mt locks. Assume that neither _lock or _unlock will
1399  * be called once we're calling this routine (ie _LOCKTAB_LOCK can be deleted)
1400  *
1401  */
1402 void msvcrt_free_locks(void)
1403 {
1404   int i;
1405
1406   TRACE( ": uninitializing all mtlocks\n" );
1407
1408   /* Uninitialize the table */
1409   for( i=0; i < _TOTAL_LOCKS; i++ )
1410   {
1411     if( lock_table[ i ].bInit )
1412     {
1413       msvcrt_uninitialize_mlock( i );
1414     }
1415   }
1416
1417 #if _MSVCR_VER >= 100
1418   if(keyed_event)
1419       NtClose(keyed_event);
1420 #endif
1421 }