tests/directiotest/directiotest.c

   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 }