/* Thread-local storage (native Windows implementation).
Copyright (C) 2005-2020 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>. */
/* Written by Bruno Haible <bruno@clisp.org>, 2005. */
#include <config.h>
/* Specification. */
#include "windows-tls.h"
#include <errno.h>
#include <limits.h>
#include <stdlib.h>
#include "windows-once.h"
void *
glwthread_tls_get (glwthread_tls_key_t key)
{
return TlsGetValue (key);
}
int
glwthread_tls_set (glwthread_tls_key_t key, void *value)
{
if (!TlsSetValue (key, value))
return EINVAL;
return 0;
}
/* The following variables keep track of TLS keys with non-NULL destructor. */
static glwthread_once_t dtor_table_init_once = GLWTHREAD_ONCE_INIT;
static CRITICAL_SECTION dtor_table_lock;
struct dtor { glwthread_tls_key_t key; void (*destructor) (void *); };
/* The table of dtors. */
static struct dtor *dtor_table;
/* Number of active entries in the dtor_table. */
static unsigned int dtors_count;
/* Valid indices into dtor_table are 0..dtors_used-1. */
static unsigned int dtors_used;
/* Allocation size of dtor_table. */
static unsigned int dtors_allocated;
/* Invariant: 0 <= dtors_count <= dtors_used <= dtors_allocated. */
/* Number of threads that are currently processing destructors. */
static unsigned int dtor_processing_threads;
static void
dtor_table_initialize (void)
{
InitializeCriticalSection (&dtor_table_lock);
/* The other variables are already initialized to NULL or 0, respectively. */
}
static void
dtor_table_ensure_initialized (void)
{
glwthread_once (&dtor_table_init_once, dtor_table_initialize);
}
/* Shrinks dtors_used down to dtors_count, by replacing inactive entries
with active ones. */
static void
dtor_table_shrink_used (void)
{
unsigned int i = 0;
unsigned int j = dtors_used;
for (;;)
{
BOOL i_found = FALSE;
BOOL j_found = FALSE;
/* Find the next inactive entry, from the left. */
for (; i < dtors_count;)
{
if (dtor_table[i].destructor == NULL)
{
i_found = TRUE;
break;
}
i++;
}
/* Find the next active entry, from the right. */
for (; j > dtors_count;)
{
j--;
if (dtor_table[j].destructor != NULL)
{
j_found = TRUE;
break;
}
}
if (i_found != j_found)
/* dtors_count was apparently wrong. */
abort ();
if (!i_found)
break;
/* i_found and j_found are TRUE. Swap the two entries. */
dtor_table[i] = dtor_table[j];
i++;
}
dtors_used = dtors_count;
}
void
glwthread_tls_process_destructors (void)
{
unsigned int repeat;
dtor_table_ensure_initialized ();
EnterCriticalSection (&dtor_table_lock);
if (dtor_processing_threads == 0)
{
/* Now it's the appropriate time for shrinking dtors_used. */
if (dtors_used > dtors_count)
dtor_table_shrink_used ();
}
dtor_processing_threads++;
for (repeat = GLWTHREAD_DESTRUCTOR_ITERATIONS; repeat > 0; repeat--)
{
unsigned int destructors_run = 0;
/* Iterate across dtor_table. We don't need to make a copy of dtor_table,
because
* When another thread calls glwthread_tls_key_create with a non-NULL
destructor argument, this will possibly reallocate the dtor_table
array and increase dtors_allocated as well as dtors_used and
dtors_count, but it will not change dtors_used nor the contents of
the first dtors_used entries of dtor_table.
* When another thread calls glwthread_tls_key_delete, this will
possibly set some 'destructor' member to NULL, thus marking an
entry as inactive, but it will not otherwise change dtors_used nor
the contents of the first dtors_used entries of dtor_table. */
unsigned int i_limit = dtors_used;
unsigned int i;
for (i = 0; i < i_limit; i++)
{
struct dtor current = dtor_table[i];
if (current.destructor != NULL)
{
/* The current dtor has not been deleted yet. */
void *current_value = glwthread_tls_get (current.key);
if (current_value != NULL)
{
/* The current value is non-NULL. Run the destructor. */
glwthread_tls_set (current.key, NULL);
LeaveCriticalSection (&dtor_table_lock);
current.destructor (current_value);
EnterCriticalSection (&dtor_table_lock);
destructors_run++;
}
}
}
/* When all TLS values were already NULL, no further iterations are
needed. */
if (destructors_run == 0)
break;
}
dtor_processing_threads--;
LeaveCriticalSection (&dtor_table_lock);
}
int
glwthread_tls_key_create (glwthread_tls_key_t *keyp, void (*destructor) (void *))
{
if (destructor != NULL)
{
dtor_table_ensure_initialized ();
EnterCriticalSection (&dtor_table_lock);
if (dtor_processing_threads == 0)
{
/* Now it's the appropriate time for shrinking dtors_used. */
if (dtors_used > dtors_count)
dtor_table_shrink_used ();
}
while (dtors_used == dtors_allocated)
{
/* Need to grow the dtor_table. */
unsigned int new_allocated = 2 * dtors_allocated + 1;
if (new_allocated < 7)
new_allocated = 7;
if (new_allocated <= dtors_allocated) /* overflow? */
new_allocated = UINT_MAX;
LeaveCriticalSection (&dtor_table_lock);
{
struct dtor *new_table =
(struct dtor *) malloc (new_allocated * sizeof (struct dtor));
if (new_table == NULL)
return ENOMEM;
EnterCriticalSection (&dtor_table_lock);
/* Attention! dtors_used, dtors_allocated may have changed! */
if (dtors_used < new_allocated)
{
if (dtors_allocated < new_allocated)
{
/* The new_table is useful. */
memcpy (new_table, dtor_table,
dtors_used * sizeof (struct dtor));
dtor_table = new_table;
dtors_allocated = new_allocated;
}
else
{
/* The new_table is not useful, since another thread
meanwhile allocated a drop_table that is at least
as large. */
free (new_table);
}
break;
}
/* The new_table is not useful, since other threads increased
dtors_used. Free it any retry. */
free (new_table);
}
}
/* Here dtors_used < dtors_allocated. */
{
/* Allocate a new key. */
glwthread_tls_key_t key = TlsAlloc ();
if (key == (DWORD)-1)
{
LeaveCriticalSection (&dtor_table_lock);
return EAGAIN;
}
/* Store the new dtor in the dtor_table, after all used entries.
Do not overwrite inactive entries with indices < dtors_used, in order
not to disturb glwthread_tls_process_destructors invocations that may
be executing in other threads. */
dtor_table[dtors_used].key = key;
dtor_table[dtors_used].destructor = destructor;
dtors_used++;
dtors_count++;
LeaveCriticalSection (&dtor_table_lock);
*keyp = key;
}
}
else
{
/* Allocate a new key. */
glwthread_tls_key_t key = TlsAlloc ();
if (key == (DWORD)-1)
return EAGAIN;
*keyp = key;
}
return 0;
}
int
glwthread_tls_key_delete (glwthread_tls_key_t key)
{
/* Should the destructor be called for all threads that are currently running?
Probably not, because
- ISO C does not specify when the destructor is to be invoked at all.
- In POSIX, the destructor functions specified with pthread_key_create()
are invoked at thread exit.
- It would be hard to implement, because there are no primitives for
accessing thread-specific values from a different thread. */
dtor_table_ensure_initialized ();
EnterCriticalSection (&dtor_table_lock);
if (dtor_processing_threads == 0)
{
/* Now it's the appropriate time for shrinking dtors_used. */
if (dtors_used > dtors_count)
dtor_table_shrink_used ();
/* Here dtors_used == dtors_count. */
/* Find the key in dtor_table. */
{
unsigned int i_limit = dtors_used;
unsigned int i;
for (i = 0; i < i_limit; i++)
if (dtor_table[i].key == key)
{
if (i < dtors_used - 1)
/* Swap the entries i and dtors_used - 1. */
dtor_table[i] = dtor_table[dtors_used - 1];
dtors_count = dtors_used = dtors_used - 1;
break;
}
}
}
else
{
/* Be careful not to disturb the glwthread_tls_process_destructors
invocations that are executing in other threads. */
unsigned int i_limit = dtors_used;
unsigned int i;
for (i = 0; i < i_limit; i++)
if (dtor_table[i].destructor != NULL /* skip inactive entries */
&& dtor_table[i].key == key)
{
/* Mark this entry as inactive. */
dtor_table[i].destructor = NULL;
dtors_count = dtors_count - 1;
break;
}
}
LeaveCriticalSection (&dtor_table_lock);
/* Now we have ensured that glwthread_tls_process_destructors will no longer
use this key. */
if (!TlsFree (key))
return EINVAL;
return 0;
}