robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 1 | /* |
| 2 | * |
| 3 | * Copyright (c) International Business Machines Corp., 2002 |
| 4 | * |
| 5 | * This program is free software; you can redistribute it and/or modify |
| 6 | * it under the terms of the GNU General Public License as published by |
| 7 | * the Free Software Foundation; either version 2 of the License, or |
| 8 | * (at your option) any later version. |
| 9 | * |
| 10 | * This program 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 |
| 13 | * the GNU General Public License for more details. |
| 14 | * |
| 15 | * You should have received a copy of the GNU General Public License |
| 16 | * along with this program; if not, write to the Free Software |
Wanlong Gao | 4548c6c | 2012-10-19 18:03:36 +0800 | [diff] [blame] | 17 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 18 | */ |
| 19 | |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 20 | /* |
| 21 | * NAME |
| 22 | * diotest6.c |
| 23 | * |
| 24 | * DESCRIPTION |
| 25 | * Fork given number of children. Each child opens the same file, but |
| 26 | * uses its own file descriptior. The child does writes and reads from |
| 27 | * its segment in the file. The segment to which the child writes is |
| 28 | * determined by childnumber * bufsize. There is no need to use any locks. |
| 29 | * Tests the combinations of buffered/direct readv(), writev() calls. |
| 30 | * Test program contains the following test blocks: |
| 31 | * [1] Direct Read, Buffered write |
| 32 | * [2] Direct Write, Buffered read |
| 33 | * [3] Direct Read, Direct Write |
| 34 | * |
| 35 | * USAGE |
| 36 | * diotest6 [-b bufsize] [-o offset] [-n numchild] [-i iterations] |
| 37 | * [-v nvector] [-f fileaname] |
subrata_modak | 4bb656a | 2009-02-26 12:02:09 +0000 | [diff] [blame] | 38 | * |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 39 | * History |
| 40 | * 04/30/2002 Narasimha Sharoff nsharoff@us.ibm.com |
| 41 | * |
| 42 | * RESTRICTIONS |
| 43 | * None |
| 44 | */ |
| 45 | |
| 46 | #include <stdio.h> |
| 47 | #include <stdlib.h> |
| 48 | #include <unistd.h> |
| 49 | #include <string.h> |
| 50 | #include <sys/file.h> |
| 51 | #include <sys/fcntl.h> |
mridge | b48651d | 2004-05-18 17:05:51 +0000 | [diff] [blame] | 52 | #include <sys/syscall.h> |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 53 | #include <sys/uio.h> |
| 54 | #include <errno.h> |
| 55 | |
robbiew | f7dc1be | 2003-03-14 16:20:37 +0000 | [diff] [blame] | 56 | #include "diotest_routines.h" |
| 57 | |
robbiew | 96f4bb3 | 2003-03-13 15:39:53 +0000 | [diff] [blame] | 58 | #include "test.h" |
robbiew | 96f4bb3 | 2003-03-13 15:39:53 +0000 | [diff] [blame] | 59 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 60 | char *TCID = "diotest06"; /* Test program identifier. */ |
| 61 | int TST_TOTAL = 3; /* Total number of test conditions */ |
robbiew | 8680e9b | 2003-11-19 15:29:01 +0000 | [diff] [blame] | 62 | |
robbiew | 96f4bb3 | 2003-03-13 15:39:53 +0000 | [diff] [blame] | 63 | #ifdef O_DIRECT |
| 64 | |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 65 | #define BUFSIZE 4096 |
| 66 | #define TRUE 1 |
| 67 | #define LEN 30 |
| 68 | #define READ_DIRECT 1 |
| 69 | #define WRITE_DIRECT 2 |
| 70 | #define RDWR_DIRECT 3 |
| 71 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 72 | static int iter = 100; /* Iterations. Default 100 */ |
| 73 | static int bufsize = BUFSIZE; /* Buffersize. Default 4k */ |
| 74 | static off64_t offset = 0; /* Offset. Default 0 */ |
| 75 | static int nvector = 20; /* Vector array. Default 20 */ |
| 76 | static char filename[LEN]; /* Test data file */ |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 77 | static int fd1 = -1; |
| 78 | |
| 79 | static void setup(void); |
| 80 | static void cleanup(void); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 81 | |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 82 | /* |
| 83 | * prg_usage: display the program usage |
| 84 | */ |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 85 | void prg_usage() |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 86 | { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 87 | fprintf(stderr, |
| 88 | "Usage: diotest6 [-b bufsize] [-o offset] [-n numchild] [-i iterations] [-v nvector] [-f filename]\n"); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 89 | exit(1); |
| 90 | } |
| 91 | |
| 92 | /* |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 93 | * runtest: write the data to the file. Read the data from the file and compare. |
subrata_modak | 4bb656a | 2009-02-26 12:02:09 +0000 | [diff] [blame] | 94 | * For each iteration, write data starting at offse+iter*bufsize |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 95 | * location in the file and read from there. |
| 96 | */ |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 97 | int runtest(int fd_r, int fd_w, int childnum, int action) |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 98 | { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 99 | off64_t seekoff; |
| 100 | int i, bufsize = BUFSIZE; |
| 101 | struct iovec *iov1, *iov2, *iovp; |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 102 | |
| 103 | /* Allocate for buffers and data pointers */ |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 104 | seekoff = offset + bufsize * childnum; |
| 105 | if ((iov1 = |
| 106 | (struct iovec *)valloc(sizeof(struct iovec) * nvector)) == NULL) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 107 | tst_resm(TFAIL, "valloc buf1 failed: %s", strerror(errno)); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 108 | return (-1); |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 109 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 110 | if ((iov2 = |
| 111 | (struct iovec *)valloc(sizeof(struct iovec) * nvector)) == NULL) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 112 | tst_resm(TFAIL, "valloc buf2 failed: %s", strerror(errno)); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 113 | return (-1); |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 114 | } |
| 115 | for (i = 0, iovp = iov1; i < nvector; iovp++, i++) { |
| 116 | if ((iovp->iov_base = valloc(bufsize)) == NULL) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 117 | tst_resm(TFAIL, "valloc for iovp->iov_base: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 118 | strerror(errno)); |
| 119 | return (-1); |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 120 | } |
| 121 | iovp->iov_len = bufsize; |
| 122 | } |
| 123 | for (i = 0, iovp = iov2; i < nvector; iovp++, i++) { |
| 124 | if ((iovp->iov_base = valloc(bufsize)) == NULL) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 125 | tst_resm(TFAIL, "valloc, iov2 for iovp->iov_base: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 126 | strerror(errno)); |
| 127 | return (-1); |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 128 | } |
| 129 | iovp->iov_len = bufsize; |
| 130 | } |
| 131 | |
| 132 | /* seek, write, read and verify */ |
| 133 | for (i = 0; i < iter; i++) { |
| 134 | /* |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 135 | fillbuf(buf1, bufsize, childnum+i); |
| 136 | */ |
| 137 | vfillbuf(iov1, nvector, childnum + i); |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 138 | if (lseek(fd_w, seekoff, SEEK_SET) < 0) { |
subrata_modak | 4bb656a | 2009-02-26 12:02:09 +0000 | [diff] [blame] | 139 | tst_resm(TFAIL, "lseek before write failed: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 140 | strerror(errno)); |
| 141 | return (-1); |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 142 | } |
| 143 | if (write(fd_w, iov1, bufsize) < bufsize) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 144 | tst_resm(TFAIL, "write failed: %s", strerror(errno)); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 145 | return (-1); |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 146 | } |
| 147 | if (action == READ_DIRECT) { |
| 148 | /* Make sure data is on to disk before read */ |
| 149 | if (fsync(fd_w) < 0) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 150 | tst_resm(TFAIL, "fsync failed: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 151 | strerror(errno)); |
| 152 | return (-1); |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 153 | } |
| 154 | } |
| 155 | if (lseek(fd_r, seekoff, SEEK_SET) < 0) { |
subrata_modak | 4bb656a | 2009-02-26 12:02:09 +0000 | [diff] [blame] | 156 | tst_resm(TFAIL, "lseek before read failed: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 157 | strerror(errno)); |
| 158 | return (-1); |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 159 | } |
| 160 | if (read(fd_r, iov2, bufsize) < bufsize) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 161 | tst_resm(TFAIL, "read failed: %s", strerror(errno)); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 162 | return (-1); |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 163 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 164 | if (bufcmp((char *)iov1, (char *)iov2, bufsize) != 0) { |
subrata_modak | 4bb656a | 2009-02-26 12:02:09 +0000 | [diff] [blame] | 165 | tst_resm(TFAIL, "comparsion failed. Child=%d offset=%d", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 166 | childnum, (int)seekoff); |
| 167 | return (-1); |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 168 | } |
| 169 | } |
subrata_modak | 43337a3 | 2009-02-26 11:43:51 +0000 | [diff] [blame] | 170 | return 0; |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 171 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 172 | |
robbiew | 8c64d1b | 2003-03-24 22:20:47 +0000 | [diff] [blame] | 173 | /* |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 174 | * child_function: open the file for read and write. Call the runtest routine. |
| 175 | */ |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 176 | int child_function(int childnum, int action) |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 177 | { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 178 | int fd_w, fd_r; |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 179 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 180 | switch (action) { |
| 181 | case READ_DIRECT: |
| 182 | if ((fd_w = open(filename, O_WRONLY | O_CREAT, 0666)) < 0) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 183 | tst_resm(TFAIL, "fd_w open failed for %s: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 184 | filename, strerror(errno)); |
| 185 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 186 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 187 | if ((fd_r = open(filename, O_DIRECT | O_RDONLY, 0666)) < 0) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 188 | tst_resm(TFAIL, "fd_r open failed for %s: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 189 | filename, strerror(errno)); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 190 | close(fd_w); |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 191 | unlink(filename); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 192 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 193 | } |
| 194 | if (runtest(fd_r, fd_w, childnum, action) == -1) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 195 | tst_resm(TFAIL, "Read Direct-child %d failed", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 196 | childnum); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 197 | close(fd_w); |
| 198 | close(fd_r); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 199 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 200 | } |
| 201 | break; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 202 | case WRITE_DIRECT: |
| 203 | if ((fd_w = |
| 204 | open(filename, O_DIRECT | O_WRONLY | O_CREAT, 0666)) < 0) { |
| 205 | tst_resm(TFAIL, "fd_w open failed for %s: %s", filename, |
| 206 | strerror(errno)); |
| 207 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 208 | } |
| 209 | if ((fd_r = open(filename, O_RDONLY, 0666)) < 0) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 210 | tst_resm(TFAIL, "fd_r open failed for %s: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 211 | filename, strerror(errno)); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 212 | close(fd_w); |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 213 | unlink(filename); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 214 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 215 | } |
| 216 | if (runtest(fd_r, fd_w, childnum, action) == -1) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 217 | tst_resm(TFAIL, "Write Direct-child %d failed", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 218 | childnum); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 219 | close(fd_w); |
| 220 | close(fd_r); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 221 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 222 | } |
| 223 | break; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 224 | case RDWR_DIRECT: |
| 225 | if ((fd_w = |
| 226 | open(filename, O_DIRECT | O_WRONLY | O_CREAT, 0666)) < 0) { |
| 227 | tst_resm(TFAIL, "fd_w open failed for %s: %s", filename, |
| 228 | strerror(errno)); |
| 229 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 230 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 231 | if ((fd_r = open(filename, O_DIRECT | O_RDONLY, 0666)) < 0) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 232 | tst_resm(TFAIL, "fd_r open failed for %s: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 233 | filename, strerror(errno)); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 234 | close(fd_w); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 235 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 236 | } |
| 237 | if (runtest(fd_r, fd_w, childnum, action) == -1) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 238 | tst_resm(TFAIL, "RDWR Direct-child %d failed", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 239 | childnum); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 240 | close(fd_w); |
| 241 | close(fd_r); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 242 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 243 | } |
| 244 | break; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 245 | default: |
| 246 | fprintf(stderr, "Invalid Action Value\n"); |
| 247 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 248 | } |
| 249 | close(fd_w); |
| 250 | close(fd_r); |
| 251 | exit(0); |
| 252 | } |
| 253 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 254 | int main(int argc, char *argv[]) |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 255 | { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 256 | int *pidlst; |
| 257 | int numchild = 1; /* Number of children. Default 5 */ |
| 258 | int i, fail_count = 0, failed = 0, total = 0; |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 259 | |
| 260 | /* Options */ |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 261 | sprintf(filename, "testdata-6.%ld", syscall(__NR_gettid)); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 262 | while ((i = getopt(argc, argv, "b:o:i:n:v:f:")) != -1) { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 263 | switch (i) { |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 264 | case 'b': |
| 265 | if ((bufsize = atoi(optarg)) <= 0) { |
| 266 | fprintf(stderr, "bufsize must be > 0\n"); |
| 267 | prg_usage(); |
| 268 | } |
| 269 | if (bufsize % 4096 != 0) { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 270 | fprintf(stderr, |
| 271 | "bufsize must be multiple of 4k\n"); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 272 | prg_usage(); |
| 273 | } |
| 274 | break; |
| 275 | case 'o': |
| 276 | if ((offset = atoi(optarg)) <= 0) { |
| 277 | fprintf(stderr, "offset must be > 0\n"); |
| 278 | prg_usage(); |
| 279 | } |
| 280 | break; |
| 281 | case 'i': |
| 282 | if ((iter = atoi(optarg)) <= 0) { |
| 283 | fprintf(stderr, "iterations must be > 0\n"); |
| 284 | prg_usage(); |
| 285 | } |
| 286 | break; |
| 287 | case 'n': |
| 288 | if ((numchild = atoi(optarg)) <= 0) { |
| 289 | fprintf(stderr, "no of children must be > 0\n"); |
| 290 | prg_usage(); |
| 291 | } |
| 292 | break; |
| 293 | case 'v': |
| 294 | if ((nvector = atoi(optarg)) <= 0) { |
| 295 | fprintf(stderr, "vectory array must be > 0\n"); |
| 296 | prg_usage(); |
| 297 | } |
| 298 | break; |
| 299 | case 'f': |
| 300 | strcpy(filename, optarg); |
| 301 | break; |
| 302 | default: |
| 303 | prg_usage(); |
| 304 | } |
| 305 | } |
| 306 | |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 307 | setup(); |
robbiew | 8680e9b | 2003-11-19 15:29:01 +0000 | [diff] [blame] | 308 | |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 309 | /* Testblock-1: Read with Direct IO, Write without */ |
Garrett Cooper | 8fb1cdb | 2010-11-28 22:56:35 -0800 | [diff] [blame] | 310 | if (forkchldrn(&pidlst, numchild, READ_DIRECT, child_function) < 0) { |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 311 | failed = TRUE; |
| 312 | fail_count++; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 313 | tst_resm(TFAIL, "Read with Direct IO, Write without"); |
| 314 | } else { |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 315 | if (waitchldrn(&pidlst, numchild) < 0) { |
| 316 | failed = TRUE; |
| 317 | fail_count++; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 318 | tst_resm(TFAIL, "Read with Direct IO, Write without"); |
| 319 | } else |
| 320 | tst_resm(TPASS, "Read with Direct IO, Write without"); |
robbiew | 92b688b | 2004-03-01 22:36:38 +0000 | [diff] [blame] | 321 | |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 322 | } |
| 323 | unlink(filename); |
| 324 | free(pidlst); |
| 325 | total++; |
| 326 | |
| 327 | /* Testblock-2: Write with Direct IO, Read without */ |
| 328 | if (forkchldrn(&pidlst, numchild, WRITE_DIRECT, child_function) < 0) { |
| 329 | failed = TRUE; |
| 330 | fail_count++; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 331 | tst_resm(TFAIL, "Write with Direct IO, Read without"); |
| 332 | } else { |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 333 | if (waitchldrn(&pidlst, numchild) < 0) { |
| 334 | failed = TRUE; |
| 335 | fail_count++; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 336 | tst_resm(TFAIL, "Write with Direct IO, Read without"); |
| 337 | } else |
| 338 | tst_resm(TPASS, "Write with Direct IO, Read without"); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 339 | } |
| 340 | unlink(filename); |
| 341 | free(pidlst); |
| 342 | total++; |
| 343 | |
| 344 | /* Testblock-3: Read, Write with Direct IO. */ |
| 345 | if (forkchldrn(&pidlst, numchild, RDWR_DIRECT, child_function) < 0) { |
| 346 | failed = TRUE; |
| 347 | fail_count++; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 348 | tst_resm(TFAIL, "Read, Write with Direct IO"); |
| 349 | } else { |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 350 | if (waitchldrn(&pidlst, numchild) < 0) { |
| 351 | failed = TRUE; |
| 352 | fail_count++; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 353 | tst_resm(TFAIL, "Read, Write with Direct IO"); |
| 354 | } else |
| 355 | tst_resm(TPASS, "Read, Write with Direct IO"); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 356 | } |
| 357 | unlink(filename); |
| 358 | free(pidlst); |
| 359 | total++; |
| 360 | |
robbiew | 92b688b | 2004-03-01 22:36:38 +0000 | [diff] [blame] | 361 | if (failed) |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 362 | tst_resm(TINFO, "%d/%d testblocks failed", fail_count, total); |
robbiew | 92b688b | 2004-03-01 22:36:38 +0000 | [diff] [blame] | 363 | else |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 364 | tst_resm(TINFO, |
| 365 | "%d testblocks %d iterations with %d children completed", |
| 366 | total, iter, numchild); |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 367 | cleanup(); |
Garrett Cooper | 2c28215 | 2010-12-16 00:55:50 -0800 | [diff] [blame] | 368 | tst_exit(); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 369 | } |
| 370 | |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 371 | static void setup(void) |
| 372 | { |
| 373 | tst_tmpdir(); |
| 374 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 375 | if ((fd1 = open(filename, O_CREAT | O_EXCL, 0600)) < 0) { |
| 376 | tst_brkm(TBROK, cleanup, "Couldn't create test file %s: %s", |
| 377 | filename, strerror(errno)); |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 378 | } |
| 379 | close(fd1); |
| 380 | |
| 381 | /* Test for filesystem support of O_DIRECT */ |
| 382 | if ((fd1 = open(filename, O_DIRECT, 0600)) < 0) { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 383 | tst_brkm(TCONF, cleanup, |
| 384 | "O_DIRECT is not supported by this filesystem. %s", |
| 385 | strerror(errno)); |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 386 | } |
Subrata Modak | 76a720a | 2010-07-03 21:08:18 +0530 | [diff] [blame] | 387 | close(fd1); |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 388 | } |
| 389 | |
| 390 | static void cleanup(void) |
| 391 | { |
Garrett Cooper | df3eb16 | 2010-11-28 22:44:32 -0800 | [diff] [blame] | 392 | if (fd1 != -1) |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 393 | unlink(filename); |
| 394 | |
| 395 | tst_rmdir(); |
| 396 | |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 397 | } |
robbiew | 96f4bb3 | 2003-03-13 15:39:53 +0000 | [diff] [blame] | 398 | |
| 399 | #else /* O_DIRECT */ |
| 400 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 401 | int main() |
| 402 | { |
robbiew | 96f4bb3 | 2003-03-13 15:39:53 +0000 | [diff] [blame] | 403 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 404 | tst_resm(TCONF, "O_DIRECT is not defined."); |
| 405 | return 0; |
robbiew | 96f4bb3 | 2003-03-13 15:39:53 +0000 | [diff] [blame] | 406 | } |
Chris Dearman | ec6edca | 2012-10-17 19:54:01 -0700 | [diff] [blame] | 407 | #endif /* O_DIRECT */ |