Whamcloud - gitweb
LU-3365 lmv: support DNE with HSM.
[fs/lustre-release.git] / lustre / utils / llverdev.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.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2011, Intel Corporation.
31  *
32  */
33 /*
34  * This file is part of Lustre, http://www.lustre.org/
35  * Lustre is a trademark of Sun Microsystems, Inc.
36  *
37  * lustre/utils/llverdev.c
38  *
39  * Large Block Device Verification Tool.
40  * This program is used to test whether the block device is correctly
41  * handling IO beyond 2TB boundary.
42  * This tool have two working modes
43  * 1. full mode
44  * 2. partial mode
45  *
46  * In full mode, the program writes a test pattern on the entire disk.
47  * The test pattern (device offset and timestamp) is written at the
48  * beginning of each 4kB block. When the whole device is full the read
49  * operation is performed to verify that the test pattern is correct.
50  *
51  * In partial mode, the program writes data at the critical locations
52  * of the device such as start of the device, before and after multiple of 1GB
53  * offset and at the end.
54  *
55  * A chunk buffer with default size of 1MB is used to write and read test
56  * pattern in bulk.
57  */
58
59 #ifndef _GNU_SOURCE
60 #define _GNU_SOURCE
61 #endif
62 #ifndef LUSTRE_UTILS
63 #define LUSTRE_UTILS
64 #endif
65 #ifndef _LARGEFILE64_SOURCE
66 #define _LARGEFILE64_SOURCE
67 #endif
68 #ifndef _FILE_OFFSET_BITS
69 #define _FILE_OFFSET_BITS 64
70 #endif
71
72 #include <features.h>
73 #include <stdlib.h>
74 #include <stdio.h>
75 #include <string.h>
76 #include <ctype.h>
77 #include <fcntl.h>
78 #include <unistd.h>
79 #include <limits.h>
80 #include <errno.h>
81 #include <fcntl.h>
82 #include <getopt.h>
83 #include <time.h>
84 #include <sys/types.h>
85 #include <sys/stat.h>
86 #include <sys/ioctl.h>
87 #include <sys/mount.h>
88 #include <sys/time.h>
89 #include <gnu/stubs.h>
90
91 #ifdef HAVE_EXT2FS_EXT2FS_H
92 #  include <ext2fs/ext2fs.h>
93 #endif
94
95 #define ONE_MB (1024 * 1024)
96 #define ONE_GB (1024 * 1024 * 1024)
97 #define HALF_MB (ONE_MB / 2)
98 #define ONE_KB 1024
99 #define HALF_KB (ONE_KB / 2)
100 #define BLOCKSIZE 4096
101
102 /* Structure for writting test pattern */
103 struct block_data {
104         unsigned long long bd_offset;
105         unsigned long long bd_time;
106         unsigned long long bd_inode;
107 };
108 static char *progname;          /* name by which this program was run. */
109 static unsigned verbose = 1;    /* prints offset in kB, operation rate */
110 static int readoption;          /* run test in read-only (verify) mode */
111 static int writeoption;         /* run test in write_only mode */
112 const char *devname;            /* name of device to be tested. */
113 static unsigned full = 1;       /* flag to full check */
114 static int error_count;         /* number of IO errors hit during run */
115 static int isatty_flag;
116
117 static struct option const longopts[] =
118 {
119         { "chunksize", required_argument, 0, 'c' },
120         { "force", no_argument, 0, 'f' },
121         { "help", no_argument, 0, 'h' },
122         { "offset", required_argument, 0, 'o' },
123         { "partial", required_argument, 0, 'p' },
124         { "quiet", required_argument, 0, 'q' },
125         { "read", no_argument, 0, 'r' },
126         { "timestamp", required_argument, 0, 't' },
127         { "verbose", no_argument, 0, 'v' },
128         { "write", no_argument, 0, 'w' },
129         { "long", no_argument, 0, 'l' },
130         { "full", no_argument, 0, 'l' },
131         { 0, 0, 0, 0}
132 };
133
134 /*
135  * Usage: displays help information, whenever user supply --help option in
136  * command or enters incorrect command line.
137  */
138 void usage(int status)
139 {
140         if (status != 0) {
141                 printf("\nUsage: %s [OPTION]... <device-name> ...\n",
142                        progname);
143                 printf("Block device verification tool.\n"
144                        "\t-t {seconds}, --timestamp, "
145                        "set test time  (default=current time())\n"
146                        "\t-o {offset}, --offset, "
147                        "offset in kB of start of test, default=0\n"
148                        "\t-r, --read, run in verify mode\n"
149                        "\t-w, --write, run in test-pattern mode, default=rw\n"
150                        "\t-v, --verbose\n"
151                        "\t-q, --quiet\n"
152                        "\t-l, --long, --full check of device\n"
153                        "\t-p, --partial, for partial check (1GB steps)\n"
154                        "\t-c {bytes}, --chunksize, IO size, default=1048576\n"
155                        "\t-f, --force, force test to run without confirmation\n"
156                        "\t-h, --help, display this help and exit\n");
157         }
158         exit(status);
159 }
160
161 /*
162  * Open_dev: Opens device in specified mode and returns fd.
163  */
164 static int open_dev(const char *devname, int mode)
165 {
166         int     fd;
167 #ifdef HAVE_EXT2FS_EXT2FS_H
168         int     mount_flags;
169         char    mountpt[80] = "";
170
171         if (ext2fs_check_mount_point(devname, &mount_flags, mountpt,
172                                      sizeof(mountpt))) {
173                 fprintf(stderr, "%s: ext2fs_check_mount_point failed:%s",
174                         progname, strerror(errno));
175                 exit(1);
176         }
177         if (mount_flags & EXT2_MF_MOUNTED){
178                 fprintf(stderr, "%s: %s is already mounted\n", progname,
179                         devname);
180                 exit(1);
181         }
182 #endif
183         fd = open(devname, mode | O_EXCL | O_LARGEFILE);
184         if (fd < 0) {
185                 fprintf(stderr, "%s: Open failed: %s",progname,strerror(errno));
186                 exit(3);
187         }
188         return fd;
189 }
190
191 #ifdef HAVE_BLKID_BLKID_H
192 #include <blkid/blkid.h>
193 #endif
194 /*
195  * sizeof_dev: Returns size of device in bytes
196  */
197 static loff_t sizeof_dev(int fd)
198 {
199         loff_t numbytes;
200
201 #ifdef HAVE_BLKID_BLKID_H
202         numbytes = blkid_get_dev_size(fd);
203         if (numbytes <= 0) {
204                 fprintf(stderr, "%s: blkid_get_dev_size(%s) failed",
205                         progname, devname);
206                 return 1;
207         }
208         goto out;
209 #else
210 # if defined BLKGETSIZE64       /* in sys/mount.h */
211         if (ioctl(fd, BLKGETSIZE64, &numbytes) >= 0)
212                 goto out;
213 # endif
214 # if defined BLKGETSIZE         /* in sys/mount.h */
215         {
216                 unsigned long sectors;
217
218                 if (ioctl(fd, BLKGETSIZE, &sectors) >= 0) {
219                         numbytes = (loff_t)sectors << 9;
220                         goto out;
221                 }
222         }
223 # endif
224         {
225                 struct stat statbuf;
226
227                 if (fstat(fd, &statbuf) == 0 && S_ISREG(statbuf.st_mode)) {
228                         numbytes = statbuf.st_size;
229                         goto out;
230                 }
231         }
232         fprintf(stderr, "%s: unable to determine size of %s\n",
233                 progname, devname);
234         return 0;
235 #endif
236
237 out:
238         if (verbose)
239                 printf("%s: %s is %llu bytes (%g GB) in size\n",
240                        progname, devname,
241                        (unsigned long long)numbytes, (double)numbytes / ONE_GB);
242
243         return numbytes;
244 }
245
246 /*
247  * Verify_chunk: Verifies test pattern in each 4kB (BLOCKSIZE) is correct.
248  * Returns 0 if test offset and timestamp is correct otherwise 1.
249  */
250 int verify_chunk(char *chunk_buf, const size_t chunksize,
251                  unsigned long long chunk_off, const unsigned long long time_st,
252                  const unsigned long long inode_st, const char *file)
253 {
254         struct block_data *bd;
255         char *chunk_end;
256
257         for (chunk_end = chunk_buf + chunksize - sizeof(*bd);
258              (char *)chunk_buf < chunk_end;
259              chunk_buf += BLOCKSIZE, chunk_off += BLOCKSIZE) {
260                 bd = (struct block_data *)chunk_buf;
261                 if ((bd->bd_offset == chunk_off) && (bd->bd_time == time_st) &&
262                     (bd->bd_inode == inode_st))
263                         continue;
264
265                 fprintf(stderr, "\n%s: verify %s failed offset/timestamp/inode "
266                         "%llu/%llu/%llu: found %llu/%llu/%llu instead\n",
267                         progname, file, chunk_off, time_st, inode_st,
268                         bd->bd_offset, bd->bd_time, bd->bd_inode);
269                 error_count++;
270                 return 1;
271         }
272         return 0;
273 }
274
275 /*
276  * fill_chunk: Fills the chunk with current or user specified timestamp
277  * and offset. The test pattern is filled at the beginning of
278  * each 4kB(BLOCKSIZE) blocks in chunk_buf.
279  */
280 void fill_chunk(char *chunk_buf, size_t chunksize, loff_t chunk_off,
281                 const time_t time_st, const ino_t inode_st)
282 {
283         struct block_data *bd;
284         char *chunk_end;
285
286         for (chunk_end = chunk_buf + chunksize - sizeof(*bd);
287              (char *)chunk_buf < chunk_end;
288              chunk_buf += BLOCKSIZE, chunk_off += BLOCKSIZE) {
289                 bd = (struct block_data *)chunk_buf;
290                 bd->bd_offset = chunk_off;
291                 bd->bd_time = time_st;
292                 bd->bd_inode = inode_st;
293         }
294 }
295
296 void show_rate(char *op, unsigned long long offset, unsigned long long *count)
297 {
298         static time_t last;
299         time_t now;
300         double diff;
301
302         now = time(NULL);
303         diff = now - last;
304
305         if (diff > 4) {
306                 if (last != 0) {
307                         if (isatty_flag)
308                                 printf("\r");
309                         printf("%s offset: %14llukB %5g MB/s            ", op,
310                                offset / ONE_KB, (double)(*count) /ONE_MB /diff);
311                         if (isatty_flag)
312                                 fflush(stdout);
313                         else
314                                 printf("\n");
315
316                         *count = 0;
317                 }
318                 last = now;
319         }
320 }
321
322 /*
323  * Write a chunk to disk, handling errors, interrupted writes, etc.
324  *
325  * If there is an IO error hit during the write, it is possible that
326  * this will just show up as a short write, and a subsequent write
327  * will return the actual error.  We want to continue in the face of
328  * minor media errors so that we can validate the whole device if
329  * possible, but if there are many errors we don't want to loop forever.
330  *
331  * The error count will be returned upon exit to ensure that the
332  * media errors are detected even if nobody is looking at the output.
333  *
334  * Returns 0 on success, or -ve errno on failure.
335  */
336 size_t write_retry(int fd, const char *chunk_buf, size_t nrequested,
337                    unsigned long long offset, const char *file)
338 {
339         long nwritten;
340
341 retry:
342         nwritten = write(fd, chunk_buf, nrequested);
343         if (nwritten < 0) {
344                 if (errno != ENOSPC) {
345                         fprintf(stderr, "\n%s: write %s@%llu+%zi failed: %s\n",
346                                 progname, file, offset, nrequested,
347                                 strerror(errno));
348                         if (error_count++ < 100)
349                                 return 0;
350                 }
351                 return -errno;
352         }
353         if (nwritten < nrequested) {
354                 fprintf(stderr, "\n%s: write %s@%llu+%zi short: %ld written\n",
355                         progname, file, offset, nrequested, nwritten);
356                 offset += nwritten;
357                 chunk_buf += nwritten;
358                 nrequested -= nwritten;
359                 goto retry;
360         }
361
362         return 0;
363 }
364
365 /*
366  * write_chunks: write the chunk_buf on the device. The number of write
367  * operations are based on the parameters write_end, offset, and chunksize.
368  *
369  * Returns 0 on success, or -ve error number on failure.
370  */
371 int write_chunks(int fd, unsigned long long offset,unsigned long long write_end,
372                  char *chunk_buf, size_t chunksize, const time_t time_st,
373                  const ino_t inode_st, const char *file)
374 {
375         unsigned long long stride, count = 0;
376
377         stride = full ? chunksize : (ONE_GB - chunksize);
378         for (offset = offset & ~(chunksize - 1); offset < write_end;
379              offset += stride) {
380                 int ret;
381
382                 if (lseek64(fd, offset, SEEK_SET) == -1) {
383                         fprintf(stderr, "\n%s: lseek64(%s+%llu) failed: %s\n",
384                                 progname, file, offset, strerror(errno));
385                         return -errno;
386                 }
387                 if (offset + chunksize > write_end)
388                         chunksize = write_end - offset;
389                 if (!full && offset > chunksize) {
390                         fill_chunk(chunk_buf, chunksize, offset, time_st,
391                                    inode_st);
392                         ret = write_retry(fd, chunk_buf, chunksize,
393                                           offset, file);
394                         if (ret < 0)
395                                 return ret;
396                         offset += chunksize;
397                         count += chunksize;
398                         if (offset + chunksize > write_end)
399                                 chunksize = write_end - offset;
400                 }
401                 fill_chunk(chunk_buf, chunksize, offset, time_st, inode_st);
402                 ret = write_retry(fd, chunk_buf, chunksize, offset, file);
403                 if (ret < 0)
404                         return ret;
405
406                 count += chunksize;
407                 if (verbose > 1)
408                         show_rate("write", offset, &count);
409         }
410
411         if (verbose > 1) {
412                 show_rate("write", offset, &count);
413                 printf("\nwrite complete\n");
414         }
415         if (fsync(fd) == -1) {
416                 fprintf(stderr, "%s: fsync failed: %s\n", progname,
417                         strerror(errno));
418                 return -errno;
419         }
420         return 0;
421 }
422
423 /*
424  * read_chunk: reads the chunk_buf from the device. The number of read
425  * operations are based on the parameters read_end, offset, and chunksize.
426  */
427 int read_chunks(int fd, unsigned long long offset, unsigned long long read_end,
428                 char *chunk_buf, size_t chunksize, const time_t time_st,
429                 const ino_t inode_st, const char *file)
430 {
431         unsigned long long stride, count = 0;
432
433         if (ioctl(fd, BLKFLSBUF, 0) < 0 && verbose)
434                 fprintf(stderr, "%s: ioctl BLKFLSBUF failed: %s (ignoring)\n",
435                         progname, strerror(errno));
436
437         stride = full ? chunksize : (ONE_GB - chunksize);
438         for (offset = offset & ~(chunksize - 1); offset < read_end;
439              offset += stride) {
440                 ssize_t nread;
441
442                 if (lseek64(fd, offset, SEEK_SET) == -1) {
443                         fprintf(stderr, "\n%s: lseek64(%llu) failed: %s\n",
444                                 progname, offset, strerror(errno));
445                         return 1;
446                 }
447                 if (offset + chunksize > read_end)
448                         chunksize = read_end - offset;
449
450                 if (!full && offset > chunksize) {
451                         nread = read(fd, chunk_buf, chunksize);
452                         if (nread < 0) {
453                                 fprintf(stderr,"\n%s: read %s@%llu+%zi failed: "
454                                         "%s\n", progname, file, offset,
455                                         chunksize, strerror(errno));
456                                 error_count++;
457                                 return 1;
458                         }
459                         if (nread < chunksize) {
460                                 fprintf(stderr, "\n%s: read %s@%llu+%zi short: "
461                                         "%zi read\n", progname, file, offset,
462                                         chunksize, nread);
463                                 error_count++;
464                         }
465                         if (verify_chunk(chunk_buf, nread, offset, time_st,
466                                          inode_st, file) != 0)
467                                 return 1;
468                         offset += chunksize;
469                         count += chunksize;
470
471                         /* Need to reset position after read error */
472                         if (nread < chunksize &&
473                             lseek64(fd, offset, SEEK_SET) == -1) {
474                                 fprintf(stderr,
475                                         "\n%s: lseek64(%s@%llu) failed: %s\n",
476                                         progname, file, offset,strerror(errno));
477                                 return 1;
478                         }
479                         if (offset + chunksize >= read_end)
480                                 chunksize = read_end - offset;
481                 }
482
483                 nread = read(fd, chunk_buf, chunksize);
484                 if (nread < 0) {
485                         fprintf(stderr, "\n%s: read failed: %s\n", progname,
486                                 strerror(errno));
487                         error_count++;
488                         return 1;
489                 }
490                 if (nread < chunksize) {
491                         fprintf(stderr, "\n%s: read %s@%llu+%zi short: "
492                                 "%zi read\n", progname, file, offset,
493                                 chunksize, nread);
494                         error_count++;
495                 }
496
497                 if (verify_chunk(chunk_buf, nread, offset, time_st,
498                                  inode_st, file) != 0)
499                         return 1;
500
501                 count += chunksize;
502                 if (verbose > 1)
503                         show_rate("read", offset, &count);
504         }
505         if (verbose > 1) {
506                 show_rate("read", offset, &count);
507                 printf("\nread complete\n");
508         }
509         return 0;
510 }
511
512 int main(int argc, char **argv)
513 {
514         time_t time_st = 0;             /* Default timestamp */
515         long long offset = 0, offset_orig; /* offset in kB */
516         size_t chunksize = ONE_MB;      /* IO chunk size */
517         char *chunk_buf = NULL;
518         unsigned int force = 0;         /* run test run without confirmation*/
519         unsigned long long dev_size = 0;
520         char yesno[4];
521         int mode = O_RDWR;              /* mode which device should be opened */
522         int fd;
523         int error = 0, c;
524
525         progname = strrchr(argv[0], '/') == NULL ?
526                 argv[0] : strrchr(argv[0], '/') + 1;
527         while ((c = getopt_long(argc, argv, "c:fhlo:pqrt:vw", longopts,
528                                 NULL)) != -1) {
529                 switch (c) {
530                 case 'c':
531                         chunksize = (strtoul(optarg, NULL, 0) * ONE_MB);
532                         if (!chunksize) {
533                                 fprintf(stderr, "%s: chunk size value should be"
534                                         "nonzero and multiple of 1MB\n",
535                                         progname);
536                                 return -1;
537                         }
538                         break;
539                 case 'f':
540                         force = 1;
541                         break;
542                 case 'l':
543                         full = 1;
544                         break;
545                 case 'o':
546                         offset = strtoull(optarg, NULL, 0) * ONE_KB;
547                         break;
548                 case 'p':
549                         full = 0;
550                         break;
551                 case 'q':
552                         verbose = 0;
553                         break;
554                 case 'r':
555                         readoption = 1;
556                         mode = O_RDONLY;
557                         break;
558                 case 't':
559                         time_st = (time_t)strtoul(optarg, NULL, 0);
560                         break;
561                 case 'v':
562                         verbose++;
563                         break;
564                 case 'w':
565                         writeoption = 1;
566                         mode = O_WRONLY;
567                         break;
568                 case 'h':
569                 default:
570                         usage (1);
571                         return 0;
572                 }
573         }
574         offset_orig = offset;
575         devname = argv[optind];
576         if (!devname) {
577                 fprintf(stderr, "%s: device name not given\n", progname);
578                 usage (1);
579                 return -1;
580         }
581
582         if (readoption && writeoption)
583                 mode = O_RDWR;
584         if (!readoption && !writeoption) {
585                 readoption = 1;
586                 writeoption = 1;
587         }
588
589         if (!force && writeoption) {
590                 printf("%s: permanently overwrite all data on %s (yes/no)? ",
591                        progname, devname);
592                 if (scanf("%3s", yesno) == EOF && ferror(stdin)) {
593                         perror("reading from stdin");
594                         return -1;
595                 }
596                 if (!(strcasecmp("yes", yesno) || strcasecmp("y", yesno))) {
597                         printf("Not continuing due to '%s' response", yesno);
598                         return 0;
599                 }
600         }
601
602         if (!writeoption && time_st == 0) {
603                 fprintf(stderr, "%s: must give timestamp for read-only test\n",
604                         progname);
605                 usage(1);
606         }
607
608         fd = open_dev(devname, mode);
609         dev_size = sizeof_dev(fd);
610         if (!dev_size) {
611                 fprintf(stderr, "%s: cannot test on device size < 1MB\n",
612                         progname);
613                 error = 7;
614                 goto close_dev;
615         }
616
617         if (dev_size < (offset * 2)) {
618                 fprintf(stderr, "%s: device size %llu < offset %llu\n",
619                         progname, dev_size, offset);
620                 error = 6;
621                 goto close_dev;
622         }
623         if (!time_st)
624                 (void)time(&time_st);
625
626         isatty_flag = isatty(STDOUT_FILENO);
627
628         if (verbose)
629                 printf("Timestamp: %lu\n", time_st);
630
631         chunk_buf = (char *)calloc(chunksize, 1);
632         if (chunk_buf == NULL) {
633                 fprintf(stderr, "%s: memory allocation failed for chunk_buf\n",
634                         progname);
635                 error = 4;
636                 goto close_dev;
637         }
638         if (writeoption) {
639                 c = write_chunks(fd, offset, dev_size, chunk_buf, chunksize,
640                                  time_st, 0, devname);
641                 if (c < 0 && c != -ENOSPC) {
642                         error = 3;
643                         goto chunk_buf;
644                 }
645                 if (!full) { /* end of device aligned to a block */
646                         offset = ((dev_size - chunksize + BLOCKSIZE - 1) &
647                                   ~(BLOCKSIZE - 1));
648                         c = write_chunks(fd, offset, dev_size, chunk_buf,
649                                          chunksize, time_st, 0, devname);
650                         if (c < 0 && c != -ENOSPC) {
651                                 error = 3;
652                                 goto chunk_buf;
653                         }
654                 }
655                 offset = offset_orig;
656         }
657         if (readoption) {
658                 if (read_chunks(fd, offset, dev_size, chunk_buf, chunksize,
659                                 time_st, 0, devname)) {
660                         error = 2;
661                         goto chunk_buf;
662                 }
663                 if (!full) { /* end of device aligned to a block */
664                         offset = ((dev_size - chunksize + BLOCKSIZE - 1) &
665                                   ~(BLOCKSIZE - 1));
666                         if (read_chunks(fd, offset, dev_size, chunk_buf,
667                                         chunksize, time_st, 0, devname)) {
668                                 error = 2;
669                                 goto chunk_buf;
670                         }
671                 }
672                 if (verbose)
673                         printf("\n%s: data verified successfully\n", progname);
674         }
675         error = error_count;
676 chunk_buf:
677         free(chunk_buf);
678 close_dev:
679         close(fd);
680         return error;
681 }