/* 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;

}