Update.
[glibc.git] / rt / tst-aio64.c
blob0efd0d30a7aa7ed91ad9a39f0ec143ec5dcc65ce
1 /* Tests for 64bit AIO in librt.
2 Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
3 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 License, or (at your option) any later version.
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 Library General Public License for more details.
15 You should have received a copy of the GNU Library General Public
16 License along with the GNU C Library; see the file COPYING.LIB. If not,
17 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
20 #define _LARGEFILE_SOURCE 1
21 #include <aio.h>
22 #include <errno.h>
23 #include <error.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <sys/stat.h>
30 /* Prototype for our test function. */
31 extern void do_prepare (int argc, char *argv[]);
32 extern int do_test (int argc, char *argv[]);
34 /* We have a preparation function. */
35 #define PREPARE do_prepare
37 /* We might need a bit longer timeout. */
38 #define TIMEOUT 20 /* sec */
40 /* This defines the `main' function and some more. */
41 #include <test-skeleton.c>
44 /* These are for the temporary file we generate. */
45 char *name;
46 int fd;
48 void
49 do_prepare (int argc, char *argv[])
51 char name_len;
53 name_len = strlen (test_dir);
54 name = malloc (name_len + sizeof ("/aioXXXXXX"));
55 mempcpy (mempcpy (name, test_dir, name_len),
56 "/aioXXXXXX", sizeof ("/aioXXXXXX"));
57 add_temp_file (name);
59 /* Open our test file. */
60 fd = mkstemp (name);
61 if (fd == -1)
62 error (EXIT_FAILURE, errno, "cannot open test file `%s'", name);
66 static int
67 test_file (const void *buf, size_t size, int fd, const char *msg)
69 struct stat st;
70 char tmp[size];
72 errno = 0;
73 if (fstat (fd, &st) < 0)
75 error (0, errno, "%s: failed stat", msg);
76 return 1;
79 if (st.st_size != size)
81 error (0, errno, "%s: wrong size: %lu, should be %lu",
82 msg, (unsigned long int) st.st_size, (unsigned long int) size);
83 return 1;
86 if (pread (fd, tmp, size, 0) != size)
88 error (0, errno, "%s: failed pread", msg);
89 return 1;
92 if (memcmp (buf, tmp, size) != 0)
94 error (0, errno, "%s: failed comparison", msg);
95 return 1;
98 printf ("%s test ok\n", msg);
100 return 0;
104 static int
105 do_wait (struct aiocb64 **cbp, size_t nent, int allowed_err)
107 int go_on;
108 size_t cnt;
109 int result = 0;
113 aio_suspend64 ((const struct aiocb64 *const *) cbp, nent, NULL);
114 go_on = 0;
115 for (cnt = 0; cnt < nent; ++cnt)
116 if (cbp[cnt] != NULL)
118 if (aio_error64 (cbp[cnt]) == EINPROGRESS)
119 go_on = 1;
120 else
122 if (aio_return64 (cbp[cnt]) == -1
123 && (allowed_err == 0
124 || aio_error64 (cbp[cnt]) != allowed_err))
126 error (0, aio_error64 (cbp[cnt]), "Operation failed\n");
127 result = 1;
129 cbp[cnt] = NULL;
133 while (go_on);
135 return result;
140 do_test (int argc, char *argv[])
142 struct aiocb64 cbs[10];
143 struct aiocb64 cbs_fsync;
144 struct aiocb64 *cbp[10];
145 struct aiocb64 *cbp_fsync[1];
146 char buf[1000];
147 size_t cnt;
148 int result = 0;
150 /* Preparation. */
151 for (cnt = 0; cnt < 10; ++cnt)
153 cbs[cnt].aio_fildes = fd;
154 cbs[cnt].aio_reqprio = 0;
155 cbs[cnt].aio_buf = memset (&buf[cnt * 100], '0' + cnt, 100);
156 cbs[cnt].aio_nbytes = 100;
157 cbs[cnt].aio_offset = cnt * 100;
158 cbs[cnt].aio_sigevent.sigev_notify = SIGEV_NONE;
160 cbp[cnt] = &cbs[cnt];
163 /* First a simple test. */
164 for (cnt = 10; cnt > 0; )
165 aio_write64 (cbp[--cnt]);
166 /* Wait 'til the results are there. */
167 result |= do_wait (cbp, 10, 0);
168 /* Test this. */
169 result |= test_file (buf, sizeof (buf), fd, "aio_write");
171 /* Read now as we've written it. */
172 memset (buf, '\0', sizeof (buf));
173 /* Issue the commands. */
174 for (cnt = 10; cnt > 0; )
176 --cnt;
177 cbp[cnt] = &cbs[cnt];
178 aio_read64 (cbp[cnt]);
180 /* Wait 'til the results are there. */
181 result |= do_wait (cbp, 10, 0);
182 /* Test this. */
183 for (cnt = 0; cnt < 1000; ++cnt)
184 if (buf[cnt] != '0' + (cnt / 100))
186 result = 1;
187 error (0, 0, "comparison failed for aio_read test");
188 break;
191 if (cnt == 1000)
192 puts ("aio_read test ok");
194 /* Remove the test file contents. */
195 if (ftruncate64 (fd, 0) < 0)
197 error (0, errno, "ftruncate failed\n");
198 result = 1;
201 /* Test lio_listio. */
202 for (cnt = 0; cnt < 10; ++cnt)
204 cbs[cnt].aio_lio_opcode = LIO_WRITE;
205 cbp[cnt] = &cbs[cnt];
207 /* Issue the command. */
208 lio_listio64 (LIO_WAIT, cbp, 10, NULL);
209 /* ...and immediately test it since we started it in wait mode. */
210 result |= test_file (buf, sizeof (buf), fd, "lio_listio (write)");
212 /* Test aio_fsync. */
213 cbs_fsync.aio_fildes = fd;
214 cbs_fsync.aio_sigevent.sigev_notify = SIGEV_NONE;
215 cbp_fsync[0] = &cbs_fsync;
217 /* Remove the test file contents first. */
218 if (ftruncate64 (fd, 0) < 0)
220 error (0, errno, "ftruncate failed\n");
221 result = 1;
224 /* Write again. */
225 for (cnt = 10; cnt > 0; )
226 aio_write64 (cbp[--cnt]);
228 if (aio_fsync64 (O_SYNC, &cbs_fsync) < 0)
230 error (0, errno, "aio_fsync failed\n");
231 result = 1;
233 result |= do_wait (cbp_fsync, 1, 0);
235 /* ...and test since all data should be on disk now. */
236 result |= test_file (buf, sizeof (buf), fd, "aio_fsync (aio_write)");
238 /* Test aio_cancel. */
239 /* Remove the test file contents first. */
240 if (ftruncate64 (fd, 0) < 0)
242 error (0, errno, "ftruncate failed\n");
243 result = 1;
246 /* Write again. */
247 for (cnt = 10; cnt > 0; )
248 aio_write64 (cbp[--cnt]);
250 /* Cancel all requests. */
251 if (aio_cancel64 (fd, NULL) == -1)
252 printf ("aio_cancel64 (fd, NULL) cannot cancel anything\n");
254 result |= do_wait (cbp, 10, ECANCELED);
256 /* Another test for aio_cancel. */
257 /* Remove the test file contents first. */
258 if (ftruncate64 (fd, 0) < 0)
260 error (0, errno, "ftruncate failed\n");
261 result = 1;
264 /* Write again. */
265 for (cnt = 10; cnt > 0; )
267 --cnt;
268 cbp[cnt] = &cbs[cnt];
269 aio_write64 (cbp[cnt]);
271 puts ("finished3");
273 /* Cancel all requests. */
274 for (cnt = 10; cnt > 0; )
275 if (aio_cancel64 (fd, cbp[--cnt]) == -1)
276 /* This is not an error. The request can simply be finished. */
277 printf ("aio_cancel64 (fd, cbp[%Zd]) cannot be canceled\n", cnt);
278 puts ("finished2");
280 result |= do_wait (cbp, 10, ECANCELED);
282 puts ("finished");
284 return result;