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 <stdarg.h>
  20 #include <stdbool.h>
  21
  22 #include "wine/debug.h"
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winternl.h"
  26 #include "msvcrt.h"
  27 #include "mtdll.h"
  28 #include "cxx.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  31
  32 typedef struct
  33 {
  34   BOOL             bInit;
  35   CRITICAL_SECTION crit;
  36 } LOCKTABLEENTRY;
  37
  38 static LOCKTABLEENTRY lock_table[ _TOTAL_LOCKS ];
  39
  40 static inline void msvcrt_mlock_set_entry_initialized( int locknum, BOOL initialized )
  41 {
  42   lock_table[ locknum ].bInit = initialized;
  43 }
  44
  45 static inline void msvcrt_initialize_mlock( int locknum )
  46 {
  47   InitializeCriticalSection( &(lock_table[ locknum ].crit) );
  48   lock_table[ locknum ].crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": LOCKTABLEENTRY.crit");
  49   msvcrt_mlock_set_entry_initialized( locknum, TRUE );
  50 }
  51
  52 static inline void msvcrt_uninitialize_mlock( int locknum )
  53 {
  54   lock_table[ locknum ].crit.DebugInfo->Spare[0] = 0;
  55   DeleteCriticalSection( &(lock_table[ locknum ].crit) );
  56   msvcrt_mlock_set_entry_initialized( locknum, FALSE );
  57 }
  58
  59 /**********************************************************************
  60  *     msvcrt_init_mt_locks (internal)
  61  *
  62  * Initialize the table lock. All other locks will be initialized
  63  * upon first use.
  64  *
  65  */
  66 void msvcrt_init_mt_locks(void)
  67 {
  68   int i;
  69
  70   TRACE( "initializing mtlocks\n" );
  71
  72   /* Initialize the table */
  73   for( i=0; i < _TOTAL_LOCKS; i++ )
  74   {
  75     msvcrt_mlock_set_entry_initialized( i, FALSE );
  76   }
  77
  78   /* Initialize our lock table lock */
  79   msvcrt_initialize_mlock( _LOCKTAB_LOCK );
  80 }
  81
  82 /**********************************************************************
  83  *              _lock (MSVCRT.@)
  84  */
  85 void CDECL _lock( int locknum )
  86 {
  87   TRACE( "(%d)\n", locknum );
  88
  89   /* If the lock doesn't exist yet, create it */
  90   if( lock_table[ locknum ].bInit == FALSE )
  91   {
  92     /* Lock while we're changing the lock table */
  93     _lock( _LOCKTAB_LOCK );
  94
  95     /* Check again if we've got a bit of a race on lock creation */
  96     if( lock_table[ locknum ].bInit == FALSE )
  97     {
  98       TRACE( ": creating lock #%d\n", locknum );
  99       msvcrt_initialize_mlock( locknum );
 100     }
 101
 102     /* Unlock ourselves */
 103     _unlock( _LOCKTAB_LOCK );
 104   }
 105
 106   EnterCriticalSection( &(lock_table[ locknum ].crit) );
 107 }
 108
 109 /**********************************************************************
 110  *              _unlock (MSVCRT.@)
 111  *
 112  * NOTE: There is no error detection to make sure the lock exists and is acquired.
 113  */
 114 void CDECL _unlock( int locknum )
 115 {
 116   TRACE( "(%d)\n", locknum );
 117
 118   LeaveCriticalSection( &(lock_table[ locknum ].crit) );
 119 }
 120
 121 #if _MSVCR_VER == 110
 122 static LONG shared_ptr_lock;
 123
 124 void __cdecl _Lock_shared_ptr_spin_lock(void)
 125 {
 126     LONG l = 0;
 127
 128     while(InterlockedCompareExchange(&shared_ptr_lock, 1, 0) != 0) {
 129         if(l++ == 1000) {
 130             Sleep(0);
 131             l = 0;
 132         }
 133     }
 134 }
 135
 136 void __cdecl _Unlock_shared_ptr_spin_lock(void)
 137 {
 138     shared_ptr_lock = 0;
 139 }
 140 #endif
 141
 142 /**********************************************************************
 143  *     msvcrt_free_locks (internal)
 144  *
 145  * Uninitialize all mt locks. Assume that neither _lock or _unlock will
 146  * be called once we're calling this routine (ie _LOCKTAB_LOCK can be deleted)
 147  *
 148  */
 149 void msvcrt_free_locks(void)
 150 {
 151   int i;
 152
 153   TRACE( ": uninitializing all mtlocks\n" );
 154
 155   /* Uninitialize the table */
 156   for( i=0; i < _TOTAL_LOCKS; i++ )
 157   {
 158     if( lock_table[ i ].bInit )
 159     {
 160       msvcrt_uninitialize_mlock( i );
 161     }
 162   }
 163 }