nptl/tst-key3.c

   1 /* Copyright (C) 2002 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #include <pthread.h>
  20 #include <stdio.h>
  21 #include <unistd.h>
  22
  23 #define N 2
  24
  25
  26 static int cnt0;
  27 static void
  28 f0 (void *p)
  29 {
  30   ++cnt0;
  31 }
  32
  33
  34 static int cnt1;
  35 static void
  36 f1 (void *p)
  37 {
  38   ++cnt1;
  39 }
  40
  41
  42 static void (*fcts[N]) (void *) =
  43 {
  44   f0,
  45   f1
  46 };
  47
  48
  49 static pthread_barrier_t b;
  50
  51
  52 static void *
  53 tf (void *arg)
  54 {
  55   pthread_key_t *key = (pthread_key_t *) arg;
  56
  57   if (pthread_setspecific (*key, (void *) -1l) != 0)
  58     {
  59       write (2, "setspecific failed\n", 19);
  60       _exit (1);
  61     }
  62
  63   pthread_barrier_wait (&b);
  64
  65   const struct timespec t = { .tv_sec = 1000, .tv_nsec = 0 };
  66   while (1)
  67     nanosleep (&t, NULL);
  68
  69   /* NOTREACHED */
  70   return NULL;
  71 }
  72
  73
  74 int
  75 do_test (void)
  76 {
  77   pthread_key_t keys[N];
  78
  79   int i;
  80   for (i = 0; i < N; ++i)
  81     if (pthread_key_create (&keys[i], fcts[i]) != 0)
  82       {
  83         write (2, "key_create failed\n", 18);
  84         _exit (1);
  85       }
  86
  87   if (pthread_barrier_init (&b, NULL, 2) != 0)
  88     {
  89       write (2, "barrier_init failed\n", 20);
  90       _exit (1);
  91     }
  92
  93   pthread_t th;
  94   if (pthread_create (&th, NULL, tf, &keys[1]) != 0)
  95     {
  96       write (2, "create failed\n", 14);
  97       _exit (1);
  98     }
  99
 100   pthread_barrier_wait (&b);
 101
 102   if (pthread_cancel (th) != 0)
 103     {
 104       write (2, "cancel failed\n", 14);
 105       _exit (1);
 106     }
 107
 108   void *status;
 109   if (pthread_join (th, &status) != 0)
 110     {
 111       write (2, "join failed\n", 12);
 112       _exit (1);
 113     }
 114
 115   if (status != PTHREAD_CANCELED)
 116     {
 117       write (2, "thread not canceled\n", 20);
 118       _exit (1);
 119     }
 120
 121   /* Note that the TSD destructors not necessarily have to have
 122      finished by the time pthread_join returns.  At least according to
 123      POSIX.  We implement the stronger requirement that they indeed
 124      have run and therefore these tests succeed.  */
 125   if (cnt0 != 0)
 126     {
 127       write (2, "cnt0 != 0\n", 10);
 128       _exit (1);
 129     }
 130
 131   if (cnt1 != 1)
 132     {
 133       write (2, "cnt1 != 1\n", 10);
 134       _exit (1);
 135     }
 136
 137   for (i = 0; i < N; ++i)
 138     if (pthread_key_delete (keys[i]) != 0)
 139       {
 140         write (2, "key_delete failed\n", 18);
 141         _exit (1);
 142       }
 143
 144   if (pthread_barrier_destroy (&b) != 0)
 145     {
 146       write (2, "barrier_destroy failed\n", 23);
 147       _exit (1);
 148     }
 149
 150   return 0;
 151 }
 152
 153
 154 #define TEST_FUNCTION do_test ()
 155 #include "../test-skeleton.c"