nptl/tst-cancel17.c

   1 /* Copyright (C) 2003-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 <aio.h>
  19 #include <errno.h>
  20 #include <pthread.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25
  26
  27 static pthread_barrier_t b;
  28
  29
  30 /* Cleanup handling test.  */
  31 static int cl_called;
  32
  33 static void
  34 cl (void *arg)
  35 {
  36   ++cl_called;
  37 }
  38
  39
  40 static void *
  41 tf (void *arg)
  42 {
  43   int r = pthread_barrier_wait (&b);
  44   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
  45     {
  46       puts ("tf: barrier_wait failed");
  47       exit (1);
  48     }
  49
  50   pthread_cleanup_push (cl, NULL);
  51
  52   const struct aiocb *l[1] = { arg };
  53
  54   TEMP_FAILURE_RETRY (aio_suspend (l, 1, NULL));
  55
  56   pthread_cleanup_pop (0);
  57
  58   puts ("tf: aio_suspend returned");
  59
  60   exit (1);
  61 }
  62
  63
  64 static void *
  65 tf2 (void *arg)
  66 {
  67   int r = pthread_barrier_wait (&b);
  68   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
  69     {
  70       puts ("tf2: barrier_wait failed");
  71       exit (1);
  72     }
  73
  74   pthread_cleanup_push (cl, NULL);
  75
  76   const struct aiocb *l[1] = { arg };
  77   struct timespec ts = { .tv_sec = 1000, .tv_nsec = 0 };
  78
  79   TEMP_FAILURE_RETRY (aio_suspend (l, 1, &ts));
  80
  81   pthread_cleanup_pop (0);
  82
  83   puts ("tf2: aio_suspend returned");
  84
  85   exit (1);
  86 }
  87
  88
  89 static int
  90 do_test (void)
  91 {
  92   int fds[2];
  93   if (pipe (fds) != 0)
  94     {
  95       puts ("pipe failed");
  96       return 1;
  97     }
  98
  99   struct aiocb a, a2, *ap;
 100   char mem[1];
 101   memset (&a, '\0', sizeof (a));
 102   a.aio_fildes = fds[0];
 103   a.aio_buf = mem;
 104   a.aio_nbytes = sizeof (mem);
 105   if (aio_read (&a) != 0)
 106     {
 107       puts ("aio_read failed");
 108       return 1;
 109     }
 110
 111   if (pthread_barrier_init (&b, NULL, 2) != 0)
 112     {
 113       puts ("barrier_init failed");
 114       return 1;
 115     }
 116
 117   pthread_t th;
 118   if (pthread_create (&th, NULL, tf, &a) != 0)
 119     {
 120       puts ("1st create failed");
 121       return 1;
 122     }
 123
 124   int r = pthread_barrier_wait (&b);
 125   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 126     {
 127       puts ("barrier_wait failed");
 128       exit (1);
 129     }
 130
 131   struct timespec  ts = { .tv_sec = 0, .tv_nsec = 100000000 };
 132   while (nanosleep (&ts, &ts) != 0)
 133     continue;
 134
 135   puts ("going to cancel tf in-time");
 136   if (pthread_cancel (th) != 0)
 137     {
 138       puts ("1st cancel failed");
 139       return 1;
 140     }
 141
 142   void *status;
 143   if (pthread_join (th, &status) != 0)
 144     {
 145       puts ("1st join failed");
 146       return 1;
 147     }
 148   if (status != PTHREAD_CANCELED)
 149     {
 150       puts ("1st thread not canceled");
 151       return 1;
 152     }
 153
 154   if (cl_called == 0)
 155     {
 156       puts ("tf cleanup handler not called");
 157       return 1;
 158     }
 159   if (cl_called > 1)
 160     {
 161       puts ("tf cleanup handler called more than once");
 162       return 1;
 163     }
 164
 165   cl_called = 0;
 166
 167   if (pthread_create (&th, NULL, tf2, &a) != 0)
 168     {
 169       puts ("2nd create failed");
 170       return 1;
 171     }
 172
 173   r = pthread_barrier_wait (&b);
 174   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 175     {
 176       puts ("2nd barrier_wait failed");
 177       exit (1);
 178     }
 179
 180   ts.tv_sec = 0;
 181   ts.tv_nsec = 100000000;
 182   while (nanosleep (&ts, &ts) != 0)
 183     continue;
 184
 185   puts ("going to cancel tf2 in-time");
 186   if (pthread_cancel (th) != 0)
 187     {
 188       puts ("2nd cancel failed");
 189       return 1;
 190     }
 191
 192   if (pthread_join (th, &status) != 0)
 193     {
 194       puts ("2nd join failed");
 195       return 1;
 196     }
 197   if (status != PTHREAD_CANCELED)
 198     {
 199       puts ("2nd thread not canceled");
 200       return 1;
 201     }
 202
 203   if (cl_called == 0)
 204     {
 205       puts ("tf2 cleanup handler not called");
 206       return 1;
 207     }
 208   if (cl_called > 1)
 209     {
 210       puts ("tf2 cleanup handler called more than once");
 211       return 1;
 212     }
 213
 214   puts ("in-time cancellation succeeded");
 215
 216   ap = &a;
 217   if (aio_cancel (fds[0], &a) != AIO_CANCELED)
 218     {
 219       puts ("aio_cancel failed");
 220       /* If aio_cancel failed, we cannot reuse aiocb a.  */
 221       ap = &a2;
 222     }
 223
 224
 225   cl_called = 0;
 226
 227   size_t len2 = fpathconf (fds[1], _PC_PIPE_BUF);
 228   size_t page_size = sysconf (_SC_PAGESIZE);
 229   len2 = 20 * (len2 < page_size ? page_size : len2) + sizeof (mem) + 1;
 230   char *mem2 = malloc (len2);
 231   if (mem2 == NULL)
 232     {
 233       puts ("could not allocate memory for pipe write");
 234       return 1;
 235     }
 236
 237   memset (ap, '\0', sizeof (*ap));
 238   ap->aio_fildes = fds[1];
 239   ap->aio_buf = mem2;
 240   ap->aio_nbytes = len2;
 241   if (aio_write (ap) != 0)
 242     {
 243       puts ("aio_write failed");
 244       return 1;
 245     }
 246
 247   if (pthread_create (&th, NULL, tf, ap) != 0)
 248     {
 249       puts ("3rd create failed");
 250       return 1;
 251     }
 252
 253   puts ("going to cancel tf early");
 254   if (pthread_cancel (th) != 0)
 255     {
 256       puts ("3rd cancel failed");
 257       return 1;
 258     }
 259
 260   r = pthread_barrier_wait (&b);
 261   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 262     {
 263       puts ("3rd barrier_wait failed");
 264       exit (1);
 265     }
 266
 267   if (pthread_join (th, &status) != 0)
 268     {
 269       puts ("3rd join failed");
 270       return 1;
 271     }
 272   if (status != PTHREAD_CANCELED)
 273     {
 274       puts ("3rd thread not canceled");
 275       return 1;
 276     }
 277
 278   if (cl_called == 0)
 279     {
 280       puts ("tf cleanup handler not called");
 281       return 1;
 282     }
 283   if (cl_called > 1)
 284     {
 285       puts ("tf cleanup handler called more than once");
 286       return 1;
 287     }
 288
 289   cl_called = 0;
 290
 291   if (pthread_create (&th, NULL, tf2, ap) != 0)
 292     {
 293       puts ("4th create failed");
 294       return 1;
 295     }
 296
 297   puts ("going to cancel tf2 early");
 298   if (pthread_cancel (th) != 0)
 299     {
 300       puts ("4th cancel failed");
 301       return 1;
 302     }
 303
 304   r = pthread_barrier_wait (&b);
 305   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 306     {
 307       puts ("4th barrier_wait failed");
 308       exit (1);
 309     }
 310
 311   if (pthread_join (th, &status) != 0)
 312     {
 313       puts ("4th join failed");
 314       return 1;
 315     }
 316   if (status != PTHREAD_CANCELED)
 317     {
 318       puts ("4th thread not canceled");
 319       return 1;
 320     }
 321
 322   if (cl_called == 0)
 323     {
 324       puts ("tf2 cleanup handler not called");
 325       return 1;
 326     }
 327   if (cl_called > 1)
 328     {
 329       puts ("tf2 cleanup handler called more than once");
 330       return 1;
 331     }
 332
 333   puts ("early cancellation succeeded");
 334
 335   if (ap == &a2)
 336     {
 337       /* The aio_read(&a) was not canceled because the read request was
 338          already in progress. In the meanwhile aio_write(ap) wrote something
 339          to the pipe and the read request either has already been finished or
 340          is able to read the requested byte.
 341          Wait for the read request before returning from this function because
 342          the return value and error code from the read syscall will be written
 343          to the struct aiocb a, which lies on the stack of this function.
 344          Otherwise the stack from subsequent function calls - e.g. _dl_fini -
 345          will be corrupted, which can lead to undefined behaviour like a
 346          segmentation fault.  */
 347       const struct aiocb *l[1] = { &a };
 348       TEMP_FAILURE_RETRY (aio_suspend(l, 1, NULL));
 349     }
 350
 351   return 0;
 352 }
 353
 354 #define TEST_FUNCTION do_test ()
 355 #include "../test-skeleton.c"