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 | * diotest5.c |
| 23 | * |
| 24 | * DESCRIPTION |
| 25 | * The programs test buffered and direct IO with vector arrays using |
| 26 | * readv() and writev() calls. |
| 27 | * Test blocks |
| 28 | * [1] Direct readv, Buffered writev |
| 29 | * [2] Direct writev, Buffered readv |
| 30 | * [3] Direct readv, Direct writev |
| 31 | * The bufsize should be in n*4k size for direct readv, writev. The offset |
| 32 | * value marks the starting position in file from where to start the |
| 33 | * write and read. (Using larger offset, larger files can be tested). |
subrata_modak | 4bb656a | 2009-02-26 12:02:09 +0000 | [diff] [blame] | 34 | * The nvector gives vector array size. Test data file can be |
| 35 | * specified through commandline and is useful for running test with |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 36 | * raw devices as a file. |
| 37 | * |
| 38 | * USAGE |
subrata_modak | 4bb656a | 2009-02-26 12:02:09 +0000 | [diff] [blame] | 39 | * diotest5 [-b bufsize] [-o offset] [-i iterations] |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 40 | * [-v nvector] [-f filename] |
subrata_modak | 4bb656a | 2009-02-26 12:02:09 +0000 | [diff] [blame] | 41 | * |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 42 | * History |
| 43 | * 04/29/2002 Narasimha Sharoff nsharoff@us.ibm.com |
| 44 | * |
| 45 | * RESTRICTIONS |
| 46 | * None |
| 47 | */ |
| 48 | |
| 49 | #include <stdio.h> |
| 50 | #include <stdlib.h> |
| 51 | #include <unistd.h> |
| 52 | #include <string.h> |
| 53 | #include <sys/file.h> |
| 54 | #include <sys/fcntl.h> |
mridge | b48651d | 2004-05-18 17:05:51 +0000 | [diff] [blame] | 55 | #include <sys/syscall.h> |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 56 | #include <sys/uio.h> |
| 57 | #include <errno.h> |
| 58 | |
robbiew | f7dc1be | 2003-03-14 16:20:37 +0000 | [diff] [blame] | 59 | #include "diotest_routines.h" |
| 60 | |
robbiew | 96f4bb3 | 2003-03-13 15:39:53 +0000 | [diff] [blame] | 61 | #include "test.h" |
robbiew | 96f4bb3 | 2003-03-13 15:39:53 +0000 | [diff] [blame] | 62 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 63 | char *TCID = "diotest05"; /* Test program identifier. */ |
| 64 | int TST_TOTAL = 3; /* Total number of test conditions */ |
robbiew | 8680e9b | 2003-11-19 15:29:01 +0000 | [diff] [blame] | 65 | |
robbiew | 96f4bb3 | 2003-03-13 15:39:53 +0000 | [diff] [blame] | 66 | #ifdef O_DIRECT |
| 67 | |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 68 | #define BUFSIZE 4096 |
| 69 | #define TRUE 1 |
| 70 | #define LEN 30 |
| 71 | #define READ_DIRECT 1 |
| 72 | #define WRITE_DIRECT 2 |
| 73 | #define RDWR_DIRECT 3 |
| 74 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 75 | static int bufsize = BUFSIZE; /* Buffer size. Default 4k */ |
| 76 | static int iter = 20; /* Iterations. Default 20 */ |
| 77 | static int nvector = 20; /* Vector array. Default 20 */ |
| 78 | static off64_t offset = 0; /* Start offset. Default 0 */ |
| 79 | static char filename[LEN]; /* Test data file */ |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 80 | static int fd1 = -1; |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 81 | /* |
| 82 | * runtest: Write the data in vector array to the file. Read the data |
| 83 | * from the file into another vectory array and verify. Repeat the test. |
| 84 | */ |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 85 | int runtest(int fd_r, int fd_w, int iter, off64_t offset, int action) |
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 | int i, bufsize = BUFSIZE; |
| 88 | struct iovec *iov1, *iov2, *iovp; |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 89 | |
| 90 | /* Allocate for buffers and data pointers */ |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 91 | if ((iov1 = |
| 92 | (struct iovec *)valloc(sizeof(struct iovec) * nvector)) == NULL) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 93 | tst_resm(TFAIL, "valloc() buf1 failed: %s", strerror(errno)); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 94 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 95 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 96 | if ((iov2 = |
| 97 | (struct iovec *)valloc(sizeof(struct iovec) * nvector)) == NULL) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 98 | tst_resm(TFAIL, "valloc buf2 failed: %s", strerror(errno)); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 99 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 100 | } |
| 101 | for (i = 0, iovp = iov1; i < nvector; iovp++, i++) { |
| 102 | if ((iovp->iov_base = valloc(bufsize)) == NULL) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 103 | tst_resm(TFAIL, "valloc for iovp->iov_base: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 104 | strerror(errno)); |
| 105 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 106 | } |
| 107 | iovp->iov_len = bufsize; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 108 | } |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 109 | for (i = 0, iovp = iov2; i < nvector; iovp++, i++) { |
| 110 | if ((iovp->iov_base = valloc(bufsize)) == NULL) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 111 | tst_resm(TFAIL, "valloc, iov2 for iovp->iov_base: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 112 | strerror(errno)); |
| 113 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 114 | } |
| 115 | iovp->iov_len = bufsize; |
| 116 | } |
mridge | b48651d | 2004-05-18 17:05:51 +0000 | [diff] [blame] | 117 | |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 118 | /* Test */ |
| 119 | for (i = 0; i < iter; i++) { |
mridge | b48651d | 2004-05-18 17:05:51 +0000 | [diff] [blame] | 120 | vfillbuf(iov1, nvector, i); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 121 | vfillbuf(iov2, nvector, i + 1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 122 | if (lseek(fd_w, offset, SEEK_SET) < 0) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 123 | tst_resm(TFAIL, "lseek before writev failed: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 124 | strerror(errno)); |
| 125 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 126 | } |
| 127 | if (writev(fd_w, iov1, nvector) < 0) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 128 | tst_resm(TFAIL, "writev failed: %s", strerror(errno)); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 129 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 130 | } |
| 131 | if (lseek(fd_r, offset, SEEK_SET) < 0) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 132 | tst_resm(TFAIL, "lseek before readv failed: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 133 | strerror(errno)); |
| 134 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 135 | } |
| 136 | if (readv(fd_r, iov2, nvector) < 0) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 137 | tst_resm(TFAIL, "readv failed: %s", strerror(errno)); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 138 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 139 | } |
| 140 | if (vbufcmp(iov1, iov2, nvector) != 0) { |
vapier | 0bdbaa3 | 2006-02-12 10:56:55 +0000 | [diff] [blame] | 141 | tst_resm(TFAIL, "readv/writev comparision failed"); |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 142 | return (-1); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 143 | } |
| 144 | } |
| 145 | |
| 146 | /* Cleanup */ |
| 147 | for (i = 0, iovp = iov1; i < nvector; iovp++, i++) { |
| 148 | free(iovp->iov_base); |
| 149 | } |
| 150 | for (i = 0, iovp = iov2; i < nvector; iovp++, i++) { |
| 151 | free(iovp->iov_base); |
| 152 | } |
| 153 | free(iov1); |
| 154 | free(iov2); |
subrata_modak | 43337a3 | 2009-02-26 11:43:51 +0000 | [diff] [blame] | 155 | return 0; |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 156 | } |
| 157 | |
| 158 | /* |
| 159 | * prg_usage: Display the program usage |
| 160 | */ |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 161 | void prg_usage() |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 162 | { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 163 | fprintf(stderr, |
| 164 | "Usage: diotest5 [-b bufsize] [-o offset] [ -i iteration] [ -v nvector] [-f filename]\n"); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 165 | exit(1); |
| 166 | } |
| 167 | |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 168 | static void setup(void); |
| 169 | static void cleanup(void); |
| 170 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 171 | int main(int argc, char *argv[]) |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 172 | { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 173 | int i, action, fd_r, fd_w; |
| 174 | int fail_count = 0, total = 0, failed = 0; |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 175 | |
| 176 | /* Options */ |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 177 | sprintf(filename, "testdata-5.%ld", syscall(__NR_gettid)); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 178 | while ((i = getopt(argc, argv, "b:o:i:v:f:")) != -1) { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 179 | switch (i) { |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 180 | case 'b': |
| 181 | if ((bufsize = atoi(optarg)) <= 0) { |
| 182 | fprintf(stderr, "bufsize must be > 0"); |
| 183 | prg_usage(); |
| 184 | } |
| 185 | if (bufsize % 4096 != 0) { |
| 186 | fprintf(stderr, "bufsize must be > 0"); |
| 187 | prg_usage(); |
| 188 | } |
subrata_modak | bdbaec5 | 2009-02-26 12:14:51 +0000 | [diff] [blame] | 189 | break; |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 190 | case 'o': |
| 191 | if ((offset = atoll(optarg)) <= 0) { |
| 192 | fprintf(stderr, "offset must be > 0"); |
| 193 | prg_usage(); |
| 194 | } |
| 195 | break; |
| 196 | case 'i': |
| 197 | if ((iter = atoi(optarg)) <= 0) { |
| 198 | fprintf(stderr, "iterations must be > 0"); |
| 199 | prg_usage(); |
| 200 | } |
| 201 | break; |
| 202 | case 'v': |
| 203 | if ((nvector = atoi(optarg)) <= 0) { |
| 204 | fprintf(stderr, "vector array must be > 0"); |
| 205 | prg_usage(); |
| 206 | } |
| 207 | break; |
| 208 | case 'f': |
| 209 | strcpy(filename, optarg); |
| 210 | break; |
| 211 | default: |
| 212 | prg_usage(); |
| 213 | } |
| 214 | } |
| 215 | |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 216 | setup(); |
robbiew | 8680e9b | 2003-11-19 15:29:01 +0000 | [diff] [blame] | 217 | |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 218 | /* Testblock-1: Read with Direct IO, Write without */ |
| 219 | action = READ_DIRECT; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 220 | if ((fd_w = open(filename, O_WRONLY | O_CREAT, 0666)) < 0) { |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 221 | tst_brkm(TBROK, cleanup, "fd_w open failed for %s: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 222 | filename, strerror(errno)); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 223 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 224 | if ((fd_r = open64(filename, O_DIRECT | O_RDONLY | O_CREAT, 0666)) < 0) { |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 225 | tst_brkm(TBROK, cleanup, "fd_r open failed for %s: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 226 | filename, strerror(errno)); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 227 | } |
| 228 | if (runtest(fd_r, fd_w, iter, offset, action) < 0) { |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 229 | failed = TRUE; |
| 230 | fail_count++; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 231 | tst_resm(TFAIL, "Read with Direct IO, Write without"); |
| 232 | } else |
| 233 | tst_resm(TPASS, "Read with Direct IO, Write without"); |
robbiew | 92b688b | 2004-03-01 22:36:38 +0000 | [diff] [blame] | 234 | |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 235 | unlink(filename); |
| 236 | close(fd_r); |
| 237 | close(fd_w); |
| 238 | total++; |
| 239 | |
| 240 | /* Testblock-2: Write with Direct IO, Read without */ |
| 241 | action = WRITE_DIRECT; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 242 | if ((fd_w = open(filename, O_DIRECT | O_WRONLY | O_CREAT, 0666)) < 0) { |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 243 | tst_brkm(TBROK, cleanup, "fd_w open failed for %s: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 244 | filename, strerror(errno)); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 245 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 246 | if ((fd_r = open64(filename, O_RDONLY | O_CREAT, 0666)) < 0) { |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 247 | tst_brkm(TBROK, cleanup, "fd_r open failed for %s: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 248 | filename, strerror(errno)); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 249 | } |
| 250 | if (runtest(fd_r, fd_w, iter, offset, action) < 0) { |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 251 | failed = TRUE; |
| 252 | fail_count++; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 253 | tst_resm(TFAIL, "Write with Direct IO, Read without"); |
| 254 | } else |
| 255 | tst_resm(TPASS, "Write with Direct IO, Read without"); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 256 | unlink(filename); |
| 257 | close(fd_r); |
| 258 | close(fd_w); |
| 259 | total++; |
| 260 | |
| 261 | /* Testblock-3: Read, Write with Direct IO */ |
| 262 | action = RDWR_DIRECT; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 263 | if ((fd_w = open(filename, O_DIRECT | O_WRONLY | O_CREAT, 0666)) < 0) { |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 264 | tst_brkm(TBROK, cleanup, "fd_w open failed for %s: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 265 | filename, strerror(errno)); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 266 | } |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 267 | if ((fd_r = open64(filename, O_DIRECT | O_RDONLY | O_CREAT, 0666)) < 0) { |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 268 | tst_brkm(TBROK, cleanup, "fd_r open failed for %s: %s", |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 269 | filename, strerror(errno)); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 270 | } |
| 271 | if (runtest(fd_r, fd_w, iter, offset, action) < 0) { |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 272 | failed = TRUE; |
| 273 | fail_count++; |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 274 | tst_resm(TFAIL, "Read, Write with Direct IO"); |
| 275 | } else |
| 276 | tst_resm(TPASS, "Read, Write with Direct IO"); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 277 | unlink(filename); |
| 278 | close(fd_r); |
| 279 | close(fd_w); |
| 280 | total++; |
| 281 | |
robbiew | 92b688b | 2004-03-01 22:36:38 +0000 | [diff] [blame] | 282 | if (failed) |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 283 | tst_resm(TINFO, "%d/%d testblocks failed", fail_count, total); |
robbiew | 92b688b | 2004-03-01 22:36:38 +0000 | [diff] [blame] | 284 | else |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 285 | tst_resm(TINFO, |
| 286 | "%d testblocks %d iterations with %d vector array completed", |
| 287 | total, iter, nvector); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 288 | |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 289 | cleanup(); |
robbiew | 92b688b | 2004-03-01 22:36:38 +0000 | [diff] [blame] | 290 | |
Garrett Cooper | 72521cf | 2010-12-18 06:31:47 -0800 | [diff] [blame] | 291 | tst_exit(); |
robbiew | bfb98f9 | 2002-06-13 05:26:55 +0000 | [diff] [blame] | 292 | } |
robbiew | 96f4bb3 | 2003-03-13 15:39:53 +0000 | [diff] [blame] | 293 | |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 294 | static void setup(void) |
| 295 | { |
| 296 | tst_tmpdir(); |
| 297 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 298 | if ((fd1 = open(filename, O_CREAT | O_EXCL, 0600)) < 0) { |
| 299 | tst_brkm(TBROK, cleanup, "Couldn't create test file %s: %s", |
| 300 | filename, strerror(errno)); |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 301 | } |
| 302 | close(fd1); |
| 303 | |
| 304 | /* Test for filesystem support of O_DIRECT */ |
| 305 | if ((fd1 = open(filename, O_DIRECT, 0600)) < 0) { |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 306 | tst_brkm(TCONF, cleanup, |
| 307 | "O_DIRECT is not supported by this filesystem. %s", |
| 308 | strerror(errno)); |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 309 | } |
Subrata Modak | 76a720a | 2010-07-03 21:08:18 +0530 | [diff] [blame] | 310 | close(fd1); |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 311 | } |
| 312 | |
| 313 | static void cleanup(void) |
| 314 | { |
Garrett Cooper | df3eb16 | 2010-11-28 22:44:32 -0800 | [diff] [blame] | 315 | if (fd1 != -1) |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 316 | unlink(filename); |
| 317 | |
| 318 | tst_rmdir(); |
| 319 | |
subrata_modak | 04e0bfa | 2009-06-23 14:11:03 +0000 | [diff] [blame] | 320 | } |
robbiew | 96f4bb3 | 2003-03-13 15:39:53 +0000 | [diff] [blame] | 321 | #else /* O_DIRECT */ |
| 322 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 323 | int main() |
| 324 | { |
robbiew | 96f4bb3 | 2003-03-13 15:39:53 +0000 | [diff] [blame] | 325 | |
Wanlong Gao | 354ebb4 | 2012-12-07 10:10:04 +0800 | [diff] [blame] | 326 | tst_resm(TCONF, "O_DIRECT is not defined."); |
| 327 | return 0; |
robbiew | 96f4bb3 | 2003-03-13 15:39:53 +0000 | [diff] [blame] | 328 | } |
Chris Dearman | ec6edca | 2012-10-17 19:54:01 -0700 | [diff] [blame] | 329 | #endif /* O_DIRECT */ |