1  /* Copyright (C) 2002-2023 Free Software Foundation, Inc.
       2     This file is part of the GNU C Library.
       3  
       4     The GNU C 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     The GNU C 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 the GNU C Library; if not, see
      16     <https://www.gnu.org/licenses/>.  */
      17  
      18  #include <pthread.h>
      19  #include <stdio.h>
      20  #include <unistd.h>
      21  
      22  #define N 2
      23  
      24  
      25  static int do_test (void);
      26  
      27  #define TEST_FUNCTION do_test ()
      28  #include "../test-skeleton.c"
      29  
      30  static int cnt0;
      31  static void
      32  f0 (void *p)
      33  {
      34    ++cnt0;
      35  }
      36  
      37  
      38  static int cnt1;
      39  static void
      40  f1 (void *p)
      41  {
      42    ++cnt1;
      43  }
      44  
      45  
      46  static void (*fcts[N]) (void *) =
      47  {
      48    f0,
      49    f1
      50  };
      51  
      52  
      53  static pthread_barrier_t b;
      54  
      55  
      56  static void *
      57  tf (void *arg)
      58  {
      59    pthread_key_t *key = (pthread_key_t *) arg;
      60  
      61    if (pthread_setspecific (*key, arg) != 0)
      62      {
      63        write_message ("setspecific failed\n");
      64        _exit (1);
      65      }
      66  
      67    pthread_barrier_wait (&b);
      68  
      69    const struct timespec t = { .tv_sec = 1000, .tv_nsec = 0 };
      70    while (1)
      71      nanosleep (&t, NULL);
      72  
      73    /* NOTREACHED */
      74    return NULL;
      75  }
      76  
      77  
      78  int
      79  do_test (void)
      80  {
      81    pthread_key_t keys[N];
      82  
      83    int i;
      84    for (i = 0; i < N; ++i)
      85      if (pthread_key_create (&keys[i], fcts[i]) != 0)
      86        {
      87  	write_message ("key_create failed\n");
      88  	_exit (1);
      89        }
      90  
      91    if (pthread_barrier_init (&b, NULL, 2) != 0)
      92      {
      93        write_message ("barrier_init failed\n");
      94        _exit (1);
      95      }
      96  
      97    pthread_t th;
      98    if (pthread_create (&th, NULL, tf, &keys[1]) != 0)
      99      {
     100        write_message ("create failed\n");
     101        _exit (1);
     102      }
     103  
     104    pthread_barrier_wait (&b);
     105  
     106    if (pthread_cancel (th) != 0)
     107      {
     108        write_message ("cancel failed\n");
     109        _exit (1);
     110      }
     111  
     112    void *status;
     113    if (pthread_join (th, &status) != 0)
     114      {
     115        write_message ("join failed\n");
     116        _exit (1);
     117      }
     118  
     119    if (status != PTHREAD_CANCELED)
     120      {
     121        write_message ("thread not canceled\n");
     122        _exit (1);
     123      }
     124  
     125    /* Note that the TSD destructors not necessarily have to have
     126       finished by the time pthread_join returns.  At least according to
     127       POSIX.  We implement the stronger requirement that they indeed
     128       have run and therefore these tests succeed.  */
     129    if (cnt0 != 0)
     130      {
     131        write_message ("cnt0 != 0\n");
     132        _exit (1);
     133      }
     134  
     135    if (cnt1 != 1)
     136      {
     137        write_message ("cnt1 != 1\n");
     138        _exit (1);
     139      }
     140  
     141    for (i = 0; i < N; ++i)
     142      if (pthread_key_delete (keys[i]) != 0)
     143        {
     144  	write_message ("key_delete failed\n");
     145  	_exit (1);
     146        }
     147  
     148    if (pthread_barrier_destroy (&b) != 0)
     149      {
     150        write_message ("barrier_destroy failed\n");
     151        _exit (1);
     152      }
     153  
     154    return 0;
     155  }