lib/thrd.c

   1 /* Creating and controlling ISO C 11 threads.
   2    Copyright (C) 2005-2024 Free Software Foundation, Inc.
   3
   4    This file is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU Lesser General Public License as
   6    published by the Free Software Foundation; either version 2.1 of the
   7    License, or (at your option) any later version.
   8
   9    This file 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
  12    GNU Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2005, 2019.
  18    Based on GCC's gthr-posix.h, gthr-posix95.h, gthr-win32.h.  */
  19
  20 #include <config.h>
  21
  22 #include <threads.h>
  23
  24 #include <stdlib.h>
  25
  26 #if HAVE_THREADS_H
  27 /* Provide workarounds.  */
  28
  29 # if BROKEN_THRD_START_T_OR_JOIN
  30
  31 #  undef thrd_t
  32
  33 /* AIX 7.1..7.2 defines thrd_start_t incorrectly, namely as
  34    'void * (*) (void *)' instead of 'int (*) (void *)'.
  35    As a consequence, its thrd_join function never stores an exit code.
  36    AIX 7.3.1 has a corrected thrd_start_t.  But the thrd_join function still
  37    never stores an exit code.  */
  38
  39 /* The Thread-Specific Storage (TSS) key that allows to access each thread's
  40    'struct thrd_with_exitcode *' pointer.  */
  41 static tss_t thrd_with_exitcode_key;
  42
  43 /* Initializes thrd_with_exitcode_key.
  44    This function must only be called once.  */
  45 static void
  46 do_init_thrd_with_exitcode_key (void)
  47 {
  48   if (tss_create (&thrd_with_exitcode_key, NULL) != thrd_success)
  49     abort ();
  50 }
  51
  52 /* Initializes thrd_with_exitcode_key.  */
  53 static void
  54 init_thrd_with_exitcode_key (void)
  55 {
  56   static once_flag once = ONCE_FLAG_INIT;
  57   call_once (&once, do_init_thrd_with_exitcode_key);
  58 }
  59
  60 typedef union
  61         {
  62           struct thrd_with_exitcode t;
  63           struct
  64           {
  65             thrd_t tid; /* reserve memory for t.tid */
  66             int detached; /* reserve memory for t.detached */
  67             thrd_start_t mainfunc;
  68             void *arg;
  69           } a;
  70         }
  71         main_arg_t;
  72
  73 static void *
  74 thrd_main_func (void *pmarg)
  75 {
  76   /* Unpack the object that combines mainfunc and arg.  */
  77   main_arg_t *main_arg = (main_arg_t *) pmarg;
  78   thrd_start_t mainfunc = main_arg->a.mainfunc;
  79   void *arg = main_arg->a.arg;
  80
  81   if (tss_set (thrd_with_exitcode_key, &main_arg->t) != thrd_success)
  82     abort ();
  83
  84   /* Execute mainfunc, with arg as argument.  */
  85   {
  86     int exitcode = mainfunc (arg);
  87     /* Store the exitcode, for use by thrd_join().  */
  88     main_arg->t.exitcode = exitcode;
  89     if (main_arg->t.detached)
  90       {
  91         /* Clean up the thread, like thrd_join would do.  */
  92         free (&main_arg->t);
  93       }
  94     return NULL;
  95   }
  96 }
  97
  98 int
  99 rpl_thrd_create (rpl_thrd_t *threadp, thrd_start_t mainfunc, void *arg)
 100 #  undef thrd_create
 101 {
 102   init_thrd_with_exitcode_key ();
 103   {
 104     /* Combine mainfunc and arg in a single object.
 105        A stack-allocated object does not work, because it would be out of
 106        existence when thrd_create returns before pthread_main_func is
 107        entered.  So, allocate it in the heap.  */
 108     main_arg_t *main_arg = (main_arg_t *) malloc (sizeof (main_arg_t));
 109     if (main_arg == NULL)
 110       return thrd_nomem;
 111     main_arg->a.mainfunc = mainfunc;
 112     main_arg->a.arg = arg;
 113     main_arg->t.detached = 0;
 114     {
 115       int err =
 116         thrd_create ((thrd_t *) &main_arg->t.tid, thrd_main_func, main_arg);
 117       if (err == thrd_success)
 118         *threadp = &main_arg->t;
 119       else
 120         free (main_arg);
 121       return err;
 122     }
 123   }
 124 }
 125
 126 rpl_thrd_t
 127 rpl_thrd_current (void)
 128 #  undef thrd_current
 129 {
 130   init_thrd_with_exitcode_key ();
 131   {
 132     rpl_thrd_t thread =
 133       (struct thrd_with_exitcode *) tss_get (thrd_with_exitcode_key);
 134     if (thread == NULL)
 135       {
 136         /* This happens only in threads that have not been created through
 137            thrd_create(), such as the main thread.  */
 138         for (;;)
 139           {
 140             thread =
 141               (struct thrd_with_exitcode *)
 142               malloc (sizeof (struct thrd_with_exitcode));
 143             if (thread != NULL)
 144               break;
 145             /* Memory allocation failed.  There is not much we can do.  Have to
 146                busy-loop, waiting for the availability of memory.  */
 147             {
 148               struct timespec ts =
 149                 {
 150                   .tv_sec = 1,
 151                   .tv_nsec = 0
 152                 };
 153               thrd_sleep (&ts, NULL);
 154             }
 155           }
 156         thread->tid = thrd_current ();
 157         thread->detached = 0; /* This can lead to a memory leak.  */
 158         thread->exitcode = 0; /* just to be deterministic */
 159         if (tss_set (thrd_with_exitcode_key, thread) != thrd_success)
 160           abort ();
 161       }
 162     return thread;
 163   }
 164 }
 165
 166 int
 167 rpl_thrd_equal (rpl_thrd_t thread1, rpl_thrd_t thread2)
 168 {
 169   return thread1 == thread2;
 170 }
 171
 172 int
 173 rpl_thrd_detach (rpl_thrd_t thread)
 174 #  undef thrd_detach
 175 {
 176   if (thread->detached)
 177     return thrd_error;
 178   {
 179     int err =
 180       thrd_detach (thread == rpl_thrd_current ()
 181                    ? /* thread->tid may not be initialized at this point.  */
 182                      thrd_current ()
 183                    : thread->tid);
 184     if (err == thrd_success)
 185       thread->detached = 1;
 186     return err;
 187   }
 188 }
 189
 190 int
 191 rpl_thrd_join (rpl_thrd_t thread, int *exitcodep)
 192 #  undef thrd_join
 193 {
 194   if (thread == rpl_thrd_current () || thread->detached)
 195     return thrd_error;
 196   {
 197     int err = thrd_join (thread->tid, NULL);
 198     if (err == thrd_success)
 199       {
 200         if (exitcodep != NULL)
 201           *exitcodep = thread->exitcode;
 202         free (thread);
 203       }
 204     return err;
 205   }
 206 }
 207
 208 _Noreturn void
 209 rpl_thrd_exit (int exitcode)
 210 {
 211   rpl_thrd_t t = rpl_thrd_current ();
 212
 213   /* Store the exitcode, for use by thrd_join().  */
 214   t->exitcode = exitcode;
 215   if (t->detached)
 216     {
 217       /* Clean up the thread, like thrd_join would do.  */
 218       free (t);
 219     }
 220   pthread_exit (NULL);
 221 }
 222
 223 # endif
 224
 225 # if BROKEN_THRD_JOIN_NULL
 226
 227 /* On Solaris 11.4, thrd_join crashes when the second argument is NULL.  */
 228 int
 229 rpl_thrd_join (thrd_t thread, int *exitcodep)
 230 #  undef thrd_join
 231 {
 232   int exitcode;
 233   int err = thrd_join (thread, &exitcode);
 234   if (err == 0 && exitcodep != NULL)
 235     *exitcodep = exitcode;
 236   return err;
 237 }
 238
 239 # endif
 240
 241 #else
 242
 243 # include <errno.h>
 244 # include <stdint.h>
 245
 246 # if defined _WIN32 && ! defined __CYGWIN__
 247 /* Use Windows threads.  */
 248
 249 #  define WIN32_LEAN_AND_MEAN  /* avoid including junk */
 250 #  include <windows.h>
 251
 252 # else
 253 /* Use POSIX threads.  */
 254
 255 #  include <pthread.h>
 256 #  include <sched.h>
 257
 258 # endif
 259
 260 /* The main functions passed to thrd_create and
 261    pthread_create/glwthread_thread_create have different return types:
 262    'int' vs. 'void *'.  */
 263
 264 struct pthread_main_arg_t
 265 {
 266   thrd_start_t mainfunc;
 267   void *arg;
 268 };
 269
 270 static void *
 271 pthread_main_func (void *pmarg)
 272 {
 273   /* Unpack the object that combines mainfunc and arg.  */
 274   struct pthread_main_arg_t *pthread_main_arg =
 275     (struct pthread_main_arg_t *) pmarg;
 276   thrd_start_t mainfunc = pthread_main_arg->mainfunc;
 277   void *arg = pthread_main_arg->arg;
 278
 279   /* Free it.  */
 280   free (pmarg);
 281
 282   /* Execute mainfunc, with arg as argument.  */
 283   {
 284     int exitcode = mainfunc (arg);
 285     /* Note: When using Windows threads, this exit code is different from the
 286        argument passed to ExitThread(), because the latter should never be 259,
 287        see <https://docs.microsoft.com/de-de/windows/desktop/api/processthreadsapi/nf-processthreadsapi-getexitcodethread>,
 288        whereas the exit code passed to thrd_exit() is not constrained.  */
 289     return (void *) (intptr_t) exitcode;
 290   }
 291 }
 292
 293 # if defined _WIN32 && ! defined __CYGWIN__
 294 /* Use Windows threads.  */
 295
 296 int
 297 thrd_create (thrd_t *threadp, thrd_start_t mainfunc, void *arg)
 298 {
 299   /* Combine mainfunc and arg in a single object.
 300      A stack-allocated object does not work, because it would be out of
 301      existence when thrd_create returns before pthread_main_func is
 302      entered.  So, allocate it in the heap.  */
 303   struct pthread_main_arg_t *pthread_main_arg =
 304     (struct pthread_main_arg_t *) malloc (sizeof (struct pthread_main_arg_t));
 305   if (pthread_main_arg == NULL)
 306     return thrd_nomem;
 307   pthread_main_arg->mainfunc = mainfunc;
 308   pthread_main_arg->arg = arg;
 309
 310   {
 311     int err = glwthread_thread_create (threadp, 0,
 312                                        pthread_main_func, pthread_main_arg);
 313     if (err != 0)
 314       free (pthread_main_arg);
 315     return (err == 0 ? thrd_success :
 316             err == ENOMEM /* || err == EAGAIN */ ? thrd_nomem :
 317             thrd_error);
 318   }
 319 }
 320
 321 thrd_t
 322 thrd_current (void)
 323 {
 324   return glwthread_thread_self ();
 325 }
 326
 327 int
 328 thrd_equal (thrd_t thread1, thrd_t thread2)
 329 {
 330   return thread1 == thread2;
 331 }
 332
 333 void
 334 thrd_yield (void)
 335 {
 336   Sleep (0);
 337 }
 338
 339 int
 340 thrd_detach (thrd_t thread)
 341 {
 342   int err = glwthread_thread_detach (thread);
 343   return (err == 0 ? thrd_success : thrd_error);
 344 }
 345
 346 int
 347 thrd_join (thrd_t thread, int *exitcodep)
 348 {
 349   void *exitptr;
 350   int err = glwthread_thread_join (thread, &exitptr);
 351   if (err == 0)
 352     {
 353       if (exitcodep != NULL)
 354         *exitcodep = (int) (intptr_t) exitptr;
 355       return thrd_success;
 356     }
 357   else
 358     return thrd_error;
 359 }
 360
 361 _Noreturn void
 362 thrd_exit (int exitcode)
 363 {
 364   glwthread_thread_exit ((void *) (intptr_t) exitcode);
 365 }
 366
 367 # else
 368 /* Use POSIX threads.  */
 369
 370 int
 371 thrd_create (thrd_t *threadp, thrd_start_t mainfunc, void *arg)
 372 {
 373   /* Combine mainfunc and arg in a single object.
 374      A stack-allocated object does not work, because it would be out of
 375      existence when thrd_create returns before pthread_main_func is
 376      entered.  So, allocate it in the heap.  */
 377   struct pthread_main_arg_t *pthread_main_arg =
 378     (struct pthread_main_arg_t *) malloc (sizeof (struct pthread_main_arg_t));
 379   if (pthread_main_arg == NULL)
 380     return thrd_nomem;
 381   pthread_main_arg->mainfunc = mainfunc;
 382   pthread_main_arg->arg = arg;
 383
 384   {
 385     int err = pthread_create (threadp, NULL,
 386                               pthread_main_func, pthread_main_arg);
 387     if (err != 0)
 388       free (pthread_main_arg);
 389     return (err == 0 ? thrd_success :
 390             err == ENOMEM /* || err == EAGAIN */ ? thrd_nomem :
 391             thrd_error);
 392   }
 393 }
 394
 395 thrd_t
 396 thrd_current (void)
 397 {
 398   return pthread_self ();
 399 }
 400
 401 int
 402 thrd_equal (thrd_t thread1, thrd_t thread2)
 403 {
 404   return pthread_equal (thread1, thread2);
 405 }
 406
 407 void
 408 thrd_yield (void)
 409 {
 410   sched_yield ();
 411 }
 412
 413 int
 414 thrd_detach (thrd_t thread)
 415 {
 416   int err = pthread_detach (thread);
 417   return (err == 0 ? thrd_success : thrd_error);
 418 }
 419
 420 int
 421 thrd_join (thrd_t thread, int *exitcodep)
 422 {
 423   void *exitptr;
 424   int err = pthread_join (thread, &exitptr);
 425   if (err == 0)
 426     {
 427       if (exitcodep != NULL)
 428         *exitcodep = (int) (intptr_t) exitptr;
 429       return thrd_success;
 430     }
 431   else
 432     return thrd_error;
 433 }
 434
 435 _Noreturn void
 436 thrd_exit (int exitcode)
 437 {
 438   pthread_exit ((void *) (intptr_t) exitcode);
 439 }
 440
 441 # endif
 442
 443 int
 444 thrd_sleep (const struct timespec *duration, struct timespec *remaining)
 445 {
 446   int ret = nanosleep (duration, remaining);
 447   return (ret == 0 ? 0 : errno == EINTR ? -1 : -2);
 448 }
 449
 450 #endif