ltp/iogen.c

   1 /*
   2  * Copyright (c) 2000 Silicon Graphics, Inc.  All Rights Reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of version 2 of the GNU General Public License as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it would be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11  *
  12  * Further, this software is distributed without any warranty that it is
  13  * free of the rightful claim of any third person regarding infringement
  14  * or the like.  Any license provided herein, whether implied or
  15  * otherwise, applies only to this software file.  Patent licenses, if
  16  * any, provided herein do not apply to combinations of this program with
  17  * other software, or any other product whatsoever.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; if not, write the Free Software Foundation, Inc., 59
  21  * Temple Place - Suite 330, Boston MA 02111-1307, USA.
  22  *
  23  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
  24  * Mountain View, CA  94043, or:
  25  *
  26  * http://www.sgi.com
  27  *
  28  * For further information regarding this notice, see:
  29  *
  30  * http://oss.sgi.com/projects/GenInfo/NoticeExplan/
  31  */
  32 /*
  33  * iogen - a tool for generating file/sds io for a doio process
  34  */
  35
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <unistd.h>
  39 #include <signal.h>
  40 #include <fcntl.h>
  41 #include <errno.h>
  42 #include <string.h>
  43 #include <signal.h>
  44 #include <time.h>
  45 #include <sys/param.h>
  46 #include <sys/types.h>
  47 #include <sys/stat.h>
  48 #include <sys/sysmacros.h>
  49 #ifdef CRAY
  50 #include <sys/file.h>
  51 #include <sys/iosw.h>
  52 #include <sys/listio.h>
  53 #endif
  54 #ifdef sgi
  55 #include <sys/statvfs.h>
  56 #include <sys/fs/xfs_itable.h>
  57 #endif
  58
  59 #ifndef NO_XFS
  60 #include <xfs/libxfs.h>
  61 #endif
  62
  63 #ifdef CRAY
  64 #include "libkern.h"
  65 #endif
  66
  67 #include "doio.h"
  68 #include "str_to_bytes.h"
  69 #include "string_to_tokens.h"
  70 #include "open_flags.h"
  71 #include "random_range.h"
  72
  73 #ifndef BSIZE
  74 #define BSIZE 512
  75 #endif
  76
  77 #define RAW_IO(_flags_) ((_flags_) & (O_RAW | O_SSD))
  78
  79 #define SYSERR  strerror(errno)
  80
  81 /*
  82  * Structure for retaining test file information
  83  */
  84
  85 struct file_info {
  86         char    f_path[MAX_FNAME_LENGTH+1]; /* file name (full path)    */
  87         int     f_length;       /* length in bytes                      */
  88         int     f_iou;          /* file iounit                          */
  89         int     f_riou;         /* file raw iounit (for O_RAW/O_SSD)    */
  90         int     f_dalign;       /* direct I/O alignment                 */
  91         int     f_nextoff;      /* offset of end of last io operation   */
  92         int     f_type;         /* file type S_IFREG, etc...            */
  93         int     f_lastoffset;   /* offset of last io operation          */
  94         int     f_lastlength;   /* length of last io operation          */
  95 };
  96
  97 /*
  98  * Simple structure for associating strings with values - useful for converting
  99  * cmdline args to internal values, as well as printing internal values in
 100  * a human readable form.
 101  */
 102
 103 struct strmap {
 104         char    *m_string;
 105         int     m_value;
 106         int     m_flags;
 107 };
 108
 109 /*
 110  * Declare cmdline option flags/variables initialized in parse_cmdline()
 111  */
 112
 113 #define OPTS    "a:dhf:i:L:m:op:qr:s:t:T:O:N:"
 114
 115 int     a_opt = 0;              /* async io comp. types supplied            */
 116 int     o_opt = 0;              /* form overlapping requests                */
 117 int     f_opt = 0;              /* test flags                               */
 118 int     i_opt = 0;              /* iterations - 0 implies infinite          */
 119 int     L_opt = 0;              /* listio min-max nstrides & nents          */
 120 int     m_opt = 0;              /* offset mode                              */
 121 int     O_opt = 0;              /* file creation Open flags                 */
 122 int     p_opt = 0;              /* output pipe - default is stdout          */
 123 int     r_opt = 0;              /* specify raw io multiple instead of       */
 124                                 /* getting it from the mounted on device.   */
 125                                 /* Only applies to regular files.           */
 126 int     s_opt = 0;              /* syscalls                                 */
 127 int     t_opt = 0;              /* min transfer size (bytes)                */
 128 int     T_opt = 0;              /* max transfer size (bytes)                */
 129 int     q_opt = 0;              /* quiet operation on startup               */
 130 char    TagName[40];            /* name of this iogen (see Monster)         */
 131 struct  strmap *Offset_Mode;    /* M_SEQUENTIAL, M_RANDOM, etc.             */
 132 int     Iterations;             /* # requests to generate (0 --> infinite)  */
 133 int     Time_Mode = 0;          /* non-zero if Iterations is in seconds     */
 134                                 /* (ie. -i arg was suffixed with 's')       */
 135 char    *Outpipe;               /* Pipe to write output to if p_opt         */
 136 int     Mintrans;               /* min io transfer size                     */
 137 int     Maxtrans;               /* max io transfer size                     */
 138 int     Rawmult;                /* raw/ssd io multiple (from -r)            */
 139 int     Minstrides;             /* min # of listio strides per request      */
 140 int     Maxstrides;             /* max # of listio strides per request      */
 141 int     Oflags;                 /* open(2) flags for creating files         */
 142 int     Ocbits;                 /* open(2) cbits for creating files         */
 143 int     Ocblks;                 /* open(2) cblks for creating files         */
 144 int     Orealtime=0;            /* flag set for -O REALTIME                 */
 145 int     Oextsize=0;             /* real-time extent size                    */
 146 int     Oreserve=1;             /* flag for -O [no]reserve                  */
 147 int     Oallocate=0;            /* flag for -O allocate                     */
 148 int     Owrite=1;               /* flag for -O nowrite                      */
 149
 150 int     Nfiles = 0;             /* # files on cmdline                       */
 151 struct  file_info *File_List;   /* info about each file                     */
 152 int     Nflags = 0;             /* # flags on cmdline                       */
 153 struct  strmap *Flag_List[128]; /* flags selected from cmdline              */
 154 int     Nsyscalls = 0;          /* # syscalls on cmdline                    */
 155 struct  strmap *Syscall_List[128]; /* syscalls selected on cmdline          */
 156 int     Fileio = 0;             /* flag indicating that a file              */
 157                                 /* io syscall has been chosen.              */
 158 int     Naio_Strat_Types = 0;   /* # async io completion types              */
 159 struct  strmap *Aio_Strat_List[128]; /* Async io completion types           */
 160
 161 void    startup_info();
 162
 163 /*
 164  * Map async io completion modes (-a args) names to values.  Macros are
 165  * defined in doio.h.
 166  */
 167
 168 struct strmap   Aio_Strat_Map[] = {
 169 #ifndef linux
 170         { "poll",       A_POLL          },
 171         { "signal",     A_SIGNAL        },
 172 #else
 173         { "none",       0       },
 174 #endif /* !linux */
 175 #ifdef CRAY
 176 #if _UMK || RELEASE_LEVEL >= 8000
 177         { "recall",     A_RECALL        },
 178 #endif
 179
 180 #ifdef RECALL_SIZEOF
 181         { "recalla",    A_RECALLA       },
 182 #endif
 183         { "recalls",    A_RECALLS       },
 184 #endif /* CRAY */
 185
 186 #ifdef sgi
 187         { "suspend",    A_SUSPEND       },
 188         { "callback",   A_CALLBACK      },
 189 #endif
 190         { NULL,         -1              }
 191 };
 192
 193 /*
 194  * Offset_Mode #defines
 195  */
 196
 197 #define M_RANDOM        1
 198 #define M_SEQUENTIAL    2
 199 #define M_REVERSE       3
 200
 201 /*
 202  * Map offset mode (-m args) names to values
 203  */
 204
 205 struct strmap   Omode_Map[] = {
 206         { "random",             M_RANDOM        },
 207         { "sequential",         M_SEQUENTIAL    },
 208         { "reverse",            M_REVERSE       },
 209         { NULL,                 -1              }
 210 };
 211
 212 /*
 213  * Map syscall names (-s args) to values - macros are defined in doio.h.
 214  */
 215 #define SY_ASYNC        00001
 216 #define SY_WRITE        00002
 217 #define SY_SDS          00010
 218 #define SY_LISTIO       00020
 219 #define SY_NENT         00100   /* multi entry vs multi stride >>> */
 220
 221 struct strmap   Syscall_Map[] = {
 222         { "read",               READ,           0                       },
 223         { "write",              WRITE,          SY_WRITE                },
 224 #ifdef CRAY
 225         { "reada",              READA,          SY_ASYNC                },
 226         { "writea",             WRITEA,         SY_WRITE|SY_ASYNC       },
 227 #ifndef _CRAYMPP
 228         { "ssread",             SSREAD,         SY_SDS                  },
 229         { "sswrite",            SSWRITE,        SY_WRITE|SY_SDS         },
 230 #endif
 231         { "listio",             LISTIO,         SY_ASYNC                },
 232
 233         /* listio as 4 system calls */
 234         { "lread",              LREAD,          0                       },
 235         { "lreada",             LREADA,         SY_ASYNC                },
 236         { "lwrite",             LWRITE,         SY_WRITE                },
 237         { "lwritea",            LWRITEA,        SY_WRITE|SY_ASYNC       },
 238
 239         /* listio with nstrides > 1 */
 240         { "lsread",             LSREAD,         0                       },
 241         { "lsreada",            LSREADA,        SY_ASYNC                },
 242         { "lswrite",            LSWRITE,        SY_WRITE                },
 243         { "lswritea",           LSWRITEA,       SY_WRITE|SY_ASYNC       },
 244
 245         /* listio with nents > 1 */
 246         { "leread",             LEREAD,         0|SY_NENT               },
 247         { "lereada",            LEREADA,        SY_ASYNC|SY_NENT        },
 248         { "lewrite",            LEWRITE,        SY_WRITE|SY_NENT        },
 249         { "lewritea",           LEWRITEA,       SY_WRITE|SY_ASYNC|SY_NENT },
 250
 251         /* listio with nents > 1 & nstrides > 1 */
 252
 253         /* all listio system calls under one name */
 254         { "listio+",            LREAD,          0                       },
 255         { "listio+",            LREADA,         SY_ASYNC                },
 256         { "listio+",            LWRITE,         SY_WRITE                },
 257         { "listio+",            LWRITEA,        SY_WRITE|SY_ASYNC       },
 258         { "listio+",            LSREAD,         0                       },
 259         { "listio+",            LSREADA,        SY_ASYNC                },
 260         { "listio+",            LSWRITE,        SY_WRITE                },
 261         { "listio+",            LSWRITEA,       SY_WRITE|SY_ASYNC       },
 262         { "listio+",            LEREAD,         0|SY_NENT               },
 263         { "listio+",            LEREADA,        SY_ASYNC|SY_NENT        },
 264         { "listio+",            LEWRITE,        SY_WRITE|SY_NENT        },
 265         { "listio+",            LEWRITEA,       SY_WRITE|SY_ASYNC|SY_NENT },
 266 #endif
 267
 268         { "pread",              PREAD                                   },
 269         { "pwrite",             PWRITE,         SY_WRITE                },
 270 #ifdef sgi
 271         { "aread",              AREAD,          SY_ASYNC                },
 272         { "awrite",             AWRITE,         SY_WRITE|SY_ASYNC       },
 273 #if 0
 274         /* not written yet */
 275         { "llread",             LLREAD,         0                       },
 276         { "llaread",            LLAREAD,        SY_ASYNC                },
 277         { "llwrite",            LLWRITE,        0                       },
 278         { "llawrite",           LLAWRITE,       SY_ASYNC                },
 279 #endif
 280         { "ffsync",             DFFSYNC,        SY_WRITE                },
 281 #endif /* SGI */
 282 #ifndef NO_XFS
 283         { "resvsp",             RESVSP,         SY_WRITE                },
 284         { "unresvsp",           UNRESVSP,       SY_WRITE                },
 285         { "reserve",            RESVSP,         SY_WRITE                },
 286         { "unreserve",          UNRESVSP,       SY_WRITE                },
 287 #endif
 288
 289 #ifndef CRAY
 290         { "readv",              READV                                   },
 291         { "writev",             WRITEV,         SY_WRITE                },
 292         { "mmread",             MMAPR                                   },
 293         { "mmwrite",            MMAPW,          SY_WRITE                },
 294         { "fsync2",             FSYNC2,         SY_WRITE                },
 295         { "fdatasync",          FDATASYNC,      SY_WRITE                },
 296 #endif
 297
 298         { NULL,                 -1      }
 299 };
 300
 301 /*
 302  * Map open flags (-f args) to values
 303  */
 304 #define FLG_RAW         00001
 305
 306 struct strmap   Flag_Map[] = {
 307         { "buffered",           0,                      0       },
 308         { "sync",               O_SYNC,                 0       },
 309 #ifdef CRAY
 310         { "raw",                O_RAW,                  FLG_RAW },
 311         { "raw+wf",             O_RAW | O_WELLFORMED,   FLG_RAW },
 312         { "raw+wf+ldraw",       O_RAW | O_WELLFORMED | O_LDRAW, FLG_RAW },
 313         { "raw+wf+ldraw+sync",  O_RAW | O_WELLFORMED | O_LDRAW | O_SYNC, FLG_RAW },
 314 #ifdef O_SSD
 315         { "ssd",                O_SSD,                  FLG_RAW },
 316 #endif
 317 #ifdef O_LDRAW
 318         { "ldraw",              O_LDRAW,                0       },
 319 #endif
 320 #ifdef O_PARALLEL
 321         { "parallel",           O_PARALLEL | O_RAW | O_WELLFORMED,
 322                   FLG_RAW },
 323         { "parallel+sync",      O_PARALLEL | O_RAW | O_WELLFORMED | O_SYNC,
 324                   FLG_RAW },
 325         { "parallel+ldraw",     O_PARALLEL | O_RAW | O_WELLFORMED | O_LDRAW,
 326                   FLG_RAW },
 327         { "parallel+ldraw+sync",
 328                   O_PARALLEL | O_RAW | O_WELLFORMED | O_LDRAW | O_SYNC,
 329                   FLG_RAW },
 330 #endif
 331 #endif /* CRAY */
 332
 333         { "direct",             O_DIRECT,               FLG_RAW },
 334 #ifdef sgi
 335         { "dsync",              O_DSYNC         },      /* affects writes */
 336         { "rsync",              O_RSYNC         },      /* affects reads */
 337         { "rsync+dsync",        O_RSYNC|O_DSYNC },
 338 #endif
 339         { NULL,             -1          }
 340 };
 341
 342 /*
 343  * Map file types to strings
 344  */
 345
 346 struct strmap   Ftype_Map[] = {
 347         { "regular",    S_IFREG },
 348         { "blk-spec",   S_IFBLK },
 349         { "chr-spec",   S_IFCHR },
 350         { NULL,         0 }
 351 };
 352
 353 /*
 354  * Misc declarations
 355  */
 356
 357 int             Sds_Avail;
 358
 359 char    Byte_Patterns[26] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
 360                               'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
 361                               'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
 362                               'Y', 'Z' };
 363
 364
 365 int form_iorequest(struct io_req *);
 366 int init_output();
 367 int parse_cmdline(int argc, char **argv, char *opts);
 368 int help(FILE *stream);
 369 int usage(FILE *stream);
 370
 371
 372 int
 373 main(argc, argv)
 374 int     argc;
 375 char    **argv;
 376 {
 377     int             rseed, outfd, infinite;
 378     time_t          start_time;
 379     struct io_req   req;
 380
 381     umask(0);
 382
 383 #ifdef CRAY
 384     Sds_Avail = sysconf(_SC_CRAY_SDS);
 385 #else
 386     Sds_Avail = 0;
 387 #endif
 388
 389     TagName[0] = '\0';
 390     parse_cmdline(argc, argv, OPTS);
 391
 392     /*
 393      * Initialize output descriptor.
 394      */
 395     if (! p_opt) {
 396         outfd = 1;
 397     } else {
 398         outfd = init_output();
 399     }
 400
 401     rseed = getpid();
 402     random_range_seed(rseed);       /* initialize random number generator */
 403
 404     /*
 405      * Print out startup information, unless we're running in quiet mode
 406      */
 407     if (!q_opt)
 408         startup_info(stderr, rseed);
 409
 410     start_time = time(0);
 411
 412     /*
 413      * While iterations (or forever if Iterations == 0) - compute an
 414      * io request, and write the structure to the output descriptor
 415      */
 416
 417     infinite = !Iterations;
 418
 419     while (infinite ||
 420            (! Time_Mode && Iterations--) ||
 421            (Time_Mode && time(0) - start_time <= Iterations)) {
 422
 423         memset(&req, 0, sizeof(struct io_req));
 424         if (form_iorequest(&req) == -1) {
 425             fprintf(stderr, "iogen%s:  form_iorequest() failed\n", TagName);
 426             continue;
 427         }
 428
 429         req.r_magic = DOIO_MAGIC;
 430         write(outfd, (char *)&req, sizeof(req));
 431     }
 432
 433     exit(0);
 434
 435 }   /* main */
 436
 437 void
 438 startup_info(FILE *stream, int seed)
 439 {
 440     char        *value_to_string(), *type;
 441     int         i;
 442
 443     fprintf(stream, "\n");
 444     fprintf(stream, "iogen%s starting up with the following:\n", TagName);
 445     fprintf(stream, "\n");
 446
 447     fprintf(stream, "Out-pipe:              %s\n",
 448             p_opt ? Outpipe : "stdout");
 449
 450     if (Iterations) {
 451         fprintf(stream, "Iterations:            %d", Iterations);
 452         if (Time_Mode)
 453             fprintf(stream, " seconds");
 454
 455         fprintf(stream, "\n");
 456     } else {
 457         fprintf(stream, "Iterations:            Infinite\n");
 458     }
 459
 460     fprintf(stream,
 461             "Seed:                  %d\n", seed);
 462
 463     fprintf(stream,
 464             "Offset-Mode:           %s\n", Offset_Mode->m_string);
 465
 466     fprintf(stream, "Overlap Flag:          %s\n",
 467             o_opt ? "on" : "off");
 468
 469     fprintf(stream,
 470             "Mintrans:              %-11d (%d blocks)\n",
 471             Mintrans, (Mintrans+BSIZE-1)/BSIZE);
 472
 473     fprintf(stream,
 474             "Maxtrans:              %-11d (%d blocks)\n",
 475             Maxtrans, (Maxtrans+BSIZE-1)/BSIZE);
 476
 477     if (! r_opt)
 478         fprintf(stream,
 479                 "O_RAW/O_SSD Multiple:  (Determined by device)\n");
 480     else
 481         fprintf(stream,
 482                 "O_RAW/O_SSD Multiple:  %-11d (%d blocks)\n",
 483                 Rawmult, (Rawmult+BSIZE-1)/BSIZE);
 484
 485     fprintf(stream, "Syscalls:              ");
 486     for (i = 0; i < Nsyscalls; i++)
 487         fprintf(stream,
 488                 "%s ", Syscall_List[i]->m_string);
 489     fprintf(stream, "\n");
 490
 491     fprintf(stream, "Aio completion types:  ");
 492     for (i = 0; i < Naio_Strat_Types; i++)
 493         fprintf(stream,
 494                 "%s ", Aio_Strat_List[i]->m_string);
 495     fprintf(stream, "\n");
 496
 497     if (Fileio) {
 498         fprintf(stream, "Flags:                 ");
 499         for (i = 0; i < Nflags; i++)
 500             fprintf(stream,
 501                     "%s ", Flag_List[i]->m_string);
 502
 503         fprintf(stream, "\n");
 504         fprintf(stream, "\n");
 505         fprintf(stream, "Test Files:  \n");
 506         fprintf(stream, "\n");
 507         fprintf(stream,
 508                 "Path                                          Length    iou   raw iou file\n");
 509         fprintf(stream,
 510                 "                                              (bytes) (bytes) (bytes) type\n");
 511         fprintf(stream,
 512                 "-----------------------------------------------------------------------------\n");
 513
 514         for (i = 0; i < Nfiles; i++) {
 515             type = value_to_string(Ftype_Map, File_List[i].f_type);
 516             fprintf(stream, "%-40s %12d %7d %7d %s\n",
 517                     File_List[i].f_path, File_List[i].f_length,
 518                     File_List[i].f_iou, File_List[i].f_riou, type);
 519         }
 520     }
 521 }
 522
 523 /*
 524  * Initialize output descriptor.  If going to stdout, its easy,
 525  * otherwise, attempt to create a FIFO on path Outpipe.  Exit with an
 526  * error code if this cannot be done.
 527  */
 528 int
 529 init_output()
 530 {
 531     int  outfd;
 532     struct stat     sbuf;
 533
 534     if (stat(Outpipe, &sbuf) == -1) {
 535         if (errno == ENOENT) {
 536             if (mkfifo(Outpipe, 0666) == -1) {
 537                 fprintf(stderr, "iogen%s:  Could not mkfifo %s:  %s\n",
 538                         TagName, Outpipe, SYSERR);
 539                 exit(2);
 540             }
 541         } else {
 542             fprintf(stderr, "iogen%s:  Could not stat outpipe %s:  %s\n",
 543                     TagName, Outpipe, SYSERR);
 544             exit(2);
 545         }
 546     } else {
 547         if (! S_ISFIFO(sbuf.st_mode)) {
 548             fprintf(stderr,
 549                     "iogen%s:  Output file %s exists, but is not a FIFO\n",
 550                     TagName, Outpipe);
 551             exit(2);
 552         }
 553     }
 554
 555     if ((outfd = open(Outpipe, O_RDWR)) == -1) {
 556         fprintf(stderr,
 557                 "iogen%s:  Couldn't open outpipe %s with flags O_RDWR: %s\n",
 558                 TagName, Outpipe, SYSERR);
 559         exit(2);
 560     }
 561
 562     return(outfd);
 563 }
 564
 565
 566 /*
 567  * Main io generation function.  form_iorequest() selects a system call to
 568  * do based on cmdline arguments, and proceeds to select parameters for that
 569  * system call.
 570  *
 571  * Returns 0 if req is filled in with a complete doio request, otherwise
 572  * returns -1.
 573  */
 574
 575 int
 576 form_iorequest(req)
 577 struct io_req   *req;
 578 {
 579     int                 mult, offset = 0, length = 0, slength;
 580     int                 minlength, maxlength, laststart, lastend;
 581     int                 minoffset, maxoffset;
 582     int                 maxstride, nstrides;
 583     char                pattern, *errp;
 584     struct strmap       *flags, *sc, *aio_strat;
 585     struct file_info    *fptr;
 586 #ifdef CRAY
 587     int                 opcode, cmd;
 588 #endif
 589
 590     /*
 591      * Choose system call, flags, and file
 592      */
 593
 594     sc = Syscall_List[random_range(0, Nsyscalls-1, 1, NULL)];
 595     req->r_type = sc->m_value;
 596
 597 #ifdef CRAY
 598     if (sc->m_value == LISTIO ) {
 599             opcode = random_range(0, 1, 1, NULL) ? LO_READ : LO_WRITE;
 600             cmd = random_range(0, 1, 1, NULL) ? LC_START : LC_WAIT;
 601     }
 602 #endif
 603
 604     if( sc->m_flags & SY_WRITE )
 605             pattern = Byte_Patterns[random_range(0, sizeof(Byte_Patterns) - 1, 1, NULL)];
 606     else
 607             pattern = 0;
 608
 609 #if CRAY
 610     /*
 611      * If sds io, simply choose a length (possibly pattern) and return
 612      */
 613
 614     if (sc->m_flags & SY_SDS ) {
 615             req->r_data.ssread.r_nbytes = random_range(Mintrans, Maxtrans, BSIZE, NULL);
 616             if (sc->m_flags & SY_WRITE)
 617                     req->r_data.sswrite.r_pattern = pattern;
 618
 619             return 0;
 620     }
 621 #endif
 622
 623     /*
 624      * otherwise, we're doing file io.  Choose starting offset, length,
 625      * open flags, and possibly a pattern (for write/writea).
 626      */
 627
 628     fptr = &File_List[random_range(0, Nfiles-1, 1, NULL)];
 629     flags = Flag_List[random_range(0, Nflags-1, 1, NULL)];
 630
 631     /*
 632      * Choose offset/length multiple.  IO going to a device, or regular
 633      * IO that is O_RAW or O_SSD must be aligned on the file r_iou.  Otherwise
 634      * it must be aligned on the regular iou (normally 1).
 635      */
 636
 637     if ( fptr->f_type == S_IFREG && (flags->m_flags & FLG_RAW) )
 638             mult = fptr->f_riou;
 639     else
 640             mult = fptr->f_iou;
 641
 642     /*
 643      * Choose offset and length.  Both must be a multiple of mult
 644      */
 645
 646     /*
 647      * Choose length first - it must be a multiple of mult
 648      */
 649
 650     laststart = fptr->f_lastoffset;
 651     lastend = fptr->f_lastoffset + fptr->f_lastlength - 1;
 652
 653     minlength = (Mintrans > mult) ? Mintrans : mult;
 654
 655     switch (Offset_Mode->m_value) {
 656     case M_SEQUENTIAL:
 657         if (o_opt && lastend > laststart)
 658             offset = random_range(laststart, lastend, 1, NULL);
 659         else
 660             offset = lastend + 1;
 661         if (offset && (offset%mult))
 662             offset += mult - (offset % mult);
 663
 664         if (minlength > fptr->f_length - offset)
 665             offset = 0;
 666
 667         maxlength = fptr->f_length - offset;
 668         if (maxlength > Maxtrans)
 669             maxlength = Maxtrans;
 670
 671         length = random_range(minlength, maxlength, mult, &errp);
 672         if (errp != NULL) {
 673             fprintf(stderr, "iogen%s:  random_range(%d, %d, %d) failed\n",
 674                     TagName, minlength, maxlength, mult);
 675             return -1;
 676         }
 677
 678         break;
 679
 680     case M_REVERSE:
 681         maxlength = laststart;
 682
 683         if (maxlength > Maxtrans)
 684             maxlength = Maxtrans;
 685
 686         if (minlength > maxlength) {
 687             laststart = fptr->f_length;
 688             lastend = fptr->f_length;
 689             maxlength = Maxtrans;
 690         }
 691
 692         length = random_range(minlength, maxlength, mult, &errp);
 693         if (errp != NULL) {
 694             fprintf(stderr, "iogen%s:  random_range(%d, %d, %d) failed\n",
 695                     TagName, minlength, maxlength, mult);
 696             return -1;
 697         }
 698
 699         offset = laststart - length;
 700
 701         if (o_opt && lastend > laststart)
 702             offset += random_range(1, lastend - laststart, 1, NULL);
 703
 704         if (offset &&  (offset%mult))
 705             offset -= offset % mult;
 706
 707         break;
 708
 709     case M_RANDOM:
 710         length = random_range(Mintrans, Maxtrans, mult, NULL);
 711
 712         if (o_opt && lastend > laststart) {
 713                 minoffset = laststart - length + 1;
 714                 if (minoffset < 0) {
 715                         minoffset = 0;
 716                 }
 717
 718                 if (lastend + length > fptr->f_length) {
 719                         maxoffset = fptr->f_length - length;
 720                 } else {
 721                         maxoffset = lastend;
 722                 }
 723         } else {
 724             minoffset = 0;
 725             maxoffset = fptr->f_length - length;
 726         }
 727
 728         if (minoffset < 0)
 729             minoffset = 0;
 730
 731         offset = random_range(minoffset, maxoffset, mult, &errp);
 732         if (errp != NULL) {
 733             fprintf(stderr, "iogen%s:  random_range(%d, %d, %d) failed\n",
 734                     TagName, minoffset, maxoffset, mult);
 735             return -1;
 736         }
 737     }
 738
 739     fptr->f_lastoffset = offset;
 740     fptr->f_lastlength = length;
 741
 742     /*
 743      * Choose an async io completion strategy if necessary
 744      */
 745     if( sc->m_flags & SY_ASYNC )
 746             aio_strat = Aio_Strat_List[random_range(0, Naio_Strat_Types - 1,
 747                                                     1, NULL)];
 748     else
 749             aio_strat = NULL;
 750
 751     /*
 752      * fill in specific syscall record data
 753      */
 754     switch (sc->m_value) {
 755     case READ:
 756     case READA:
 757         strcpy(req->r_data.read.r_file, fptr->f_path);
 758         req->r_data.read.r_oflags = O_RDONLY | flags->m_value;
 759         req->r_data.read.r_offset = offset;
 760         req->r_data.read.r_nbytes = length;
 761         req->r_data.read.r_uflags = (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
 762         req->r_data.read.r_aio_strat = (aio_strat==NULL) ? 0 : aio_strat->m_value;
 763         req->r_data.read.r_nstrides = 1;
 764         req->r_data.read.r_nent = 1;
 765         break;
 766
 767     case WRITE:
 768     case WRITEA:
 769         strcpy(req->r_data.write.r_file, fptr->f_path);
 770         req->r_data.write.r_oflags = O_WRONLY | flags->m_value;
 771         req->r_data.write.r_offset = offset;
 772         req->r_data.write.r_nbytes = length;
 773         req->r_data.write.r_pattern = pattern;
 774         req->r_data.write.r_uflags = (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
 775         req->r_data.write.r_aio_strat = (aio_strat==NULL) ? 0 : aio_strat->m_value;
 776         req->r_data.write.r_nstrides = 1;
 777         req->r_data.write.r_nent = 1;
 778         break;
 779
 780     case READV:
 781     case AREAD:
 782     case PREAD:
 783     case WRITEV:
 784     case AWRITE:
 785     case PWRITE:
 786
 787     case LREAD:
 788     case LREADA:
 789     case LWRITE:
 790     case LWRITEA:
 791
 792     case RESVSP:
 793     case UNRESVSP:
 794     case FSYNC2:
 795     case FDATASYNC:
 796
 797         strcpy(req->r_data.io.r_file, fptr->f_path);
 798         req->r_data.io.r_oflags = ((sc->m_flags & SY_WRITE) ? O_WRONLY : O_RDONLY) | flags->m_value;
 799         req->r_data.io.r_offset = offset;
 800         req->r_data.io.r_nbytes = length;
 801         req->r_data.io.r_pattern = pattern;
 802         req->r_data.io.r_uflags = (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
 803         req->r_data.io.r_aio_strat = (aio_strat==NULL) ? 0 : aio_strat->m_value;
 804         req->r_data.io.r_nstrides = 1;
 805         req->r_data.io.r_nent = 1;
 806         break;
 807
 808     case MMAPR:
 809     case MMAPW:
 810         strcpy(req->r_data.io.r_file, fptr->f_path);
 811         /* a subtle "feature" of mmap: a write-map requires
 812            the file open read/write */
 813         req->r_data.io.r_oflags = ((sc->m_flags & SY_WRITE) ? O_RDWR : O_RDONLY) | flags->m_value;
 814         req->r_data.io.r_offset = offset;
 815         req->r_data.io.r_nbytes = length;
 816         req->r_data.io.r_pattern = pattern;
 817         req->r_data.io.r_uflags = (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
 818         req->r_data.io.r_aio_strat = (aio_strat==NULL) ? 0 : aio_strat->m_value;
 819         req->r_data.io.r_nstrides = 1;
 820         req->r_data.io.r_nent = 1;
 821         break;
 822
 823     case LSREAD:
 824     case LSREADA:
 825     case LEREAD:
 826     case LEREADA:
 827     case LSWRITE:
 828     case LSWRITEA:
 829     case LEWRITE:
 830     case LEWRITEA:
 831         /* multi-strided */
 832         strcpy(req->r_data.io.r_file, fptr->f_path);
 833         req->r_data.io.r_oflags = ((sc->m_flags & SY_WRITE) ? O_WRONLY : O_RDONLY) | flags->m_value;
 834         req->r_data.io.r_offset = offset;
 835         req->r_data.io.r_uflags = (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
 836         req->r_data.io.r_aio_strat = (aio_strat==NULL) ? 0 : aio_strat->m_value;
 837         req->r_data.io.r_pattern = pattern;
 838
 839         /* multi-strided request...
 840          *  random number of strides (1...MaxStrides)
 841          *  length of stride must be > minlength
 842          *  length of stride must be % mult
 843          *
 844          * maxstrides = min(length / mult, overall.max#strides)
 845          * nstrides = random #
 846          * while( length / nstrides < minlength )
 847          *      nstrides = new random #
 848          */
 849         maxstride = length / mult;
 850         if(maxstride > Maxstrides)
 851             maxstride = Maxstrides;
 852
 853         if(!Minstrides)
 854                 Minstrides=1;
 855         nstrides = random_range(Minstrides, maxstride, 1, &errp);
 856         if (errp != NULL) {
 857             fprintf(stderr, "iogen%s:  random_range(%d, %d, %d) failed\n",
 858                     TagName, Minstrides, maxstride, 1);
 859             return -1;
 860         }
 861
 862         slength = length / nstrides;
 863         if(slength % mult != 0) {
 864             if( mult > slength) {
 865                 slength = mult;
 866             } else {
 867                 slength -= slength % mult;
 868             }
 869             nstrides = length / slength;
 870             if(nstrides > Maxstrides)
 871                     nstrides = Maxstrides;
 872         }
 873
 874         req->r_data.io.r_nbytes = slength;
 875         if( sc->m_flags & SY_NENT ) {
 876                 req->r_data.io.r_nstrides = 1;
 877                 req->r_data.io.r_nent = nstrides;
 878         } else {
 879                 req->r_data.io.r_nstrides = nstrides;
 880                 req->r_data.io.r_nent = 1;
 881         }
 882         break;
 883
 884     case LISTIO:
 885 #ifdef CRAY
 886         strcpy(req->r_data.listio.r_file, fptr->f_path);
 887         req->r_data.listio.r_offset = offset;
 888         req->r_data.listio.r_cmd = cmd;
 889         req->r_data.listio.r_aio_strat = (aio_strat==NULL) ? 0 : aio_strat->m_value;
 890         req->r_data.listio.r_filestride = 0;
 891         req->r_data.listio.r_memstride = 0;
 892         req->r_data.listio.r_opcode = opcode;
 893         req->r_data.listio.r_nstrides = 1;
 894         req->r_data.listio.r_nbytes = length;
 895         req->r_data.listio.r_uflags = (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
 896
 897         if (opcode == LO_WRITE) {
 898                 req->r_data.listio.r_pattern = pattern;
 899                 req->r_data.listio.r_oflags = O_WRONLY | flags->m_value;
 900         } else {
 901                 req->r_data.listio.r_oflags = O_RDONLY | flags->m_value;
 902         }
 903 #endif
 904         break;
 905     }
 906
 907     return 0;
 908 }
 909
 910 /*
 911  * Get information about a file that iogen uses to choose io length and
 912  * offset.  Information gathered is file length, iounit, and raw iounit.
 913  * For regurlar files, iounit is 1, and raw iounit is the iounit of the
 914  * device on which the file resides.  For block/character special files
 915  * the iounit and raw iounit are both the iounit of the device.
 916  *
 917  * Note:        buffered and osync io must be iounit aligned
 918  *              raw and ossd io must be raw iounit aligned
 919  */
 920
 921 int
 922 get_file_info(rec)
 923 struct file_info    *rec;
 924 {
 925     struct stat                 sbuf;
 926 #ifdef CRAY
 927     struct lk_device_info       dinfo;
 928 #endif
 929 #ifndef NO_XFS
 930     int                         fd;
 931     struct dioattr              finfo;
 932 #endif
 933
 934     /*
 935      * Figure out if the files is regular, block or character special.  Any
 936      * other type is an error.
 937      */
 938
 939     if (stat(rec->f_path, &sbuf) == -1) {
 940         fprintf(stderr, "iogen%s: get_file_info():  Could not stat() %s:  %s\n",
 941                 TagName, rec->f_path, SYSERR);
 942         return -1;
 943     }
 944
 945 #if _CRAY2
 946     if ((! S_ISREG(sbuf.st_mode)) || strncmp(rec->f_path, "/dev/", 5) == 0) {
 947         fprintf(stderr, "iogen%s:  device level io not supported on cray2\n", TagName);
 948         return -1;
 949     }
 950 #endif
 951
 952     rec->f_type = sbuf.st_mode & S_IFMT;
 953
 954     /*
 955      * If regular, iou is 1, and we must figure out the device on
 956      * which the file resides.  riou is the iou (logical sector size) of
 957      * this device.
 958      */
 959
 960     if (S_ISREG(sbuf.st_mode)) {
 961         rec->f_iou = 1;
 962         rec->f_length = sbuf.st_size;
 963
 964         /*
 965          * If -r used, take Rawmult as the raw/ssd io multiple.  Otherwise
 966          * attempt to determine it by looking at the device the file
 967          * resides on.
 968          */
 969
 970         if (r_opt) {
 971             rec->f_riou = Rawmult;
 972             return 0;
 973         }
 974
 975         rec->f_riou = BSIZE;
 976 #ifdef CRAY
 977         if (lk_rawdev(rec->f_path, dinfo.path, sizeof(dinfo.path), 0) == -1)
 978             return -1;
 979
 980         if (lk_devinfo(&dinfo, 0) == -1) {
 981             /* can't get raw I/O unit -- use stat to fudge it */
 982             rec->f_riou = sbuf.st_blksize;
 983         } else {
 984             rec->f_riou = ctob(dinfo.iou);
 985         }
 986 #endif
 987 #ifndef NO_XFS
 988         if( (fd = open(rec->f_path, O_RDWR|O_DIRECT, 0)) != -1 ) {
 989             if(xfsctl(rec->f_path, fd, XFS_IOC_DIOINFO, &finfo) != -1) {
 990                 rec->f_riou = finfo.d_miniosz;
 991             } else {
 992                 fprintf(stderr,
 993                         "iogen%s: Error %s (%d) getting direct I/O info of file %s\n",
 994                         TagName, strerror(errno), errno, rec->f_path);
 995             }
 996             close(fd);
 997         } else {
 998             rec->f_riou = BBSIZE;
 999         }
1000 #endif
1001
1002     } else {
1003
1004 #ifdef CRAY
1005         /*
1006          * Otherwise, file is a device.  Use lk_devinfo() to get its logical
1007          * sector size.  This is the iou and riou
1008          */
1009
1010         strcpy(dinfo.path, rec->f_path);
1011
1012         if (lk_devinfo(&dinfo, 0) == -1) {
1013             fprintf(stderr, "iogen%s: %s:  %s\n", TagName, Lk_err_func, Lk_err_mesg);
1014             return -1;
1015         }
1016
1017         rec->f_iou = ctob(dinfo.iou);
1018         rec->f_riou = ctob(dinfo.iou);
1019         rec->f_length = ctob(dinfo.length);
1020 #else
1021 #ifdef sgi
1022         rec->f_riou = BBSIZE;
1023         rec->f_length = BBSIZE;
1024 #else
1025         rec->f_riou = BSIZE;
1026         rec->f_length = BSIZE;
1027 #endif /* sgi */
1028 #endif /* CRAY */
1029     }
1030
1031     return 0;
1032 }
1033
1034 /*
1035  * Create file path as nbytes long.  If path exists, the file will either be
1036  * extended or truncated to be nbytes long.  Returns final size of file,
1037  * or -1 if there was a failure.
1038  */
1039
1040 int
1041 create_file(path, nbytes)
1042 char    *path;
1043 int     nbytes;
1044 {
1045     int         fd, rval;
1046     char        c;
1047     struct stat sbuf;
1048 #ifndef NO_XFS
1049     int         nb;
1050     struct xfs_flock64 f;
1051     struct fsxattr xattr;
1052     struct dioattr finfo;
1053     char        *b, *buf;
1054 #endif
1055
1056     errno = 0;
1057     rval = stat(path, &sbuf);
1058
1059     if (rval == -1) {
1060         if (errno == ENOENT) {
1061             sbuf.st_size = 0;
1062         } else {
1063             fprintf(stderr, "iogen%s:  Could not stat file %s:  %s (%d)\n",
1064                     TagName, path, SYSERR, errno);
1065             return -1;
1066         }
1067     } else {
1068         if (! S_ISREG(sbuf.st_mode)) {
1069             fprintf(stderr,
1070                     "iogen%s:  file %s exists, but is not a regular file - cannot modify length\n",
1071                     TagName, path);
1072             return -1;
1073         }
1074     }
1075
1076     if (sbuf.st_size == nbytes)
1077         return nbytes;
1078
1079     Oflags |= O_CREAT | O_WRONLY;
1080
1081     if ((fd = open(path, Oflags, 0666, Ocbits, Ocblks)) == -1) {
1082         fprintf(stderr, "iogen%s:  Could not create/open file %s: %s (%d)\n",
1083                 TagName, path, SYSERR, errno);
1084         return -1;
1085     }
1086
1087     /*
1088      * Truncate file if it is longer than nbytes, otherwise attempt to
1089      * pre-allocate file blocks.
1090      */
1091
1092     if (sbuf.st_size > nbytes) {
1093         if (ftruncate(fd, nbytes) == -1) {
1094             fprintf(stderr,
1095                     "iogen%s:  Could not ftruncate() %s to %d bytes:  %s (%d)\n",
1096                     TagName, path, nbytes, SYSERR, errno);
1097             close(fd);
1098             return -1;
1099         }
1100     } else {
1101
1102 #ifndef NO_XFS
1103         /*
1104          *  The file must be designated as Real-Time before any data
1105          *  is allocated to it.
1106          *
1107          */
1108         if(Orealtime != 0) {
1109             bzero(&xattr, sizeof(xattr));
1110             xattr.fsx_xflags = XFS_XFLAG_REALTIME;
1111             /*fprintf(stderr, "set: fsx_xflags = 0x%x\n", xattr.fsx_xflags);*/
1112             if( xfsctl(path, fd, XFS_IOC_FSSETXATTR, &xattr) == -1 ) {
1113                 fprintf(stderr, "iogen%s: Error %s (%d) setting XFS XATTR->Realtime on file %s\n",
1114                         TagName, SYSERR, errno, path);
1115                 close(fd);
1116                 return -1;
1117             }
1118
1119 #ifdef DEBUG
1120             if( xfsctl(path, fd, XFS_IOC_FSGETXATTR, &xattr) == -1 ) {
1121                 fprintf(stderr, "iogen%s: Error getting realtime flag %s (%d)\n",
1122                         TagName, SYSERR, errno);
1123                 close(fd);
1124                 return -1;
1125             } else {
1126                 fprintf(stderr, "get: fsx_xflags = 0x%x\n",
1127                         xattr.fsx_xflags);
1128             }
1129 #endif
1130         }
1131
1132         /*
1133          * Reserve space
1134          *
1135          * Failure is ignored since XFS_IOC_RESVSP only works on XFS and the
1136          * filesystem could be on some otehr filesystem.
1137          */
1138         if( Oreserve ) {
1139             f.l_whence = SEEK_SET;
1140             f.l_start = 0;
1141             f.l_len = nbytes;
1142
1143             /*fprintf(stderr,
1144                     "create_file: xfsctl(%d, RESVSP, { %d, %lld, %lld })\n",
1145                    fd, f.l_whence, (long long)f.l_start, (long long)f.l_len);*/
1146
1147             /* non-zeroing reservation */
1148             if( xfsctl( path, fd, XFS_IOC_RESVSP, &f ) == -1) {
1149                 fprintf(stderr,
1150                         "iogen%s:  Could not xfsctl(XFS_IOC_RESVSP) %d bytes in file %s: %s (%d)\n",
1151                         TagName, nbytes, path, SYSERR, errno);
1152                 close(fd);
1153                 return -1;
1154             }
1155         }
1156
1157         if( Oallocate ) {
1158             /* XFS_IOC_ALLOCSP allocates from the file start to l_start */
1159             f.l_whence = SEEK_SET;
1160             f.l_start = nbytes;
1161             f.l_len = 0;
1162             /*fprintf(stderr,
1163                     "create_file: xfsctl(%d, XFS_IOC_ALLOCSP, { %d, %lld, %lld })\n",
1164                     fd, f.l_whence, (long long)f.l_start,
1165                     (long long)f.l_len);*/
1166
1167             /* zeroing reservation */
1168             if( xfsctl( path, fd, XFS_IOC_ALLOCSP, &f ) == -1) {
1169                 fprintf(stderr,
1170                         "iogen%s:  Could not xfsctl(XFS_IOC_ALLOCSP) %d bytes in file %s: %s (%d)\n",
1171                         TagName, nbytes, path, SYSERR, errno);
1172                 close(fd);
1173                 return -1;
1174             }
1175         }
1176 #endif
1177
1178         /*
1179          * Write a byte at the end of file so that stat() sets the right
1180          * file size.
1181          */
1182
1183 #ifndef NO_XFS
1184         if(Owrite == 2) {
1185             close(fd);
1186             if( (fd = open(path, O_CREAT|O_RDWR|O_DIRECT, 0)) != -1 ) {
1187                 if(xfsctl(path, fd, XFS_IOC_DIOINFO, &finfo) == -1) {
1188                     fprintf(stderr,
1189                             "iogen%s: Error %s (%d) getting direct I/O info for file %s\n",
1190                             TagName, SYSERR, errno, path);
1191                     return -1;
1192                 } else {
1193                     /*fprintf(stderr, "%s: miniosz=%d\n",
1194                             path, finfo.d_miniosz);*/
1195                 }
1196             } else {
1197                 fprintf(stderr, "iogen%s: Error %s (%d) opening file %s with flags O_CREAT|O_RDWR|O_DIRECT\n",
1198                         TagName, SYSERR, errno, path);
1199                 return -1;
1200             }
1201
1202             /*
1203              * nb is nbytes adjusted down by an even d_miniosz block
1204              *
1205              * Note: the first adjustment can cause iogen to print a warning
1206              *  about not being able to create a file of <nbytes> length,
1207              *  since the file will be shorter.
1208              */
1209             nb = nbytes-finfo.d_miniosz;
1210             nb = nb-nb%finfo.d_miniosz;
1211
1212             /*fprintf(stderr,
1213                     "create_file_ow2: lseek(%d, %d {%d %d}, SEEK_SET)\n",
1214                     fd, nb, nbytes, finfo.d_miniosz);*/
1215
1216             if (lseek(fd, nb, SEEK_SET) == -1) {
1217                 fprintf(stderr,
1218                         "iogen%s:  Could not lseek() to EOF of file %s: %s (%d)\n\tactual offset %d file size goal %d miniosz %lld\n",
1219                         TagName, path, SYSERR, errno,
1220                         nb, nbytes, (long long)finfo.d_miniosz);
1221                 close(fd);
1222                 return -1;
1223             }
1224
1225             b = buf = (char *)malloc(finfo.d_miniosz+finfo.d_mem);
1226
1227             if( ((long)buf % finfo.d_mem != 0) ) {
1228                 buf += finfo.d_mem - ((long)buf % finfo.d_mem);
1229             }
1230
1231             memset(buf, 0, finfo.d_miniosz);
1232
1233             if ( (rval=write(fd, buf, finfo.d_miniosz)) != finfo.d_miniosz) {
1234                 fprintf(stderr,
1235                         "iogen%s:  Could not write %d byte length file %s: %s (%d)\n",
1236                         TagName, nb, path, SYSERR, errno);
1237                 fprintf(stderr,
1238                         "\twrite(%d, 0x%lx, %d) = %d\n",
1239                         fd, (long)buf, finfo.d_miniosz, rval);
1240                 fprintf(stderr,
1241                         "\toffset %d file size goal %d, miniosz=%d\n",
1242                         nb, nbytes, finfo.d_miniosz);
1243                 close(fd);
1244                 return -1;
1245             }
1246             free(b);
1247         } else
1248 #endif
1249             if(Owrite) {
1250             /*fprintf(stderr,
1251                     "create_file_Owrite: lseek(%d, %d {%d}, SEEK_SET)\n",
1252                     fd, nbytes-1, nbytes);*/
1253
1254             if (lseek(fd, nbytes-1, SEEK_SET) == -1) {
1255                 fprintf(stderr,
1256                         "iogen%s:  Could not lseek() to EOF in file %s:  %s (%d)\n\toffset goal %d\n",
1257                         TagName, path, SYSERR, errno,
1258                         nbytes-1);
1259                 close(fd);
1260                 return -1;
1261             }
1262
1263             if ( (rval=write(fd, &c, 1)) != 1) {
1264                 fprintf(stderr,
1265                         "iogen%s:  Could not create a %d byte length file %s: %s (%d)\n",
1266                         TagName, nbytes, path, SYSERR, errno);
1267                 fprintf(stderr,
1268                         "\twrite(%d, 0x%lx, %d) = %d\n",
1269                         fd, (long)&c, 1, rval);
1270                 fprintf(stderr,
1271                         "\toffset %d file size goal %d\n",
1272                         nbytes-1, nbytes);
1273                 close(fd);
1274                 return -1;
1275             }
1276         }
1277     }
1278
1279     fstat(fd, &sbuf);
1280     close(fd);
1281
1282     return sbuf.st_size;
1283 }
1284
1285 /*
1286  * Function to convert a string to its corresponding value in a strmap array.
1287  * If the string is not found in the array, the value corresponding to the
1288  * NULL string (the last element in the array) is returned.
1289  */
1290
1291 int
1292 str_to_value(map, str)
1293 struct strmap   *map;
1294 char            *str;
1295 {
1296     struct strmap   *mp;
1297
1298     for (mp = map; mp->m_string != NULL; mp++)
1299         if (strcmp(mp->m_string, str) == 0)
1300             break;
1301
1302     return mp->m_value;
1303 }
1304
1305 /*
1306  * Function to convert a string to its corresponding entry in a strmap array.
1307  * If the string is not found in the array, a NULL is returned.
1308  */
1309
1310 struct strmap *
1311 str_lookup(map, str)
1312 struct strmap   *map;
1313 char            *str;
1314 {
1315     struct strmap   *mp;
1316
1317     for (mp = map; mp->m_string != NULL; mp++)
1318         if (strcmp(mp->m_string, str) == 0)
1319             break;
1320
1321     return((mp->m_string == NULL) ? NULL : mp);
1322 }
1323
1324
1325 /*
1326  * Function to convert a value to its corresponding string in a strmap array.
1327  * If the value is not found in the array, NULL is returned.
1328  */
1329
1330 char *
1331 value_to_string(map, val)
1332 struct strmap   *map;
1333 int             val;
1334 {
1335     struct strmap  *mp;
1336
1337     for (mp = map; mp->m_string != NULL; mp++)
1338         if (mp->m_value == val)
1339             break;
1340
1341     return mp->m_string;
1342 }
1343
1344 /*
1345  * Interpret cmdline options/arguments.  Exit with 1 if something on the
1346  * cmdline isn't kosher.
1347  */
1348
1349 int
1350 parse_cmdline(argc, argv, opts)
1351 int     argc;
1352 char    **argv;
1353 char    *opts;
1354 {
1355     int                 o, len, nb, format_error;
1356     struct strmap       *flgs, *sc;
1357     char                *file, *cp, ch;
1358     struct strmap       *mp;
1359     struct file_info    *fptr;
1360     int                 nopenargs;
1361     char                *openargs[5];   /* Flags, cbits, cblks */
1362 #ifdef CRAY
1363     char                *errmsg;
1364     char                *ranges;
1365     struct strmap       *type;
1366 #endif
1367
1368     while ((o = getopt(argc, argv, opts)) != EOF) {
1369         switch ((char)o) {
1370
1371         case 'a':
1372 #ifndef CRAY
1373             fprintf(stderr, "iogen%s:  Unrecognized option -a on this platform\n", TagName);
1374             exit(2);
1375 #else
1376             cp = strtok(optarg, ",");
1377             while (cp != NULL) {
1378                 if ((type = str_lookup(Aio_Strat_Map, cp)) == NULL) {
1379                     fprintf(stderr, "iogen%s:  Unrecognized aio completion strategy:  %s\n", TagName, cp);
1380                     exit(2);
1381                 }
1382
1383                 Aio_Strat_List[Naio_Strat_Types++] = type;
1384                 cp = strtok(NULL, ",");
1385             }
1386             a_opt++;
1387 #endif
1388             break;
1389
1390         case 'f':
1391             cp = strtok(optarg, ",");
1392             while (cp != NULL) {
1393                 if( (flgs = str_lookup(Flag_Map, cp)) == NULL ) {
1394                     fprintf(stderr, "iogen%s:  Unrecognized flags:  %s\n", TagName, cp);
1395                     exit(2);
1396                 }
1397
1398                 cp = strtok(NULL, ",");
1399
1400 #ifdef O_SSD
1401                 if (flgs->m_value & O_SSD && ! Sds_Avail) {
1402                     fprintf(stderr, "iogen%s:  Warning - no sds available, ignoring ssd flag\n", TagName);
1403                     continue;
1404                 }
1405 #endif
1406
1407                 Flag_List[Nflags++] = flgs;
1408             }
1409             f_opt++;
1410             break;
1411
1412         case 'h':
1413             help(stdout);
1414             exit(0);
1415             break;
1416
1417         case 'i':
1418             format_error = 0;
1419
1420             switch (sscanf(optarg, "%i%c", &Iterations, &ch)) {
1421             case 1:
1422                 Time_Mode = 0;
1423                 break;
1424
1425             case 2:
1426                 if (ch == 's')
1427                     Time_Mode = 1;
1428                 else
1429                     format_error = 1;
1430                 break;
1431
1432             default:
1433                 format_error = 1;
1434             }
1435
1436             if (Iterations < 0)
1437                 format_error = 1;
1438
1439             if (format_error) {
1440                 fprintf(stderr, "iogen%s:  Illegal -i arg (%s):  Must be of the format:  number[s]\n", TagName, optarg);
1441                 fprintf(stderr, "        where 'number' is >= 0\n");
1442                 exit(1);
1443             }
1444
1445             i_opt++;
1446             break;
1447
1448         case 'L':
1449 #ifndef CRAY
1450             fprintf(stderr, "iogen%s:  Unrecognized option -L on this platform\n", TagName);
1451             exit(2);
1452 #else
1453             if( parse_ranges(optarg, 1, 255, 1, NULL, &ranges,
1454                              &errmsg ) == -1 ) {
1455                     fprintf(stderr, "iogen%s: error parsing listio range '%s': %s\n",
1456                             TagName, optarg, errmsg);
1457                     exit(1);
1458             }
1459
1460             Minstrides = range_min(ranges, 0);
1461             Maxstrides = range_max(ranges, 0);
1462
1463             free(ranges);
1464             L_opt++;
1465 #endif
1466             break;
1467
1468         case 'm':
1469             if ((Offset_Mode = str_lookup(Omode_Map, optarg)) == NULL) {
1470                 fprintf(stderr, "iogen%s:  Illegal -m arg (%s)\n", TagName, optarg);
1471                 exit(1);
1472             }
1473
1474             m_opt++;
1475             break;
1476
1477         case 'N':
1478             sprintf( TagName, "(%.39s)", optarg );
1479             break;
1480
1481         case 'o':
1482             o_opt++;
1483             break;
1484
1485         case 'O':
1486
1487             nopenargs = string_to_tokens(optarg, openargs, 4, ":/");
1488
1489 #ifdef CRAY
1490             if(nopenargs)
1491                 sscanf(openargs[1],"%i", &Ocbits);
1492             if(nopenargs > 1)
1493                 sscanf(openargs[2],"%i", &Ocblks);
1494
1495             Oflags = parse_open_flags(openargs[0], &errmsg);
1496             if(Oflags == -1) {
1497                 fprintf(stderr, "iogen%s: -O %s error: %s\n", TagName, optarg, errmsg);
1498                 exit(1);
1499             }
1500 #endif
1501 #ifndef NO_XFS
1502             if(!strcmp(openargs[0], "realtime")) {
1503                 /*
1504                  * -O realtime:extsize
1505                  */
1506                 Orealtime = 1;
1507                 if(nopenargs > 1)
1508                     sscanf(openargs[1],"%i", &Oextsize);
1509                 else
1510                     Oextsize=0;
1511             } else if( !strcmp(openargs[0], "allocate") ||
1512                        !strcmp(openargs[0], "allocsp")) {
1513                 /*
1514                  * -O allocate
1515                  */
1516                 Oreserve=0;
1517                 Oallocate=1;
1518             } else if(!strcmp(openargs[0], "reserve")) {
1519                 /*
1520                  * -O [no]reserve
1521                  */
1522                 Oallocate=0;
1523                 Oreserve=1;
1524             } else if(!strcmp(openargs[0], "noreserve")) {
1525                 /* Oreserve=1 by default; this clears that default */
1526                 Oreserve=0;
1527             } else if(!strcmp(openargs[0], "nowrite")) {
1528                 /* Owrite=1 by default; this clears that default */
1529                 Owrite=0;
1530             } else if(!strcmp(openargs[0], "direct")) {
1531                 /* this means "use direct i/o to preallocate file" */
1532                 Owrite=2;
1533             } else {
1534                 fprintf(stderr, "iogen%s: Error: -O %s error: unrecognized option\n",
1535                         TagName, openargs[0]);
1536                 exit(1);
1537             }
1538 #else
1539             Oflags = parse_open_flags(openargs[0], &errmsg);
1540             if(Oflags == -1) {
1541                 fprintf(stderr, "iogen%s: -O %s error: %s\n", TagName, optarg, errmsg);
1542                 exit(1);
1543             }
1544 #endif
1545
1546             O_opt++;
1547             break;
1548
1549         case 'p':
1550             Outpipe = optarg;
1551             p_opt++;
1552             break;
1553
1554         case 'r':
1555             if ((Rawmult = str_to_bytes(optarg)) == -1 ||
1556                           Rawmult < 11 || Rawmult % BSIZE) {
1557                 fprintf(stderr, "iogen%s:  Illegal -r arg (%s).  Must be > 0 and multipe of BSIZE (%d)\n",
1558                         TagName, optarg, BSIZE);
1559                 exit(1);
1560             }
1561
1562             r_opt++;
1563             break;
1564
1565         case 's':
1566             cp = strtok(optarg, ",");
1567             while (cp != NULL) {
1568                 if ((sc = str_lookup(Syscall_Map, cp)) == NULL) {
1569                     fprintf(stderr, "iogen%s:  Unrecognized syscall:  %s\n", TagName, cp);
1570                     exit(2);
1571                 }
1572
1573                 do {
1574                     /* >>> sc->m_flags & FLG_SDS */
1575                     if (sc->m_value != SSREAD && sc->m_value != SSWRITE)
1576                         Fileio++;
1577
1578                     Syscall_List[Nsyscalls++] = sc;
1579                 } while ( (sc = str_lookup(++sc, cp)) != NULL);
1580
1581                 cp = strtok(NULL, ",");
1582             }
1583             s_opt++;
1584             break;
1585
1586         case 't':
1587             if ((Mintrans = str_to_bytes(optarg)) == -1) {
1588                 fprintf(stderr, "iogen%s:  Illegal -t arg (%s):  Must have the form num[bkm]\n", TagName, optarg);
1589                 exit(1);
1590             }
1591             t_opt++;
1592             break;
1593
1594         case 'T':
1595             if ((Maxtrans = str_to_bytes(optarg)) == -1) {
1596                 fprintf(stderr, "iogen%s:  Illegal -T arg (%s):  Must have the form num[bkm]\n", TagName, optarg);
1597                 exit(1);
1598             }
1599             T_opt++;
1600             break;
1601
1602         case 'q':
1603             q_opt++;
1604             break;
1605
1606         case '?':
1607             usage(stderr);
1608             exit(1);
1609         }
1610     }
1611
1612     /*
1613      * Supply defaults
1614      */
1615
1616     if( ! L_opt ) {
1617             Minstrides = 1;
1618             Maxstrides = 255;
1619     }
1620
1621     if (! m_opt)
1622         Offset_Mode = str_lookup(Omode_Map, "sequential");
1623
1624     if (! i_opt)
1625         Iterations = 0;
1626
1627     if (! t_opt)
1628         Mintrans = 1;
1629
1630     if (! T_opt)
1631         Maxtrans = 256 * BSIZE;
1632
1633     if( ! O_opt)
1634         Oflags = Ocbits = Ocblks = 0;
1635
1636     /*
1637      * Supply default async io completion strategy types.
1638      */
1639
1640     if (! a_opt) {
1641             for (mp = Aio_Strat_Map; mp->m_string != NULL; mp++) {
1642                     Aio_Strat_List[Naio_Strat_Types++] = mp;
1643             }
1644     }
1645
1646     /*
1647      * Supply default syscalls.  Default is read,write,reada,writea,listio.
1648      */
1649
1650     if (! s_opt) {
1651         Nsyscalls = 0;
1652         Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "read");
1653         Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "write");
1654 #ifdef CRAY
1655         Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "reada");
1656         Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "writea");
1657         Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "lread");
1658         Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "lreada");
1659         Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "lwrite");
1660         Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "lwritea");
1661 #endif
1662
1663         Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "pread");
1664         Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "pwrite");
1665 #ifdef sgi
1666         /*Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "aread");*/
1667         /*Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "awrite");*/
1668 #endif
1669
1670 #ifndef CRAY
1671         Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "readv");
1672         Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "writev");
1673         Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "mmread");
1674         Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "mmwrite");
1675 #endif
1676
1677         Fileio = 1;
1678     }
1679
1680     if (Fileio && (argc - optind < 1)) {
1681         fprintf(stderr, "iogen%s:  No files specified on the cmdline\n", TagName);
1682         exit(1);
1683     }
1684
1685     /*
1686      * Supply default file io flags - defaut is 'buffered,raw,sync,ldraw'.
1687      */
1688
1689     if (! f_opt && Fileio) {
1690             Nflags = 0;
1691             Flag_List[Nflags++] = str_lookup(Flag_Map, "buffered");
1692             Flag_List[Nflags++] = str_lookup(Flag_Map, "sync");
1693 #ifdef CRAY
1694             Flag_List[Nflags++] = str_lookup(Flag_Map, "raw+wf");
1695             Flag_List[Nflags++] = str_lookup(Flag_Map, "ldraw");
1696 #endif
1697
1698 #ifdef sgi
1699             /* Warning: cannot mix direct i/o with others! */
1700             Flag_List[Nflags++] = str_lookup(Flag_Map, "dsync");
1701             Flag_List[Nflags++] = str_lookup(Flag_Map, "rsync");
1702             /* Flag_List[Nflags++] = str_lookup(Flag_Map, "rsync+sync");*/
1703             /* Flag_List[Nflags++] = str_lookup(Flag_Map, "rsync+dsync");*/
1704 #endif
1705     }
1706
1707     if (Fileio) {
1708         if (optind >= argc) {
1709             fprintf(stderr, "iogen%s:  No files listed on the cmdline\n", TagName);
1710             exit(1);
1711         }
1712
1713         /*
1714          * Initialize File_List[] - only necessary if doing file io.  First
1715          * space for the File_List array, then fill it in.
1716          */
1717
1718         File_List = (struct file_info *)
1719             malloc((argc-optind) * sizeof(struct file_info));
1720
1721         if (File_List == NULL) {
1722             fprintf(stderr, "iogen%s:  Could not malloc space for %d file_info structures\n", TagName, argc-optind);
1723             exit(2);
1724         }
1725
1726         memset(File_List, 0, (argc-optind) * sizeof(struct file_info));
1727
1728         Nfiles = 0;
1729         while (optind < argc) {
1730             len = -1;
1731
1732             /*
1733              * Pick off leading len: if it's there and create/extend/trunc
1734              * the file to the desired length.  Otherwise, just make sure
1735              * the file is accessable.
1736              */
1737
1738             if ((cp = strchr(argv[optind], ':')) != NULL) {
1739                 *cp = '\0';
1740                 if ((len = str_to_bytes(argv[optind])) == -1) {
1741                     fprintf(stderr,
1742                             "iogen%s:  illegal file length (%s) for file %s\n",
1743                             TagName, argv[optind], cp+1);
1744                     exit(2);
1745                 }
1746                 *cp = ':';
1747                 file = cp+1;
1748
1749                 if (strlen(file) > MAX_FNAME_LENGTH) {
1750                     fprintf(stderr, "iogen%s:  Max fname length is %d chars - ignoring file %s\n",
1751                             TagName, MAX_FNAME_LENGTH, file);
1752                     optind++;
1753                     continue;
1754                 }
1755
1756                 nb = create_file(file, len);
1757
1758                 if (nb < len) {
1759                     fprintf(stderr,
1760                             "iogen%s warning:  Couldn't create file %s of %d bytes\n",
1761                             TagName, file, len);
1762
1763                     if (nb <= 0) {
1764                         optind++;
1765                         continue;
1766                     }
1767                 }
1768             } else {
1769                 file = argv[optind];
1770                 if (access(file, R_OK | W_OK) == -1) {
1771                     fprintf(stderr, "iogen%s:  file %s cannot be accessed for reading and/or writing:  %s (%d)\n",
1772                             TagName, file, SYSERR, errno);
1773                     exit(2);
1774                 }
1775             }
1776
1777             /*
1778              * get per-file information
1779              */
1780
1781             fptr = &File_List[Nfiles];
1782
1783             if (file[0] == '/') {
1784                 strcpy(fptr->f_path, file);
1785             } else {
1786                 getcwd(fptr->f_path,
1787                        sizeof(fptr->f_path)-1);
1788                 strcat(fptr->f_path, "/");
1789                 strcat(fptr->f_path, file);
1790             }
1791
1792             if (get_file_info(fptr) == -1) {
1793                 fprintf(stderr, "iogen%s warning:  Error getting file info for %s\n", TagName, file);
1794             } else {
1795
1796                 /*
1797                  * If the file length is smaller than our min transfer size,
1798                  * ignore it.
1799                  */
1800
1801                 if (fptr->f_length < Mintrans) {
1802                     fprintf(stderr, "iogen%s warning:  Ignoring file %s\n",
1803                             TagName, fptr->f_path);
1804                     fprintf(stderr, "                length (%d) is < min transfer size (%d)\n",
1805                             fptr->f_length, Mintrans);
1806                     optind++;
1807                     continue;
1808                 }
1809
1810                 /*
1811                  * If the file length is smaller than our max transfer size,
1812                  * ignore it.
1813                  */
1814
1815                 if (fptr->f_length < Maxtrans) {
1816                     fprintf(stderr, "iogen%s warning:  Ignoring file %s\n",
1817                             TagName, fptr->f_path);
1818                     fprintf(stderr, "                length (%d) is < max transfer size (%d)\n",
1819                             fptr->f_length, Maxtrans);
1820                     optind++;
1821                     continue;
1822                 }
1823
1824                 if (fptr->f_length > 0) {
1825                     switch (Offset_Mode->m_value) {
1826                     case M_SEQUENTIAL:
1827                         fptr->f_lastoffset = 0;
1828                         fptr->f_lastlength = 0;
1829                         break;
1830
1831                     case M_REVERSE:
1832                         fptr->f_lastoffset = fptr->f_length;
1833                         fptr->f_lastlength = 0;
1834                         break;
1835
1836                     case M_RANDOM:
1837                         fptr->f_lastoffset = fptr->f_length / 2;
1838                         fptr->f_lastlength = 0;
1839                         break;
1840                     }
1841
1842                     Nfiles++;
1843                 }
1844             }
1845
1846             optind++;
1847         }
1848
1849         if (Nfiles == 0) {
1850             fprintf(stderr, "iogen%s:  Could not create, or gather info for any test files\n", TagName);
1851             exit(2);
1852         }
1853     }
1854
1855     return 0;
1856 }
1857
1858 int
1859 help(stream)
1860 FILE    *stream;
1861 {
1862     usage(stream);
1863     fprintf(stream, "\n");
1864 #ifndef linux
1865     fprintf(stream, "\t-a aio_type,...  Async io completion types to choose.  Supported types\n");
1866 #ifdef CRAY
1867 #if _UMK || RELEASE_LEVEL >= 8000
1868     fprintf(stream, "\t                 are:  poll, signal, recall, recalla, and recalls.\n");
1869 #else
1870     fprintf(stream, "\t                 are:  poll, signal, recalla, and recalls.\n");
1871 #endif
1872 #else
1873     fprintf(stream, "\t                 are:  poll, signal, suspend, and callback.\n");
1874 #endif
1875     fprintf(stream, "\t                 Default is all of the above.\n");
1876 #else /* !linux */
1877     fprintf(stream, "\t-a               (Not used on Linux).\n");
1878 #endif /* !linux */
1879     fprintf(stream, "\t-f flag,...      Flags to use for file IO.  Supported flags are\n");
1880 #ifdef CRAY
1881     fprintf(stream, "\t                 raw, ssd, buffered, ldraw, sync,\n");
1882     fprintf(stream, "\t                 raw+wf, raw+wf+ldraw, raw+wf+ldraw+sync,\n");
1883     fprintf(stream, "\t                 and parallel (unicos/mk on MPP only).\n");
1884     fprintf(stream, "\t                 Default is 'raw,ldraw,sync,buffered'.\n");
1885 #else
1886 #ifndef NO_XFS
1887     fprintf(stream, "\t                 buffered, direct, sync.\n");
1888     fprintf(stream, "\t                 Default is 'buffered,sync'.\n");
1889 #else
1890     fprintf(stream, "\t                 buffered, sync.\n");
1891     fprintf(stream, "\t                 Default is 'buffered,sync'.\n");
1892 #endif /* sgi */
1893 #endif /* CRAY */
1894     fprintf(stream, "\t-h               This help.\n");
1895     fprintf(stream, "\t-i iterations[s] # of requests to generate.  0 means causes iogen\n");
1896     fprintf(stream, "\t                 to run until it's killed.  If iterations is suffixed\n");
1897     fprintf(stream, "\t                 with 's', then iterations is the number of seconds\n");
1898     fprintf(stream, "\t                 that iogen should run for.  Default is '0'.\n");
1899 #ifndef CRAY
1900     fprintf(stream, "\t-L min:max       listio nstrides / nrequests range\n");
1901 #else
1902     fprintf(stream, "\t-L               (Not used on this platform).\n");
1903 #endif /* !CRAY */
1904     fprintf(stream, "\t-m offset-mode   The mode by which iogen chooses the offset for\n");
1905     fprintf(stream, "\t                 consectutive transfers within a given file.\n");
1906     fprintf(stream, "\t                 Allowed values are 'random', 'sequential',\n");
1907     fprintf(stream, "\t                 and 'reverse'.\n");
1908     fprintf(stream, "\t                 sequential is the default.\n");
1909     fprintf(stream, "\t-N tagname       Tag name, for Monster.\n");
1910     fprintf(stream, "\t-o               Form overlapping consecutive requests.\n");
1911     fprintf(stream, "\t-O               Open flags for creating files\n");
1912 #ifdef CRAY
1913     fprintf(stream, "\t                 {O_PLACE,O_BIG,etc}[:CBITS[:CBLKS]]\n");
1914 #endif
1915 #ifndef NO_XFS
1916     fprintf(stream, "\t                 realtime:extsize - put file on real-time volume\n");
1917     fprintf(stream, "\t                 allocate - allocate space with F_ALLOCSP\n");
1918     fprintf(stream, "\t                 reserve - reserve space with F_RESVSP (default)\n");
1919     fprintf(stream, "\t                 noreserve - do not reserve with F_RESVSP\n");
1920     fprintf(stream, "\t                 direct - use O_DIRECT I/O to write to the file\n");
1921 #else
1922     fprintf(stream, "\t                 {O_SYNC,etc}\n");
1923 #endif
1924     fprintf(stream, "\t-p               Output pipe.  Default is stdout.\n");
1925     fprintf(stream, "\t-q               Quiet mode.  Normally iogen spits out info\n");
1926     fprintf(stream, "\t                 about test files, options, etc. before starting.\n");
1927     fprintf(stream, "\t-s syscall,...   Syscalls to do.  Supported syscalls are\n");
1928 #ifdef sgi
1929     fprintf(stream, "\t                 read, write, pread, pwrite, readv, writev\n");
1930     fprintf(stream, "\t                 aread, awrite, resvsp, unresvsp, ffsync,\n");
1931     fprintf(stream, "\t                 mmread, mmwrite, fsync2, fdatasync,\n");
1932     fprintf(stream, "\t                 Default is 'read,write,pread,pwrite,readv,writev,mmread,mmwrite'.\n");
1933 #endif
1934 #ifdef CRAY
1935     fprintf(stream, "\t                 read, write, reada, writea, listio,\n");
1936     fprintf(stream, "\t                 ssread (PVP only), and sswrite (PVP only).\n");
1937     fprintf(stream, "\t                 Default is 'read,write,reada,writea,listio'.\n");
1938 #endif
1939 #ifdef linux
1940     fprintf(stream, "\t                 read, write, pread, pwrite, readv, writev,\n");
1941     fprintf(stream, "\t                 mmread, mmwrite, fsync2, fdatasync,\n");
1942     fprintf(stream, "\t                 Default is 'read,write,readv,writev,mmread,mmwrite'.\n");
1943 #endif
1944     fprintf(stream, "\t-t mintrans      Min transfer length\n");
1945     fprintf(stream, "\t-T maxtrans      Max transfer length\n");
1946     fprintf(stream, "\n");
1947     fprintf(stream, "\t[len:]file,...   Test files to do IO against (note ssread/sswrite\n");
1948     fprintf(stream, "\t                 don't need a test file).  The len: syntax\n");
1949     fprintf(stream, "\t                 informs iogen to first create/expand/truncate the\n");
1950     fprintf(stream, "\t                 to the desired length.\n");
1951     fprintf(stream, "\n");
1952     fprintf(stream, "\tNote:  The ssd flag causes sds transfers to also be done.\n");
1953     fprintf(stream, "\t       To totally eliminate sds transfers, you must eleminate sds\n");
1954     fprintf(stream, "\t       from the flags (-f) and ssread,ssrite from the syscalls (-s)\n");
1955     fprintf(stream, "\tThe mintrans, maxtrans, and len: parameters are numbers of the\n");
1956     fprintf(stream, "\tform [0-9]+[bkm].  The optional trailing b, k, or m multiplies\n");
1957     fprintf(stream, "\tthe number by blocks, kilobytes, or megabytes.  If no trailing\n");
1958     fprintf(stream, "\tmultiplier is present, the number is interpreted as bytes\n");
1959
1960     return 0;
1961 }
1962
1963 /*
1964  * Obvious - usage clause
1965  */
1966
1967 int
1968 usage(stream)
1969 FILE    *stream;
1970 {
1971     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);
1972     return 0;
1973 }