2002-09-30 Roland McGrath <roland@redhat.com>
[kopensolaris-gnu/glibc.git] / rt / tst-aio7.c
1 /* Test for AIO POSIX compliance.
2    Copyright (C) 2001,02 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, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #include <aio.h>
21 #include <error.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <unistd.h>
26
27
28 /* We might wait for 3 seconds, so increase timeout to 10 seconds.  */
29 #define TIMEOUT 10
30
31
32 #define TEST_FUNCTION do_test ()
33 static int
34 do_test (void)
35 {
36   int result = 0;
37   int piped[2];
38
39   /* Make a pipe that we will never write to, so we can block reading it.  */
40   if (pipe (piped) < 0)
41     {
42       perror ("pipe");
43       return 1;
44     }
45
46   /* Test for aio_cancel() detecting invalid file descriptor.  */
47   {
48     struct aiocb cb;
49     int fd = -1;
50
51     cb.aio_fildes = fd;
52     cb.aio_offset = 0;
53     cb.aio_buf = NULL;
54     cb.aio_nbytes = 0;
55     cb.aio_reqprio = 0;
56     cb.aio_sigevent.sigev_notify = SIGEV_NONE;
57
58     errno = 0;
59
60     /* Case one: invalid fds that match.  */
61     if (aio_cancel (fd, &cb) != -1 || errno != EBADF)
62       {
63         if (errno == ENOSYS)
64           {
65             puts ("no aio support in this configuration");
66             return 0;
67           }
68
69         puts ("aio_cancel( -1, {-1..} ) did not return -1 or errno != EBADF");
70         ++result;
71       }
72
73     cb.aio_fildes = -2;
74     errno = 0;
75
76     /* Case two: invalid fds that do not match; just print warning.  */
77     if (aio_cancel (fd, &cb) != -1 || errno != EBADF)
78       puts ("aio_cancel( -1, {-2..} ) did not return -1 or errno != EBADF");
79   }
80
81   /* Test for aio_fsync() detecting bad fd, and fd not open for writing.  */
82   {
83     struct aiocb cb;
84     int fd = -1;
85
86     cb.aio_fildes = fd;
87     cb.aio_offset = 0;
88     cb.aio_buf = NULL;
89     cb.aio_nbytes = 0;
90     cb.aio_reqprio = 0;
91     cb.aio_sigevent.sigev_notify = SIGEV_NONE;
92
93     errno = 0;
94
95     /* Case one: invalid fd.  */
96     if (aio_fsync (O_SYNC, &cb) != -1 || errno != EBADF)
97       {
98         puts ("aio_fsync( op, {-1..} ) did not return -1 or errno != EBADF");
99         ++result;
100       }
101
102     if ((fd = open ("/dev/null", O_RDONLY)) < 0)
103       error (1, errno, "opening /dev/null");
104
105     cb.aio_fildes = fd;
106     errno = 0;
107
108     /* Case two: valid fd but open for read only.  */
109     if (aio_fsync (O_SYNC, &cb) != -1 || errno != EBADF)
110       {
111         puts ("aio_fsync( op, {RO..} ) did not return -1 or errno != EBADF");
112         ++result;
113       }
114
115     close (fd);
116   }
117
118   /* Test for aio_suspend() suspending even if completed elements in list.  */
119   {
120     const int BYTES = 8, ELEMS = 2;
121     int i, r, fd;
122     char buff[BYTES];
123     char name[] = "/tmp/aio7.XXXXXX";
124     struct timespec timeout;
125     struct aiocb cb0, cb1;
126     struct aiocb *list[ELEMS];
127
128     fd = mkstemp (name);
129     if (fd < 0)
130       error (1, errno, "creating temp file");
131
132     if (unlink (name))
133       error (1, errno, "unlinking temp file");
134
135     if (write (fd, "01234567", BYTES) != BYTES)
136       error (1, errno, "writing to temp file");
137
138     cb0.aio_fildes = fd;
139     cb0.aio_offset = 0;
140     cb0.aio_buf = buff;
141     cb0.aio_nbytes = BYTES;
142     cb0.aio_reqprio = 0;
143     cb0.aio_sigevent.sigev_notify = SIGEV_NONE;
144
145     r = aio_read (&cb0);
146     if (r != 0)
147       error (1, errno, "reading from file");
148
149     while (aio_error (&(cb0)) == EINPROGRESS)
150       usleep (10);
151
152     for (i = 0; i < BYTES; i++)
153       printf ("%c ", buff[i]);
154     printf ("\n");
155
156     /* At this point, the first read is completed, so start another one on
157        the read half of a pipe on which nothing will be written.  */
158     cb1.aio_fildes = piped[0];
159     cb1.aio_offset = 0;
160     cb1.aio_buf = buff;
161     cb1.aio_nbytes = BYTES;
162     cb1.aio_reqprio = 0;
163     cb1.aio_sigevent.sigev_notify = SIGEV_NONE;
164
165     r = aio_read (&cb1);
166     if (r != 0)
167       error (1, errno, "reading from file");
168
169     /* Now call aio_suspend() with the two reads.  It should return
170      * immediately according to the POSIX spec.
171      */
172     list[0] = &cb0;
173     list[1] = &cb1;
174     timeout.tv_sec = 3;
175     timeout.tv_nsec = 0;
176     r = aio_suspend ((const struct aiocb * const *) list, ELEMS, &timeout);
177
178     if (r == -1 && errno == EAGAIN)
179       {
180         puts ("aio_suspend([done,blocked],2,3) suspended thread");
181         ++result;
182       }
183   }
184
185   return result;
186 }
187
188 #include "../test-skeleton.c"