1  /* Test for completion thread handling.
       2     Copyright (C) 2000-2023 Free Software Foundation, Inc.
       3     This file is part of the GNU C Library.
       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     <https://www.gnu.org/licenses/>.  */
      18  
      19  #include <aio.h>
      20  #include <signal.h>
      21  #include <stdio.h>
      22  #include <stdlib.h>
      23  #include <unistd.h>
      24  #include <errno.h>
      25  
      26  #define MY_SIVAL 27
      27  
      28  volatile sig_atomic_t flag;
      29  
      30  
      31  static void
      32  callback (sigval_t s)
      33  {
      34    flag = s.sival_int;
      35  }
      36  
      37  static int
      38  wait_flag (void)
      39  {
      40    while (flag == 0)
      41      {
      42        puts ("Sleeping...");
      43        sleep (1);
      44      }
      45  
      46    if (flag != MY_SIVAL)
      47      {
      48        printf ("signal handler received wrong signal, flag is %d\n", flag);
      49        return 1;
      50      }
      51  
      52    return 0;
      53  }
      54  
      55  
      56  static int
      57  do_test (int argc, char *argv[])
      58  {
      59    char name[] = "/tmp/aio5.XXXXXX";
      60    int fd;
      61    struct aiocb *arr[1];
      62    struct aiocb cb;
      63    static const char buf[] = "Hello World\n";
      64    struct sigevent ev;
      65  
      66    fd = mkstemp (name);
      67    if (fd == -1)
      68      {
      69        printf ("cannot open temp name: %m\n");
      70        return 1;
      71      }
      72  
      73    unlink (name);
      74  
      75    arr[0] = &cb;
      76  
      77    cb.aio_fildes = fd;
      78    cb.aio_lio_opcode = LIO_WRITE;
      79    cb.aio_reqprio = 0;
      80    cb.aio_buf = (void *) buf;
      81    cb.aio_nbytes = sizeof (buf) - 1;
      82    cb.aio_offset = 0;
      83    cb.aio_sigevent.sigev_notify = SIGEV_THREAD;
      84    cb.aio_sigevent.sigev_notify_function = callback;
      85    cb.aio_sigevent.sigev_notify_attributes = NULL;
      86    cb.aio_sigevent.sigev_value.sival_int = MY_SIVAL;
      87  
      88    ev.sigev_notify = SIGEV_THREAD;
      89    ev.sigev_notify_function = callback;
      90    ev.sigev_notify_attributes = NULL;
      91    ev.sigev_value.sival_int = MY_SIVAL;
      92  
      93    /* First use aio_write.  */
      94    if (aio_write (arr[0]) < 0)
      95      {
      96        if (errno == ENOSYS)
      97  	{
      98  	  puts ("no aio support in this configuration");
      99  	  return 0;
     100  	}
     101        printf ("aio_write failed: %m\n");
     102        return 1;
     103      }
     104  
     105    if (wait_flag ())
     106      return 1;
     107  
     108    puts ("aio_write OK");
     109  
     110    flag = 0;
     111    /* Again with lio_listio.  */
     112    if (lio_listio (LIO_NOWAIT, arr, 1, &ev) < 0)
     113      {
     114        printf ("lio_listio failed: %m\n");
     115        return 1;
     116      }
     117  
     118    if (wait_flag ())
     119      return 1;
     120  
     121    puts ("all OK");
     122  
     123    return 0;
     124  }
     125  
     126  #include "../test-skeleton.c"