my_os2tls.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:4k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) Yuri Dario & 2000 MySQL AB
  2.    All the above parties has a full, independent copyright to
  3.    the following code, including the right to use the code in
  4.    any manner without any demands from the other parties.
  5.    This library is free software; you can redistribute it and/or
  6.    modify it under the terms of the GNU Library General Public
  7.    License as published by the Free Software Foundation; either
  8.    version 2 of the License, or (at your option) any later version.
  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.    Library General Public License for more details.
  13.    You should have received a copy of the GNU Library General Public
  14.    License along with this library; if not, write to the Free
  15.    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16.    MA 02111-1307, USA */
  17. DWORD  TlsAlloc( void);
  18. BOOL  TlsFree( DWORD);
  19. PVOID  TlsGetValue( DWORD);
  20. BOOL  TlsSetValue( DWORD, PVOID);
  21. #define TLS_MINIMUM_AVAILABLE 64
  22. PULONG  tls_storage; /* TLS local storage */
  23. DWORD  tls_bits[2]; /* TLS in-use bits   */
  24. pthread_mutex_t  tls_mutex; /* TLS mutex for in-use bits */
  25. DWORD  TlsAlloc( void)
  26. {
  27.   DWORD index = -1;
  28.   DWORD mask, tibidx;
  29.   int  i;
  30.   if (tls_storage == NULL)
  31.   {
  32.     APIRET rc;
  33.     /* allocate memory for TLS storage */
  34.     rc = DosAllocThreadLocalMemory( 1, &tls_storage);
  35.     if (rc)
  36.       fprintf( stderr, "DosAllocThreadLocalMemory error: return code = %un",
  37.        rc);
  38.     /* create a mutex */
  39.     if (pthread_mutex_init( &tls_mutex, NULL))
  40.       fprintf( stderr, "Failed to init TLS mutexn");
  41.   }
  42.   pthread_mutex_lock( &tls_mutex);
  43.   tibidx = 0;
  44.   if (tls_bits[0] == 0xFFFFFFFF)
  45.   {
  46.     if (tls_bits[1] == 0xFFFFFFFF)
  47.     {
  48.       fprintf( stderr, "tid#%d, no more TLS bits availablen", _threadid);
  49.       pthread_mutex_unlock( &tls_mutex);
  50.       return -1;
  51.     }
  52.     tibidx = 1;
  53.   }
  54.   for (i=0; i<32; i++)
  55.   {
  56.     mask = (1 << i);
  57.     if ((tls_bits[ tibidx] & mask) == 0)
  58.     {
  59.       tls_bits[ tibidx] |= mask;
  60.       index = (tibidx*32) + i;
  61.       break;
  62.     }
  63.   }
  64.   tls_storage[index] = 0;
  65.   pthread_mutex_unlock( &tls_mutex);
  66.   /* fprintf( stderr, "tid#%d, TlsAlloc index %dn", _threadid, index); */
  67.   return index;
  68. }
  69. BOOL TlsFree( DWORD index)
  70. {
  71.   int   tlsidx;
  72.   DWORD  mask;
  73.   if (index >= TLS_MINIMUM_AVAILABLE)
  74.     return NULL;
  75.   pthread_mutex_lock( &tls_mutex);
  76.   tlsidx = 0;
  77.   if (index > 32)
  78.     tlsidx++;
  79.   mask = (1 << index);
  80.   if (tls_bits[ tlsidx] & mask)
  81.   {
  82.     tls_bits[tlsidx] &= ~mask;
  83.     tls_storage[index] = 0;
  84.     pthread_mutex_unlock( &tls_mutex);
  85.     return TRUE;
  86.   }
  87.   pthread_mutex_unlock( &tls_mutex);
  88.   return FALSE;
  89. }
  90. PVOID TlsGetValue( DWORD index)
  91. {
  92.   if (index >= TLS_MINIMUM_AVAILABLE)
  93.     return NULL;
  94.   /* verify if memory has been allocated for this thread */
  95.   if (*tls_storage == NULL)
  96.   {
  97.     /* allocate memory for indexes */
  98.     *tls_storage = (ULONG)calloc( TLS_MINIMUM_AVAILABLE, sizeof(int));
  99.     /* fprintf(stderr, "tid#%d, tls_storage %xn", _threadid, *tls_storage); */
  100.   }
  101.   ULONG* tls_array = (ULONG*) *tls_storage;
  102.   return (PVOID) tls_array[index];
  103. }
  104. BOOL TlsSetValue( DWORD index, PVOID val)
  105. {
  106.   /* verify if memory has been allocated for this thread */
  107.   if (*tls_storage == NULL)
  108.   {
  109.     /* allocate memory for indexes */
  110.     *tls_storage = (ULONG)calloc( TLS_MINIMUM_AVAILABLE, sizeof(int));
  111.     /* fprintf(stderr, "tid#%d, tls_storage %xn", _threadid, *tls_storage); */
  112.   }
  113.   if (index >= TLS_MINIMUM_AVAILABLE)
  114.     return FALSE;
  115.   ULONG* tls_array = (ULONG*) *tls_storage;
  116.   /* fprintf( stderr, "tid#%d, TlsSetValue array %08x index %d -> %08x (old)n", _threadid, tls_array, index, tls_array[ index]); */
  117.   tls_array[ index] = (ULONG) val;
  118.   /* fprintf( stderr, "tid#%d, TlsSetValue array %08x index %d -> %08xn", _threadid, tls_array, index, val); */
  119.   return TRUE;
  120. }