2 * Copyright (c) 2000 Silicon Graphics, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 * iogen - a tool for generating file/sds io for a doio process
24 #ifdef HAVE_SYS_SYSSGI_H
25 #include <sys/syssgi.h>
28 #ifdef HAVE_SYS_UUID_H
32 #ifdef HAVE_SYS_FS_XFS_FSOPS_H
33 #include <sys/fs/xfs_fsops.h>
36 #ifdef HAVE_SYS_FS_XFS_ITABLE_H
37 #include <sys/fs/xfs_itable.h>
42 #include "str_to_bytes.h"
43 #include "string_to_tokens.h"
44 #include "open_flags.h"
45 #include "random_range.h"
51 #define RAW_IO(_flags_) ((_flags_) & (O_RAW | O_SSD))
53 #define SYSERR strerror(errno)
56 * Structure for retaining test file information
60 char f_path[MAX_FNAME_LENGTH+1]; /* file name (full path) */
61 int f_length; /* length in bytes */
62 int f_iou; /* file iounit */
63 int f_riou; /* file raw iounit (for O_RAW/O_SSD) */
64 int f_dalign; /* direct I/O alignment */
65 int f_nextoff; /* offset of end of last io operation */
66 int f_type; /* file type S_IFREG, etc... */
67 int f_lastoffset; /* offset of last io operation */
68 int f_lastlength; /* length of last io operation */
72 * Simple structure for associating strings with values - useful for converting
73 * cmdline args to internal values, as well as printing internal values in
74 * a human readable form.
84 * Declare cmdline option flags/variables initialized in parse_cmdline()
87 #define OPTS "a:dhf:i:L:m:op:qr:s:t:T:O:N:"
89 int a_opt = 0; /* async io comp. types supplied */
90 int o_opt = 0; /* form overlapping requests */
91 int f_opt = 0; /* test flags */
92 int i_opt = 0; /* iterations - 0 implies infinite */
93 int L_opt = 0; /* listio min-max nstrides & nents */
94 int m_opt = 0; /* offset mode */
95 int O_opt = 0; /* file creation Open flags */
96 int p_opt = 0; /* output pipe - default is stdout */
97 int r_opt = 0; /* specify raw io multiple instead of */
98 /* getting it from the mounted on device. */
99 /* Only applies to regular files. */
100 int s_opt = 0; /* syscalls */
101 int t_opt = 0; /* min transfer size (bytes) */
102 int T_opt = 0; /* max transfer size (bytes) */
103 int q_opt = 0; /* quiet operation on startup */
104 char TagName[40]; /* name of this iogen (see Monster) */
105 struct strmap *Offset_Mode; /* M_SEQUENTIAL, M_RANDOM, etc. */
106 int Iterations; /* # requests to generate (0 --> infinite) */
107 int Time_Mode = 0; /* non-zero if Iterations is in seconds */
108 /* (ie. -i arg was suffixed with 's') */
109 char *Outpipe; /* Pipe to write output to if p_opt */
110 int Mintrans; /* min io transfer size */
111 int Maxtrans; /* max io transfer size */
112 int Rawmult; /* raw/ssd io multiple (from -r) */
113 int Minstrides; /* min # of listio strides per request */
114 int Maxstrides; /* max # of listio strides per request */
115 int Oflags; /* open(2) flags for creating files */
116 int Ocbits; /* open(2) cbits for creating files */
117 int Ocblks; /* open(2) cblks for creating files */
118 int Orealtime=0; /* flag set for -O REALTIME */
119 int Oextsize=0; /* real-time extent size */
120 int Oreserve=1; /* flag for -O [no]reserve */
121 int Oallocate=0; /* flag for -O allocate */
122 int Owrite=1; /* flag for -O nowrite */
124 int Nfiles = 0; /* # files on cmdline */
125 struct file_info *File_List; /* info about each file */
126 int Nflags = 0; /* # flags on cmdline */
127 struct strmap *Flag_List[128]; /* flags selected from cmdline */
128 int Nsyscalls = 0; /* # syscalls on cmdline */
129 struct strmap *Syscall_List[128]; /* syscalls selected on cmdline */
130 int Fileio = 0; /* flag indicating that a file */
131 /* io syscall has been chosen. */
132 int Naio_Strat_Types = 0; /* # async io completion types */
133 struct strmap *Aio_Strat_List[128]; /* Async io completion types */
135 void startup_info(FILE *stream, int seed);
138 * Map async io completion modes (-a args) names to values. Macros are
142 struct strmap Aio_Strat_Map[] = {
145 { "signal", A_SIGNAL },
153 * Offset_Mode #defines
157 #define M_SEQUENTIAL 2
161 * Map offset mode (-m args) names to values
164 struct strmap Omode_Map[] = {
165 { "random", M_RANDOM },
166 { "sequential", M_SEQUENTIAL },
167 { "reverse", M_REVERSE },
172 * Map syscall names (-s args) to values - macros are defined in doio.h.
174 #define SY_ASYNC 00001
175 #define SY_WRITE 00002
177 #define SY_LISTIO 00020
178 #define SY_NENT 00100 /* multi entry vs multi stride >>> */
180 struct strmap Syscall_Map[] = {
182 { "write", WRITE, SY_WRITE },
184 { "pwrite", PWRITE, SY_WRITE },
185 { "resvsp", RESVSP, SY_WRITE },
186 { "unresvsp", UNRESVSP, SY_WRITE },
187 { "reserve", RESVSP, SY_WRITE },
188 { "unreserve", UNRESVSP, SY_WRITE },
190 { "writev", WRITEV, SY_WRITE },
192 { "mmwrite", MMAPW, SY_WRITE },
193 { "fsync2", FSYNC2, SY_WRITE },
194 { "fdatasync", FDATASYNC, SY_WRITE },
199 * Map open flags (-f args) to values
201 #define FLG_RAW 00001
203 struct strmap Flag_Map[] = {
204 { "buffered", 0, 0 },
205 { "sync", O_SYNC, 0 },
206 { "direct", O_DIRECT, FLG_RAW },
211 * Map file types to strings
214 struct strmap Ftype_Map[] = {
215 { "regular", S_IFREG },
216 { "blk-spec", S_IFBLK },
217 { "chr-spec", S_IFCHR },
227 char Byte_Patterns[26] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
228 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
229 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
233 int form_iorequest(struct io_req *);
235 int parse_cmdline(int argc, char **argv, char *opts);
236 int help(FILE *stream);
237 int usage(FILE *stream);
245 int rseed, outfd, infinite;
252 parse_cmdline(argc, argv, OPTS);
255 * Initialize output descriptor.
260 outfd = init_output();
264 random_range_seed(rseed); /* initialize random number generator */
267 * Print out startup information, unless we're running in quiet mode
270 startup_info(stderr, rseed);
272 start_time = time(0);
275 * While iterations (or forever if Iterations == 0) - compute an
276 * io request, and write the structure to the output descriptor
279 infinite = !Iterations;
282 (! Time_Mode && Iterations--) ||
283 (Time_Mode && time(0) - start_time <= Iterations)) {
285 memset(&req, 0, sizeof(struct io_req));
286 if (form_iorequest(&req) == -1) {
287 fprintf(stderr, "iogen%s: form_iorequest() failed\n", TagName);
291 req.r_magic = DOIO_MAGIC;
292 write(outfd, (char *)&req, sizeof(req));
300 startup_info(FILE *stream, int seed)
302 char *value_to_string(struct strmap *map, int val), *type;
305 fprintf(stream, "\n");
306 fprintf(stream, "iogen%s starting up with the following:\n", TagName);
307 fprintf(stream, "\n");
309 fprintf(stream, "Out-pipe: %s\n",
310 p_opt ? Outpipe : "stdout");
313 fprintf(stream, "Iterations: %d", Iterations);
315 fprintf(stream, " seconds");
317 fprintf(stream, "\n");
319 fprintf(stream, "Iterations: Infinite\n");
326 "Offset-Mode: %s\n", Offset_Mode->m_string);
328 fprintf(stream, "Overlap Flag: %s\n",
329 o_opt ? "on" : "off");
332 "Mintrans: %-11d (%d blocks)\n",
333 Mintrans, (Mintrans+BSIZE-1)/BSIZE);
336 "Maxtrans: %-11d (%d blocks)\n",
337 Maxtrans, (Maxtrans+BSIZE-1)/BSIZE);
341 "O_RAW/O_SSD Multiple: (Determined by device)\n");
344 "O_RAW/O_SSD Multiple: %-11d (%d blocks)\n",
345 Rawmult, (Rawmult+BSIZE-1)/BSIZE);
347 fprintf(stream, "Syscalls: ");
348 for (i = 0; i < Nsyscalls; i++)
350 "%s ", Syscall_List[i]->m_string);
351 fprintf(stream, "\n");
353 fprintf(stream, "Aio completion types: ");
354 for (i = 0; i < Naio_Strat_Types; i++)
356 "%s ", Aio_Strat_List[i]->m_string);
357 fprintf(stream, "\n");
360 fprintf(stream, "Flags: ");
361 for (i = 0; i < Nflags; i++)
363 "%s ", Flag_List[i]->m_string);
365 fprintf(stream, "\n");
366 fprintf(stream, "\n");
367 fprintf(stream, "Test Files: \n");
368 fprintf(stream, "\n");
370 "Path Length iou raw iou file\n");
372 " (bytes) (bytes) (bytes) type\n");
374 "-----------------------------------------------------------------------------\n");
376 for (i = 0; i < Nfiles; i++) {
377 type = value_to_string(Ftype_Map, File_List[i].f_type);
378 fprintf(stream, "%-40s %12d %7d %7d %s\n",
379 File_List[i].f_path, File_List[i].f_length,
380 File_List[i].f_iou, File_List[i].f_riou, type);
386 * Initialize output descriptor. If going to stdout, its easy,
387 * otherwise, attempt to create a FIFO on path Outpipe. Exit with an
388 * error code if this cannot be done.
396 if (stat(Outpipe, &sbuf) == -1) {
397 if (errno == ENOENT) {
398 if (mkfifo(Outpipe, 0666) == -1) {
399 fprintf(stderr, "iogen%s: Could not mkfifo %s: %s\n",
400 TagName, Outpipe, SYSERR);
404 fprintf(stderr, "iogen%s: Could not stat outpipe %s: %s\n",
405 TagName, Outpipe, SYSERR);
409 if (! S_ISFIFO(sbuf.st_mode)) {
411 "iogen%s: Output file %s exists, but is not a FIFO\n",
417 if ((outfd = open(Outpipe, O_RDWR)) == -1) {
419 "iogen%s: Couldn't open outpipe %s with flags O_RDWR: %s\n",
420 TagName, Outpipe, SYSERR);
429 * Main io generation function. form_iorequest() selects a system call to
430 * do based on cmdline arguments, and proceeds to select parameters for that
433 * Returns 0 if req is filled in with a complete doio request, otherwise
441 int mult, offset = 0, length = 0, slength;
442 int minlength, maxlength, laststart, lastend;
443 int minoffset, maxoffset;
444 int maxstride, nstrides;
446 struct strmap *flags, *sc, *aio_strat;
447 struct file_info *fptr;
450 * Choose system call, flags, and file
453 sc = Syscall_List[random_range(0, Nsyscalls-1, 1, NULL)];
454 req->r_type = sc->m_value;
456 if( sc->m_flags & SY_WRITE )
457 pattern = Byte_Patterns[random_range(0, sizeof(Byte_Patterns) - 1, 1, NULL)];
462 * otherwise, we're doing file io. Choose starting offset, length,
463 * open flags, and possibly a pattern (for write/writea).
466 fptr = &File_List[random_range(0, Nfiles-1, 1, NULL)];
467 flags = Flag_List[random_range(0, Nflags-1, 1, NULL)];
470 * Choose offset/length multiple. IO going to a device, or regular
471 * IO that is O_RAW or O_SSD must be aligned on the file r_iou. Otherwise
472 * it must be aligned on the regular iou (normally 1).
475 if ( fptr->f_type == S_IFREG && (flags->m_flags & FLG_RAW) )
481 * Choose offset and length. Both must be a multiple of mult
485 * Choose length first - it must be a multiple of mult
488 laststart = fptr->f_lastoffset;
489 lastend = fptr->f_lastoffset + fptr->f_lastlength - 1;
491 minlength = (Mintrans > mult) ? Mintrans : mult;
493 switch (Offset_Mode->m_value) {
495 if (o_opt && lastend > laststart)
496 offset = random_range(laststart, lastend, 1, NULL);
498 offset = lastend + 1;
499 if (offset && (offset%mult))
500 offset += mult - (offset % mult);
502 if (minlength > fptr->f_length - offset)
505 maxlength = fptr->f_length - offset;
506 if (maxlength > Maxtrans)
507 maxlength = Maxtrans;
509 length = random_range(minlength, maxlength, mult, &errp);
511 fprintf(stderr, "iogen%s: random_range(%d, %d, %d) failed\n",
512 TagName, minlength, maxlength, mult);
519 maxlength = laststart;
521 if (maxlength > Maxtrans)
522 maxlength = Maxtrans;
524 if (minlength > maxlength) {
525 laststart = fptr->f_length;
526 lastend = fptr->f_length;
527 maxlength = Maxtrans;
530 length = random_range(minlength, maxlength, mult, &errp);
532 fprintf(stderr, "iogen%s: random_range(%d, %d, %d) failed\n",
533 TagName, minlength, maxlength, mult);
537 offset = laststart - length;
539 if (o_opt && lastend > laststart)
540 offset += random_range(1, lastend - laststart, 1, NULL);
542 if (offset && (offset%mult))
543 offset -= offset % mult;
548 length = random_range(Mintrans, Maxtrans, mult, NULL);
550 if (o_opt && lastend > laststart) {
551 minoffset = laststart - length + 1;
556 if (lastend + length > fptr->f_length) {
557 maxoffset = fptr->f_length - length;
563 maxoffset = fptr->f_length - length;
569 offset = random_range(minoffset, maxoffset, mult, &errp);
571 fprintf(stderr, "iogen%s: random_range(%d, %d, %d) failed\n",
572 TagName, minoffset, maxoffset, mult);
577 fptr->f_lastoffset = offset;
578 fptr->f_lastlength = length;
581 * Choose an async io completion strategy if necessary
583 if( sc->m_flags & SY_ASYNC )
584 aio_strat = Aio_Strat_List[random_range(0, Naio_Strat_Types - 1,
590 * fill in specific syscall record data
592 switch (sc->m_value) {
595 strcpy(req->r_data.read.r_file, fptr->f_path);
596 req->r_data.read.r_oflags = O_RDONLY | flags->m_value;
597 req->r_data.read.r_offset = offset;
598 req->r_data.read.r_nbytes = length;
599 req->r_data.read.r_uflags = (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
600 req->r_data.read.r_aio_strat = (aio_strat==NULL) ? 0 : aio_strat->m_value;
601 req->r_data.read.r_nstrides = 1;
602 req->r_data.read.r_nent = 1;
607 strcpy(req->r_data.write.r_file, fptr->f_path);
608 req->r_data.write.r_oflags = O_WRONLY | flags->m_value;
609 req->r_data.write.r_offset = offset;
610 req->r_data.write.r_nbytes = length;
611 req->r_data.write.r_pattern = pattern;
612 req->r_data.write.r_uflags = (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
613 req->r_data.write.r_aio_strat = (aio_strat==NULL) ? 0 : aio_strat->m_value;
614 req->r_data.write.r_nstrides = 1;
615 req->r_data.write.r_nent = 1;
635 strcpy(req->r_data.io.r_file, fptr->f_path);
636 req->r_data.io.r_oflags = ((sc->m_flags & SY_WRITE) ? O_WRONLY : O_RDONLY) | flags->m_value;
637 req->r_data.io.r_offset = offset;
638 req->r_data.io.r_nbytes = length;
639 req->r_data.io.r_pattern = pattern;
640 req->r_data.io.r_uflags = (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
641 req->r_data.io.r_aio_strat = (aio_strat==NULL) ? 0 : aio_strat->m_value;
642 req->r_data.io.r_nstrides = 1;
643 req->r_data.io.r_nent = 1;
648 strcpy(req->r_data.io.r_file, fptr->f_path);
649 /* a subtle "feature" of mmap: a write-map requires
650 the file open read/write */
651 req->r_data.io.r_oflags = ((sc->m_flags & SY_WRITE) ? O_RDWR : O_RDONLY) | flags->m_value;
652 req->r_data.io.r_offset = offset;
653 req->r_data.io.r_nbytes = length;
654 req->r_data.io.r_pattern = pattern;
655 req->r_data.io.r_uflags = (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
656 req->r_data.io.r_aio_strat = (aio_strat==NULL) ? 0 : aio_strat->m_value;
657 req->r_data.io.r_nstrides = 1;
658 req->r_data.io.r_nent = 1;
670 strcpy(req->r_data.io.r_file, fptr->f_path);
671 req->r_data.io.r_oflags = ((sc->m_flags & SY_WRITE) ? O_WRONLY : O_RDONLY) | flags->m_value;
672 req->r_data.io.r_offset = offset;
673 req->r_data.io.r_uflags = (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
674 req->r_data.io.r_aio_strat = (aio_strat==NULL) ? 0 : aio_strat->m_value;
675 req->r_data.io.r_pattern = pattern;
677 /* multi-strided request...
678 * random number of strides (1...MaxStrides)
679 * length of stride must be > minlength
680 * length of stride must be % mult
682 * maxstrides = min(length / mult, overall.max#strides)
683 * nstrides = random #
684 * while( length / nstrides < minlength )
685 * nstrides = new random #
687 maxstride = length / mult;
688 if(maxstride > Maxstrides)
689 maxstride = Maxstrides;
693 nstrides = random_range(Minstrides, maxstride, 1, &errp);
695 fprintf(stderr, "iogen%s: random_range(%d, %d, %d) failed\n",
696 TagName, Minstrides, maxstride, 1);
700 slength = length / nstrides;
701 if(slength % mult != 0) {
702 if( mult > slength) {
705 slength -= slength % mult;
707 nstrides = length / slength;
708 if(nstrides > Maxstrides)
709 nstrides = Maxstrides;
712 req->r_data.io.r_nbytes = slength;
713 if( sc->m_flags & SY_NENT ) {
714 req->r_data.io.r_nstrides = 1;
715 req->r_data.io.r_nent = nstrides;
717 req->r_data.io.r_nstrides = nstrides;
718 req->r_data.io.r_nent = 1;
730 * Get information about a file that iogen uses to choose io length and
731 * offset. Information gathered is file length, iounit, and raw iounit.
732 * For regurlar files, iounit is 1, and raw iounit is the iounit of the
733 * device on which the file resides. For block/character special files
734 * the iounit and raw iounit are both the iounit of the device.
736 * Note: buffered and osync io must be iounit aligned
737 * raw and ossd io must be raw iounit aligned
742 struct file_info *rec;
746 struct dioattr finfo;
749 * Figure out if the files is regular, block or character special. Any
750 * other type is an error.
753 if (stat(rec->f_path, &sbuf) == -1) {
754 fprintf(stderr, "iogen%s: get_file_info(): Could not stat() %s: %s\n",
755 TagName, rec->f_path, SYSERR);
759 rec->f_type = sbuf.st_mode & S_IFMT;
762 * If regular, iou is 1, and we must figure out the device on
763 * which the file resides. riou is the iou (logical sector size) of
767 if (S_ISREG(sbuf.st_mode)) {
769 rec->f_length = sbuf.st_size;
772 * If -r used, take Rawmult as the raw/ssd io multiple. Otherwise
773 * attempt to determine it by looking at the device the file
778 rec->f_riou = Rawmult;
783 if( (fd = open(rec->f_path, O_RDWR|O_DIRECT, 0)) != -1 ) {
785 #ifdef XFS_IOC_DIOINFO
786 if(xfsctl(rec->f_path, fd, XFS_IOC_DIOINFO, &finfo) != -1) {
789 if(fcntl(fd, F_DIOINFO, &finfo) != -1) {
794 dio_env = getenv("XFS_DIO_MIN");
796 finfo.d_mem = finfo.d_miniosz = atoi(dio_env);
798 rec->f_riou = finfo.d_miniosz;
801 "iogen%s: Error %s (%d) getting direct I/O info of file %s\n",
802 TagName, strerror(errno), errno, rec->f_path);
806 rec->f_riou = BBSIZE;
811 rec->f_length = BSIZE;
818 * Create file path as nbytes long. If path exists, the file will either be
819 * extended or truncated to be nbytes long. Returns final size of file,
820 * or -1 if there was a failure.
824 create_file(path, nbytes)
833 struct fsxattr xattr;
834 struct dioattr finfo;
838 rval = stat(path, &sbuf);
841 if (errno == ENOENT) {
844 fprintf(stderr, "iogen%s: Could not stat file %s: %s (%d)\n",
845 TagName, path, SYSERR, errno);
849 if (! S_ISREG(sbuf.st_mode)) {
851 "iogen%s: file %s exists, but is not a regular file - cannot modify length\n",
857 if (sbuf.st_size == nbytes)
860 Oflags |= O_CREAT | O_WRONLY;
862 if ((fd = open(path, Oflags, 0666)) == -1) {
863 fprintf(stderr, "iogen%s: Could not create/open file %s: %s (%d)\n",
864 TagName, path, SYSERR, errno);
869 * Truncate file if it is longer than nbytes, otherwise attempt to
870 * pre-allocate file blocks.
873 if (sbuf.st_size > nbytes) {
874 if (ftruncate(fd, nbytes) == -1) {
876 "iogen%s: Could not ftruncate() %s to %d bytes: %s (%d)\n",
877 TagName, path, nbytes, SYSERR, errno);
884 * The file must be designated as Real-Time before any data
885 * is allocated to it.
889 bzero(&xattr, sizeof(xattr));
890 xattr.fsx_xflags = XFS_XFLAG_REALTIME;
891 /*fprintf(stderr, "set: fsx_xflags = 0x%x\n", xattr.fsx_xflags);*/
892 #ifdef XFS_IOC_FSSETXATTR
893 if( xfsctl(path, fd, XFS_IOC_FSSETXATTR, &xattr) == -1 ) {
896 if (fcntl(fd, F_FSSETXATTR, &xattr) < 0) {
901 fprintf(stderr, "iogen%s: Error %s (%d) setting XFS XATTR->Realtime on file %s\n",
902 TagName, SYSERR, errno, path);
908 #ifdef XFS_IOC_FSGETXATTR
909 if( xfsctl(path, fd, XFS_IOC_FSGETXATTR, &xattr) == -1 ) {
912 if (fcntl(fd, F_FSGETXATTR, &xattr) < 0) {
917 fprintf(stderr, "iogen%s: Error getting realtime flag %s (%d)\n",
918 TagName, SYSERR, errno);
922 fprintf(stderr, "get: fsx_xflags = 0x%x\n",
930 * Failure is ignored since XFS_IOC_RESVSP only works on XFS and the
931 * filesystem could be on some otehr filesystem.
934 f.l_whence = SEEK_SET;
939 "create_file: xfsctl(%d, RESVSP, { %d, %lld, %lld })\n",
940 fd, f.l_whence, (long long)f.l_start, (long long)f.l_len);*/
942 /* non-zeroing reservation */
943 #ifdef XFS_IOC_RESVSP
944 if( xfsctl( path, fd, XFS_IOC_RESVSP, &f ) == -1) {
946 "iogen%s: Could not xfsctl(XFS_IOC_RESVSP) %d bytes in file %s: %s (%d)\n",
947 TagName, nbytes, path, SYSERR, errno);
953 if( fcntl( fd, F_RESVSP, &f ) == -1) {
955 "iogen%s: Could not fcntl(F_RESVSP) %d bytes in file %s: %s (%d)\n",
956 TagName, nbytes, path, SYSERR, errno);
967 /* XFS_IOC_ALLOCSP allocates from the file start to l_start */
968 f.l_whence = SEEK_SET;
972 "create_file: xfsctl(%d, XFS_IOC_ALLOCSP, { %d, %lld, %lld })\n",
973 fd, f.l_whence, (long long)f.l_start,
974 (long long)f.l_len);*/
976 /* zeroing reservation */
977 #ifdef XFS_IOC_ALLOCSP
978 if( xfsctl( path, fd, XFS_IOC_ALLOCSP, &f ) == -1) {
980 "iogen%s: Could not xfsctl(XFS_IOC_ALLOCSP) %d bytes in file %s: %s (%d)\n",
981 TagName, nbytes, path, SYSERR, errno);
987 if ( fcntl(fd, F_ALLOCSP, &f) < 0) {
989 "iogen%s: Could not fcntl(F_ALLOCSP) %d bytes in file %s: %s (%d)\n",
990 TagName, nbytes, path, SYSERR, errno);
1002 * Write a byte at the end of file so that stat() sets the right
1008 if( (fd = open(path, O_CREAT|O_RDWR|O_DIRECT, 0)) != -1 ) {
1010 #ifdef XFS_IOC_DIOINFO
1011 if(xfsctl(path, fd, XFS_IOC_DIOINFO, &finfo) == -1) {
1014 if (fcntl(fd, F_DIOINFO, &finfo) < 0) {
1020 "iogen%s: Error %s (%d) getting direct I/O info for file %s\n",
1021 TagName, SYSERR, errno, path);
1024 /*fprintf(stderr, "%s: miniosz=%d\n",
1025 path, finfo.d_miniosz);*/
1028 dio_env = getenv("XFS_DIO_MIN");
1030 finfo.d_mem = finfo.d_miniosz = atoi(dio_env);
1032 fprintf(stderr, "iogen%s: Error %s (%d) opening file %s with flags O_CREAT|O_RDWR|O_DIRECT\n",
1033 TagName, SYSERR, errno, path);
1038 * nb is nbytes adjusted down by an even d_miniosz block
1040 * Note: the first adjustment can cause iogen to print a warning
1041 * about not being able to create a file of <nbytes> length,
1042 * since the file will be shorter.
1044 nb = nbytes-finfo.d_miniosz;
1045 nb = nb-nb%finfo.d_miniosz;
1048 "create_file_ow2: lseek(%d, %d {%d %d}, SEEK_SET)\n",
1049 fd, nb, nbytes, finfo.d_miniosz);*/
1051 if (lseek(fd, nb, SEEK_SET) == -1) {
1053 "iogen%s: Could not lseek() to EOF of file %s: %s (%d)\n\tactual offset %d file size goal %d miniosz %lld\n",
1054 TagName, path, SYSERR, errno,
1055 nb, nbytes, (long long)finfo.d_miniosz);
1060 b = buf = (char *)malloc(finfo.d_miniosz+finfo.d_mem);
1062 if( ((long)buf % finfo.d_mem != 0) ) {
1063 buf += finfo.d_mem - ((long)buf % finfo.d_mem);
1066 memset(buf, 0, finfo.d_miniosz);
1068 if ( (rval=write(fd, buf, finfo.d_miniosz)) != finfo.d_miniosz) {
1070 "iogen%s: Could not write %d byte length file %s: %s (%d)\n",
1071 TagName, nb, path, SYSERR, errno);
1073 "\twrite(%d, 0x%lx, %d) = %d\n",
1074 fd, (long)buf, finfo.d_miniosz, rval);
1076 "\toffset %d file size goal %d, miniosz=%d\n",
1077 nb, nbytes, finfo.d_miniosz);
1085 "create_file_Owrite: lseek(%d, %d {%d}, SEEK_SET)\n",
1086 fd, nbytes-1, nbytes);*/
1088 if (lseek(fd, nbytes-1, SEEK_SET) == -1) {
1090 "iogen%s: Could not lseek() to EOF in file %s: %s (%d)\n\toffset goal %d\n",
1091 TagName, path, SYSERR, errno,
1097 if ( (rval=write(fd, &c, 1)) != 1) {
1099 "iogen%s: Could not create a %d byte length file %s: %s (%d)\n",
1100 TagName, nbytes, path, SYSERR, errno);
1102 "\twrite(%d, 0x%lx, %d) = %d\n",
1103 fd, (long)&c, 1, rval);
1105 "\toffset %d file size goal %d\n",
1116 return sbuf.st_size;
1120 * Function to convert a string to its corresponding value in a strmap array.
1121 * If the string is not found in the array, the value corresponding to the
1122 * NULL string (the last element in the array) is returned.
1126 str_to_value(map, str)
1132 for (mp = map; mp->m_string != NULL; mp++)
1133 if (strcmp(mp->m_string, str) == 0)
1140 * Function to convert a string to its corresponding entry in a strmap array.
1141 * If the string is not found in the array, a NULL is returned.
1145 str_lookup(map, str)
1151 for (mp = map; mp->m_string != NULL; mp++)
1152 if (strcmp(mp->m_string, str) == 0)
1155 return((mp->m_string == NULL) ? NULL : mp);
1160 * Function to convert a value to its corresponding string in a strmap array.
1161 * If the value is not found in the array, NULL is returned.
1165 value_to_string(map, val)
1171 for (mp = map; mp->m_string != NULL; mp++)
1172 if (mp->m_value == val)
1175 return mp->m_string;
1179 * Interpret cmdline options/arguments. Exit with 1 if something on the
1180 * cmdline isn't kosher.
1184 parse_cmdline(argc, argv, opts)
1189 int o, len, nb, format_error;
1190 struct strmap *flgs, *sc;
1191 char *file, *cp, ch;
1193 struct file_info *fptr;
1195 char *openargs[5]; /* Flags, cbits, cblks */
1196 while ((o = getopt(argc, argv, opts)) != EOF) {
1200 fprintf(stderr, "iogen%s: Unrecognized option -a on this platform\n", TagName);
1205 cp = strtok(optarg, ",");
1206 while (cp != NULL) {
1207 if( (flgs = str_lookup(Flag_Map, cp)) == NULL ) {
1208 fprintf(stderr, "iogen%s: Unrecognized flags: %s\n", TagName, cp);
1212 cp = strtok(NULL, ",");
1215 if (flgs->m_value & O_SSD && ! Sds_Avail) {
1216 fprintf(stderr, "iogen%s: Warning - no sds available, ignoring ssd flag\n", TagName);
1221 Flag_List[Nflags++] = flgs;
1234 switch (sscanf(optarg, "%i%c", &Iterations, &ch)) {
1254 fprintf(stderr, "iogen%s: Illegal -i arg (%s): Must be of the format: number[s]\n", TagName, optarg);
1255 fprintf(stderr, " where 'number' is >= 0\n");
1263 fprintf(stderr, "iogen%s: Unrecognized option -L on this platform\n", TagName);
1268 if ((Offset_Mode = str_lookup(Omode_Map, optarg)) == NULL) {
1269 fprintf(stderr, "iogen%s: Illegal -m arg (%s)\n", TagName, optarg);
1277 sprintf( TagName, "(%.39s)", optarg );
1286 nopenargs = string_to_tokens(optarg, openargs, 4, ":/");
1287 if(!strcmp(openargs[0], "realtime")) {
1289 * -O realtime:extsize
1293 sscanf(openargs[1],"%i", &Oextsize);
1296 } else if( !strcmp(openargs[0], "allocate") ||
1297 !strcmp(openargs[0], "allocsp")) {
1303 } else if(!strcmp(openargs[0], "reserve")) {
1309 } else if(!strcmp(openargs[0], "noreserve")) {
1310 /* Oreserve=1 by default; this clears that default */
1312 } else if(!strcmp(openargs[0], "nowrite")) {
1313 /* Owrite=1 by default; this clears that default */
1315 } else if(!strcmp(openargs[0], "direct")) {
1316 /* this means "use direct i/o to preallocate file" */
1319 fprintf(stderr, "iogen%s: Error: -O %s error: unrecognized option\n",
1320 TagName, openargs[0]);
1332 if ((Rawmult = str_to_bytes(optarg)) == -1 ||
1333 Rawmult < 11 || Rawmult % BSIZE) {
1334 fprintf(stderr, "iogen%s: Illegal -r arg (%s). Must be > 0 and multipe of BSIZE (%d)\n",
1335 TagName, optarg, BSIZE);
1343 cp = strtok(optarg, ",");
1344 while (cp != NULL) {
1345 if ((sc = str_lookup(Syscall_Map, cp)) == NULL) {
1346 fprintf(stderr, "iogen%s: Unrecognized syscall: %s\n", TagName, cp);
1351 /* >>> sc->m_flags & FLG_SDS */
1352 if (sc->m_value != SSREAD && sc->m_value != SSWRITE)
1355 Syscall_List[Nsyscalls++] = sc;
1356 } while ( (sc = str_lookup(++sc, cp)) != NULL);
1358 cp = strtok(NULL, ",");
1364 if ((Mintrans = str_to_bytes(optarg)) == -1) {
1365 fprintf(stderr, "iogen%s: Illegal -t arg (%s): Must have the form num[bkm]\n", TagName, optarg);
1372 if ((Maxtrans = str_to_bytes(optarg)) == -1) {
1373 fprintf(stderr, "iogen%s: Illegal -T arg (%s): Must have the form num[bkm]\n", TagName, optarg);
1399 Offset_Mode = str_lookup(Omode_Map, "sequential");
1408 Maxtrans = 256 * BSIZE;
1411 Oflags = Ocbits = Ocblks = 0;
1414 * Supply default async io completion strategy types.
1418 for (mp = Aio_Strat_Map; mp->m_string != NULL; mp++) {
1419 Aio_Strat_List[Naio_Strat_Types++] = mp;
1424 * Supply default syscalls. Default is read,write,reada,writea,listio.
1429 Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "read");
1430 Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "write");
1431 Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "pread");
1432 Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "pwrite");
1433 Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "readv");
1434 Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "writev");
1435 Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "mmread");
1436 Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "mmwrite");
1441 if (Fileio && (argc - optind < 1)) {
1442 fprintf(stderr, "iogen%s: No files specified on the cmdline\n", TagName);
1447 * Supply default file io flags - defaut is 'buffered,raw,sync,ldraw'.
1450 if (! f_opt && Fileio) {
1452 Flag_List[Nflags++] = str_lookup(Flag_Map, "buffered");
1453 Flag_List[Nflags++] = str_lookup(Flag_Map, "sync");
1457 if (optind >= argc) {
1458 fprintf(stderr, "iogen%s: No files listed on the cmdline\n", TagName);
1463 * Initialize File_List[] - only necessary if doing file io. First
1464 * space for the File_List array, then fill it in.
1467 File_List = (struct file_info *)
1468 malloc((argc-optind) * sizeof(struct file_info));
1470 if (File_List == NULL) {
1471 fprintf(stderr, "iogen%s: Could not malloc space for %d file_info structures\n", TagName, argc-optind);
1475 memset(File_List, 0, (argc-optind) * sizeof(struct file_info));
1478 while (optind < argc) {
1482 * Pick off leading len: if it's there and create/extend/trunc
1483 * the file to the desired length. Otherwise, just make sure
1484 * the file is accessable.
1487 if ((cp = strchr(argv[optind], ':')) != NULL) {
1489 if ((len = str_to_bytes(argv[optind])) == -1) {
1491 "iogen%s: illegal file length (%s) for file %s\n",
1492 TagName, argv[optind], cp+1);
1498 if (strlen(file) > MAX_FNAME_LENGTH) {
1499 fprintf(stderr, "iogen%s: Max fname length is %d chars - ignoring file %s\n",
1500 TagName, MAX_FNAME_LENGTH, file);
1505 nb = create_file(file, len);
1509 "iogen%s warning: Couldn't create file %s of %d bytes\n",
1510 TagName, file, len);
1518 file = argv[optind];
1519 if (access(file, R_OK | W_OK) == -1) {
1520 fprintf(stderr, "iogen%s: file %s cannot be accessed for reading and/or writing: %s (%d)\n",
1521 TagName, file, SYSERR, errno);
1527 * get per-file information
1530 fptr = &File_List[Nfiles];
1532 if (file[0] == '/') {
1533 strcpy(fptr->f_path, file);
1535 getcwd(fptr->f_path,
1536 sizeof(fptr->f_path)-1);
1537 strcat(fptr->f_path, "/");
1538 strcat(fptr->f_path, file);
1541 if (get_file_info(fptr) == -1) {
1542 fprintf(stderr, "iogen%s warning: Error getting file info for %s\n", TagName, file);
1546 * If the file length is smaller than our min transfer size,
1550 if (fptr->f_length < Mintrans) {
1551 fprintf(stderr, "iogen%s warning: Ignoring file %s\n",
1552 TagName, fptr->f_path);
1553 fprintf(stderr, " length (%d) is < min transfer size (%d)\n",
1554 fptr->f_length, Mintrans);
1560 * If the file length is smaller than our max transfer size,
1564 if (fptr->f_length < Maxtrans) {
1565 fprintf(stderr, "iogen%s warning: Ignoring file %s\n",
1566 TagName, fptr->f_path);
1567 fprintf(stderr, " length (%d) is < max transfer size (%d)\n",
1568 fptr->f_length, Maxtrans);
1573 if (fptr->f_length > 0) {
1574 switch (Offset_Mode->m_value) {
1576 fptr->f_lastoffset = 0;
1577 fptr->f_lastlength = 0;
1581 fptr->f_lastoffset = fptr->f_length;
1582 fptr->f_lastlength = 0;
1586 fptr->f_lastoffset = fptr->f_length / 2;
1587 fptr->f_lastlength = 0;
1599 fprintf(stderr, "iogen%s: Could not create, or gather info for any test files\n", TagName);
1612 fprintf(stream, "\n");
1614 fprintf(stream, "\t-a aio_type,... Async io completion types to choose. Supported types\n");
1615 fprintf(stream, "\t are: poll, signal, suspend, and callback.\n");
1616 fprintf(stream, "\t Default is all of the above.\n");
1618 fprintf(stream, "\t-a (Not used on Linux).\n");
1620 fprintf(stream, "\t-f flag,... Flags to use for file IO. Supported flags are\n");
1621 fprintf(stream, "\t buffered, direct, sync.\n");
1622 fprintf(stream, "\t Default is 'buffered,sync'.\n");
1623 fprintf(stream, "\t-h This help.\n");
1624 fprintf(stream, "\t-i iterations[s] # of requests to generate. 0 means causes iogen\n");
1625 fprintf(stream, "\t to run until it's killed. If iterations is suffixed\n");
1626 fprintf(stream, "\t with 's', then iterations is the number of seconds\n");
1627 fprintf(stream, "\t that iogen should run for. Default is '0'.\n");
1628 fprintf(stream, "\t-L min:max listio nstrides / nrequests range\n");
1629 fprintf(stream, "\t-m offset-mode The mode by which iogen chooses the offset for\n");
1630 fprintf(stream, "\t consectutive transfers within a given file.\n");
1631 fprintf(stream, "\t Allowed values are 'random', 'sequential',\n");
1632 fprintf(stream, "\t and 'reverse'.\n");
1633 fprintf(stream, "\t sequential is the default.\n");
1634 fprintf(stream, "\t-N tagname Tag name, for Monster.\n");
1635 fprintf(stream, "\t-o Form overlapping consecutive requests.\n");
1636 fprintf(stream, "\t-O Open flags for creating files\n");
1637 fprintf(stream, "\t realtime:extsize - put file on real-time volume\n");
1638 fprintf(stream, "\t allocate - allocate space with F_ALLOCSP\n");
1639 fprintf(stream, "\t reserve - reserve space with F_RESVSP (default)\n");
1640 fprintf(stream, "\t noreserve - do not reserve with F_RESVSP\n");
1641 fprintf(stream, "\t direct - use O_DIRECT I/O to write to the file\n");
1642 fprintf(stream, "\t-p Output pipe. Default is stdout.\n");
1643 fprintf(stream, "\t-q Quiet mode. Normally iogen spits out info\n");
1644 fprintf(stream, "\t about test files, options, etc. before starting.\n");
1645 fprintf(stream, "\t-s syscall,... Syscalls to do. Supported syscalls are\n");
1647 fprintf(stream, "\t read, write, pread, pwrite, readv, writev,\n");
1648 fprintf(stream, "\t mmread, mmwrite, fsync2, fdatasync,\n");
1649 fprintf(stream, "\t Default is 'read,write,readv,writev,mmread,mmwrite'.\n");
1651 fprintf(stream, "\t-t mintrans Min transfer length\n");
1652 fprintf(stream, "\t-T maxtrans Max transfer length\n");
1653 fprintf(stream, "\n");
1654 fprintf(stream, "\t[len:]file,... Test files to do IO against (note ssread/sswrite\n");
1655 fprintf(stream, "\t don't need a test file). The len: syntax\n");
1656 fprintf(stream, "\t informs iogen to first create/expand/truncate the\n");
1657 fprintf(stream, "\t to the desired length.\n");
1658 fprintf(stream, "\n");
1659 fprintf(stream, "\tNote: The ssd flag causes sds transfers to also be done.\n");
1660 fprintf(stream, "\t To totally eliminate sds transfers, you must eleminate sds\n");
1661 fprintf(stream, "\t from the flags (-f) and ssread,ssrite from the syscalls (-s)\n");
1662 fprintf(stream, "\tThe mintrans, maxtrans, and len: parameters are numbers of the\n");
1663 fprintf(stream, "\tform [0-9]+[bkm]. The optional trailing b, k, or m multiplies\n");
1664 fprintf(stream, "\tthe number by blocks, kilobytes, or megabytes. If no trailing\n");
1665 fprintf(stream, "\tmultiplier is present, the number is interpreted as bytes\n");
1671 * Obvious - usage clause
1678 fprintf(stream, "usage%s: iogen [-hoq] [-a aio_type,...] [-f flag[,flag...]] [-i iterations] [-p outpipe] [-m offset-mode] [-s syscall[,syscall...]] [-t mintrans] [-T maxtrans] [ -O file-create-flags ] [[len:]file ...]\n", TagName);