Whamcloud - gitweb
LU-10657 utils: fd leak in mirror_split()
[fs/lustre-release.git] / lustre / tests / test_brw.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2014, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  * Lustre is a trademark of Sun Microsystems, Inc.
31  */
32
33 /* for O_DIRECT */
34 #ifndef _GNU_SOURCE
35 #define _GNU_SOURCE
36 #endif
37
38 #include <inttypes.h>
39 #include <stdio.h>
40 #include <string.h>
41 #include <unistd.h>
42 #include <fcntl.h>
43 #include <stdlib.h>
44 #include <errno.h>
45 #include <sys/mman.h>
46 #include <sys/types.h>
47 #include <sys/stat.h>
48 #include <linux/types.h>
49
50 #define READ  1
51 #define WRITE 2
52
53 #define LPDS sizeof(uint64_t)
54 int block_debug_setup(void *addr, int len, uint64_t off, uint64_t id)
55 {
56         off = htole64(off);
57         id = htole64(id);
58         memcpy(addr, (char *)&off, LPDS);
59         memcpy(addr + LPDS, (char *)&id, LPDS);
60
61         addr += len - LPDS - LPDS;
62         memcpy(addr, (char *)&off, LPDS);
63         memcpy(addr + LPDS, (char *)&id, LPDS);
64
65         return 0;
66 }
67
68 int block_debug_check(char *who, void *addr, int size, uint64_t off, uint64_t id)
69 {
70         uint64_t ne_off;
71         int err = 0;
72
73         ne_off = le64toh(off);
74         id = le64toh(id);
75         if (memcmp(addr, (char *)&ne_off, LPDS)) {
76                 fprintf(stderr, "%s: for offset %"PRIu64" off: %"PRIx64" != %"PRIx64"\n",
77                         who, off, *(uint64_t *)addr, ne_off);
78                 err = -EINVAL;
79         }
80         if (memcmp(addr + LPDS, (char *)&id, LPDS)) {
81                 fprintf(stderr, "%s: for offset %"PRIu64" id: %"PRIx64" != %"PRIx64"\n",
82                         who, off, *(uint64_t *)(addr + LPDS), id);
83                 err = -EINVAL;
84         }
85
86         addr += size - LPDS - LPDS;
87         if (memcmp(addr, (char *)&ne_off, LPDS)) {
88                 fprintf(stderr, "%s: for offset %"PRIu64" end off: %"PRIx64" != %"PRIx64"\n",
89                         who, off, *(uint64_t *)addr, ne_off);
90                 err = -EINVAL;
91         }
92         if (memcmp(addr + LPDS, (char *)&id, LPDS)) {
93                 fprintf(stderr, "%s: for offset %"PRIu64" end id: %"PRIx64" != %"PRIx64"\n",
94                         who, off, *(uint64_t *)(addr + LPDS), id);
95                 err = -EINVAL;
96         }
97
98         return err;
99 }
100 #undef LPDS
101
102 void usage(char *prog)
103 {
104         fprintf(stderr,
105                 "usage: %s file count [[d]{r|w|rw} [pages_per_vec [objid]]]\n",
106                 prog);
107         exit(1);
108 }
109
110 int main(int argc, char **argv)
111 {
112         int fd;
113         char *buf;
114         long long count, last;
115         long pg_vec, len;
116         uint64_t objid, offset;
117         struct stat st;
118         int flags = 0;
119         int cmd = 0;
120         char *end;
121         int rc;
122
123         if (argc < 3 || argc > 6)
124                 usage(argv[0]);
125
126         count = strtoull(argv[2], &end, 0);
127         if (*end) {
128                 fprintf(stderr, "%s: invalid count '%s'\n", argv[0], argv[2]);
129                 usage(argv[0]);
130         }
131         if (argc >= 4) {
132                 if (strchr(argv[3], 'r')) {
133                         cmd = READ;
134                         flags = O_RDONLY;
135                 }
136                 if (strchr(argv[3], 'w')) {
137                         cmd |= WRITE;
138                         flags = O_RDWR | O_CREAT;
139                 }
140                 if (strchr(argv[3], 'd')) {
141 #ifdef O_DIRECT
142                         flags |= O_DIRECT;
143 #else
144                         fprintf(stderr,
145                                 "%s: O_DIRECT not supported in this build\n",
146                                 argv[0]);
147                         exit(1);
148 #endif
149                 }
150                 if (!cmd)
151                         usage(argv[0]);
152         } else {
153                 cmd = READ | WRITE;
154                 flags = O_RDWR | O_CREAT;
155 #ifdef O_DIRECT
156                 flags |= O_DIRECT;
157 #else
158                 fprintf(stderr, "%s: warning: not setting O_DIRECT\n",
159                         argv[0]);
160 #endif
161         }
162
163         if (argc >= 5) {
164                 pg_vec = strtoul(argv[4], &end, 0);
165                 if (*end) {
166                         fprintf(stderr, "%s: invalid pages_per_vec '%s'\n",
167                                 argv[0], argv[4]);
168                         usage(argv[0]);
169                 }
170         } else {
171                 pg_vec = 16;
172         }
173
174         if (argc >= 6) {
175                 objid = strtoull(argv[5], &end, 0);
176                 if (*end) {
177                         fprintf(stderr, "%s: invalid objid '%s'\n",
178                                 argv[0], argv[5]);
179                         usage(argv[0]);
180                 }
181         } else {
182                 objid = 3;
183         }
184
185         printf("%s: %s on %s(objid %"PRIx64") for %llux%ld pages \n",
186                argv[0],
187 #ifdef O_DIRECT
188                flags & O_DIRECT ? "directio" : "i/o",
189 #else
190                "i/o",
191 #endif
192                argv[1], objid, count, pg_vec);
193
194         fd = open(argv[1], flags | O_LARGEFILE);
195         if (fd == -1) {
196                 fprintf(stderr, "%s: cannot open %s:  %s\n", argv[0],
197                         argv[1], strerror(errno));
198                 return 3;
199         }
200
201         rc = fstat(fd, &st);
202         if (rc < 0) {
203                 fprintf(stderr, "%s: cannot stat %s: %s\n", argv[0],
204                         argv[1], strerror(errno));
205                 return 4;
206         }
207
208         len = pg_vec * st.st_blksize;
209         last = (long long)count * len;
210
211         buf = mmap(0, len, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, 0, 0);
212         if (buf == MAP_FAILED) {
213                 fprintf(stderr, "%s: no buffer memory %s\n",
214                         argv[0], strerror(errno));
215                 return 2;
216         }
217
218         for (offset = 0; offset < last && cmd & WRITE; offset += len) {
219                 unsigned int i;
220
221                 for (i = 0; i < len; i += st.st_blksize)
222                         block_debug_setup(buf + i, st.st_blksize,
223                                           offset + i, objid);
224
225                 rc = write(fd, buf, len);
226
227                 for (i = 0; i < len; i += st.st_blksize) {
228                         if (block_debug_check("write", buf + i, st.st_blksize,
229                                               offset + i, objid))
230                                 return 10;
231                 }
232
233                 if (rc != len) {
234                         fprintf(stderr, "%s: write error: %s, rc %d != %ld\n",
235                                 argv[0], strerror(errno), rc, len);
236                         return 4;
237                 }
238         }
239
240         if (lseek(fd, 0, SEEK_SET) != 0) {
241                 fprintf(stderr, "%s: cannot seek %s\n",
242                         argv[0], strerror(errno));
243                 return 5;
244         }
245
246         for (offset = 0; offset < last && cmd & READ; offset += len) {
247                 int i;
248
249                 rc = read(fd, buf, len);
250                 if (rc != len) {
251                         fprintf(stderr, "%s: read error: %s, rc %d != %ld\n",
252                                 argv[0], strerror(errno), rc, len);
253                         return 6;
254                 }
255
256                 for (i = 0; i < len; i += st.st_blksize) {
257                         if (block_debug_check("read", buf + i, st.st_blksize,
258                                               offset + i, objid))
259                                 return 11;
260                 }
261         }
262
263         return 0;
264 }