| 1 |
/* |
| 2 |
* Copyright 2010 by Garmin Ltd. or its subsidiaries |
| 3 |
* |
| 4 |
* Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 |
* you may not use this file except in compliance with the License. |
| 6 |
* You may obtain a copy of the License at |
| 7 |
* |
| 8 |
* http://www.apache.org/licenses/LICENSE-2.0 |
| 9 |
* |
| 10 |
* Unless required by applicable law or agreed to in writing, software |
| 11 |
* distributed under the License is distributed on an "AS IS" BASIS, |
| 12 |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 |
* See the License for the specific language governing permissions and |
| 14 |
* limitations under the License. |
| 15 |
* |
| 16 |
* Performs a simple write/readback test to verify correct functionality |
| 17 |
* of direct i/o on a block device node. |
| 18 |
*/ |
| 19 |
|
| 20 |
/* For large-file support */ |
| 21 |
#define _FILE_OFFSET_BITS 64 |
| 22 |
#define _LARGEFILE_SOURCE |
| 23 |
#define _LARGEFILE64_SOURCE |
| 24 |
|
| 25 |
/* For O_DIRECT */ |
| 26 |
#define _GNU_SOURCE |
| 27 |
|
| 28 |
#include <ctype.h> |
| 29 |
#include <errno.h> |
| 30 |
#include <fcntl.h> |
| 31 |
#include <inttypes.h> |
| 32 |
#include <limits.h> |
| 33 |
#include <stdint.h> |
| 34 |
#include <stdio.h> |
| 35 |
#include <stdlib.h> |
| 36 |
#include <string.h> |
| 37 |
#include <sys/ioctl.h> |
| 38 |
#include <sys/mman.h> |
| 39 |
#include <sys/stat.h> |
| 40 |
#include <sys/types.h> |
| 41 |
#include <unistd.h> |
| 42 |
|
| 43 |
#include <linux/fs.h> |
| 44 |
|
| 45 |
#define NUM_TEST_BLKS 128 |
| 46 |
|
| 47 |
/* |
| 48 |
* Allocate page-aligned memory. Could use posix_memalign(3), but some |
| 49 |
* systems don't support it. Also pre-faults memory since we'll be using |
| 50 |
* it all right away anyway. |
| 51 |
*/ |
| 52 |
static void *pagealign_alloc(size_t size) |
| 53 |
{ |
| 54 |
void *ret = mmap(NULL, size, PROT_READ | PROT_WRITE, |
| 55 |
MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE | MAP_LOCKED, |
| 56 |
-1, 0); |
| 57 |
if (ret == MAP_FAILED) { |
| 58 |
perror("mmap"); |
| 59 |
ret = NULL; |
| 60 |
} |
| 61 |
return ret; |
| 62 |
} |
| 63 |
|
| 64 |
static void pagealign_free(void *addr, size_t size) |
| 65 |
{ |
| 66 |
int ret = munmap(addr, size); |
| 67 |
if (ret == -1) |
| 68 |
perror("munmap"); |
| 69 |
} |
| 70 |
|
| 71 |
static ssize_t do_read(int fd, void *buf, off64_t start, size_t count) |
| 72 |
{ |
| 73 |
ssize_t ret; |
| 74 |
size_t bytes_read = 0; |
| 75 |
|
| 76 |
lseek64(fd, start, SEEK_SET); |
| 77 |
|
| 78 |
do { |
| 79 |
ret = read(fd, (char *)buf + bytes_read, count - bytes_read); |
| 80 |
if (ret == -1) { |
| 81 |
perror("read"); |
| 82 |
return -1; |
| 83 |
} else if (ret == 0) { |
| 84 |
fprintf(stderr, "Unexpected end-of-file\n"); |
| 85 |
return -1; |
| 86 |
} |
| 87 |
bytes_read += ret; |
| 88 |
} while (bytes_read < count); |
| 89 |
|
| 90 |
return bytes_read; |
| 91 |
} |
| 92 |
|
| 93 |
static ssize_t do_write(int fd, const void *buf, off64_t start, size_t count) |
| 94 |
{ |
| 95 |
ssize_t ret; |
| 96 |
size_t bytes_out = 0; |
| 97 |
|
| 98 |
lseek64(fd, start, SEEK_SET); |
| 99 |
|
| 100 |
do { |
| 101 |
ret = write(fd, (char *)buf + bytes_out, count - bytes_out); |
| 102 |
if (ret == -1) { |
| 103 |
perror("write"); |
| 104 |
return -1; |
| 105 |
} else if (ret == 0) { |
| 106 |
fprintf(stderr, "write returned 0\n"); |
| 107 |
return -1; |
| 108 |
} |
| 109 |
bytes_out += ret; |
| 110 |
} while (bytes_out < count); |
| 111 |
|
| 112 |
return bytes_out; |
| 113 |
} |
| 114 |
|
| 115 |
/* |
| 116 |
* Initializes test buffer with locally-unique test pattern. High 16-bits of |
| 117 |
* each 32-bit word contain first disk block number of the test area, low |
| 118 |
* 16-bits contain word offset into test area. The goal is that a given test |
| 119 |
* area should never contain the same data as a nearby test area, and that the |
| 120 |
* data for a given test area be easily reproducable given the start block and |
| 121 |
* test area size. |
| 122 |
*/ |
| 123 |
static void init_test_buf(void *buf, uint64_t start_blk, size_t len) |
| 124 |
{ |
| 125 |
uint32_t *data = buf; |
| 126 |
size_t i; |
| 127 |
|
| 128 |
len /= sizeof(uint32_t); |
| 129 |
for (i = 0; i < len; i++) |
| 130 |
data[i] = (start_blk & 0xFFFF) << 16 | (i & 0xFFFF); |
| 131 |
} |
| 132 |
|
| 133 |
static void dump_hex(const void *buf, int len) |
| 134 |
{ |
| 135 |
const uint8_t *data = buf; |
| 136 |
int i; |
| 137 |
char ascii_buf[17]; |
| 138 |
|
| 139 |
ascii_buf[16] = '\0'; |
| 140 |
|
| 141 |
for (i = 0; i < len; i++) { |
| 142 |
int val = data[i]; |
| 143 |
int off = i % 16; |
| 144 |
|
| 145 |
if (off == 0) |
| 146 |
printf("%08x ", i); |
| 147 |
printf("%02x ", val); |
| 148 |
ascii_buf[off] = isprint(val) ? val : '.'; |
| 149 |
if (off == 15) |
| 150 |
printf(" %-16s\n", ascii_buf); |
| 151 |
} |
| 152 |
|
| 153 |
i %= 16; |
| 154 |
if (i) { |
| 155 |
ascii_buf[i] = '\0'; |
| 156 |
while (i++ < 16) |
| 157 |
printf(" "); |
| 158 |
printf(" %-16s\n", ascii_buf); |
| 159 |
} |
| 160 |
} |
| 161 |
|
| 162 |
static void update_progress(int current, int total) |
| 163 |
{ |
| 164 |
double pct_done = (double)current * 100 / total; |
| 165 |
printf("Testing area %d/%d (%6.2f%% complete)\r", current, total, |
| 166 |
pct_done); |
| 167 |
fflush(stdout); |
| 168 |
} |
| 169 |
|
| 170 |
int main(int argc, const char *argv[]) |
| 171 |
{ |
| 172 |
int ret = 1; |
| 173 |
const char *path; |
| 174 |
int fd; |
| 175 |
struct stat stat; |
| 176 |
void *read_buf = NULL, *write_buf = NULL; |
| 177 |
int blk_size; |
| 178 |
uint64_t num_blks; |
| 179 |
size_t test_size; |
| 180 |
int test_areas, i; |
| 181 |
|
| 182 |
if (argc != 2) { |
| 183 |
printf("Usage: directiotest blkdev_path\n"); |
| 184 |
exit(1); |
| 185 |
} |
| 186 |
|
| 187 |
path = argv[1]; |
| 188 |
fd = open(path, O_RDWR | O_DIRECT | O_LARGEFILE); |
| 189 |
if (fd == -1) { |
| 190 |
perror("open"); |
| 191 |
exit(1); |
| 192 |
} |
| 193 |
if (fstat(fd, &stat) == -1) { |
| 194 |
perror("stat"); |
| 195 |
goto cleanup; |
| 196 |
} else if (!S_ISBLK(stat.st_mode)) { |
| 197 |
fprintf(stderr, "%s is not a block device\n", path); |
| 198 |
goto cleanup; |
| 199 |
} |
| 200 |
|
| 201 |
if (ioctl(fd, BLKSSZGET, &blk_size) == -1) { |
| 202 |
perror("ioctl"); |
| 203 |
goto cleanup; |
| 204 |
} |
| 205 |
if (ioctl(fd, BLKGETSIZE64, &num_blks) == -1) { |
| 206 |
perror("ioctl"); |
| 207 |
goto cleanup; |
| 208 |
} |
| 209 |
num_blks /= blk_size; |
| 210 |
|
| 211 |
test_size = (size_t)blk_size * NUM_TEST_BLKS; |
| 212 |
read_buf = pagealign_alloc(test_size); |
| 213 |
write_buf = pagealign_alloc(test_size); |
| 214 |
if (!read_buf || !write_buf) { |
| 215 |
fprintf(stderr, "Error allocating test buffers\n"); |
| 216 |
goto cleanup; |
| 217 |
} |
| 218 |
|
| 219 |
/* |
| 220 |
* Start the actual test. Go through the entire device, writing |
| 221 |
* locally-unique patern to each test block and then reading it |
| 222 |
* back. |
| 223 |
*/ |
| 224 |
if (num_blks / NUM_TEST_BLKS > INT_MAX) { |
| 225 |
printf("Warning: Device too large for test variables\n"); |
| 226 |
printf("Entire device will not be tested\n"); |
| 227 |
test_areas = INT_MAX; |
| 228 |
} else { |
| 229 |
test_areas = num_blks / NUM_TEST_BLKS; |
| 230 |
} |
| 231 |
|
| 232 |
printf("Starting test\n"); |
| 233 |
|
| 234 |
for (i = 0; i < test_areas; i++) { |
| 235 |
uint64_t cur_blk = (uint64_t)i * NUM_TEST_BLKS; |
| 236 |
|
| 237 |
update_progress(i + 1, test_areas); |
| 238 |
|
| 239 |
init_test_buf(write_buf, cur_blk, test_size); |
| 240 |
|
| 241 |
if (do_write(fd, write_buf, cur_blk * blk_size, test_size) != |
| 242 |
(ssize_t)test_size) { |
| 243 |
fprintf(stderr, "write failed, aborting test\n"); |
| 244 |
goto cleanup; |
| 245 |
} |
| 246 |
if (do_read(fd, read_buf, cur_blk * blk_size, test_size) != |
| 247 |
(ssize_t)test_size) { |
| 248 |
fprintf(stderr, "read failed, aborting test\n"); |
| 249 |
goto cleanup; |
| 250 |
} |
| 251 |
|
| 252 |
if (memcmp(write_buf, read_buf, test_size)) { |
| 253 |
printf("Readback verification failed at block %" PRIu64 "\n\n", |
| 254 |
cur_blk); |
| 255 |
printf("Written data:\n"); |
| 256 |
dump_hex(write_buf, test_size); |
| 257 |
printf("\nRead data:\n"); |
| 258 |
dump_hex(read_buf, test_size); |
| 259 |
goto cleanup; |
| 260 |
} |
| 261 |
} |
| 262 |
|
| 263 |
printf("\nTest complete\n"); |
| 264 |
ret = 0; |
| 265 |
|
| 266 |
cleanup: |
| 267 |
if (read_buf) |
| 268 |
pagealign_free(read_buf, test_size); |
| 269 |
if (write_buf) |
| 270 |
pagealign_free(write_buf, test_size); |
| 271 |
close(fd); |
| 272 |
return ret; |
| 273 |
} |