xfstests: remove unused conditional NO_XFS
[xfstests-dev.git] / ltp / doio.c
1 /*
2  * Copyright (c) 2000 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
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.
8  *
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.
13  *
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
17  */
18 /*
19  * doio -       a general purpose io initiator with system call and
20  *              write logging.  See doio.h for the structure which defines
21  *              what doio requests should look like.
22  *
23  * programming
24  * notes:
25  * -----------
26  *      messages should generally be printed using doio_fprintf().
27  *
28  */
29
30 #include "global.h"
31
32 #include <sys/uio.h>    /* for struct iovec (readv)*/
33 #include <sys/mman.h>   /* for mmap(2) */
34 #include <sys/ipc.h>    /* for i/o buffer in shared memory */
35 #include <sys/shm.h>    /* for i/o buffer in shared memory */
36 #include <sys/wait.h>
37 #include <sys/time.h>   /* for delays */
38 #include <ctype.h>
39
40 struct io_req;
41 int do_xfsctl(struct io_req *);
42
43 #include "doio.h"
44 #include "pattern.h"
45 #include "write_log.h"
46 #include "random_range.h"
47 #include "string_to_tokens.h"
48
49 #ifndef O_SSD
50 #define O_SSD 0                /* so code compiles on a CRAY2 */
51 #endif
52
53 #define UINT64_T unsigned long long
54
55 #ifndef O_PARALLEL
56 #define O_PARALLEL 0    /* so O_PARALLEL may be used in expressions */
57 #endif
58
59 #define PPID_CHECK_INTERVAL 5           /* check ppid every <-- iterations */
60 #define MAX_AIO         256             /* maximum number of async I/O ops */
61 #define MPP_BUMP        0
62
63
64 #define SYSERR strerror(errno)
65
66 /*
67  * getopt() string of supported cmdline arguments.
68  */
69
70 #define OPTS    "aC:d:ehm:n:kr:w:vU:V:M:N:"
71
72 #define DEF_RELEASE_INTERVAL    0
73
74 /*
75  * Flags set in parse_cmdline() to indicate which options were selected
76  * on the cmdline.
77  */
78
79 int     a_opt = 0;          /* abort on data compare errors     */
80 int     e_opt = 0;          /* exec() after fork()'ing          */
81 int     C_opt = 0;          /* Data Check Type                  */
82 int     d_opt = 0;          /* delay between operations         */
83 int     k_opt = 0;          /* lock file regions during writes  */
84 int     m_opt = 0;          /* generate periodic messages       */
85 int     n_opt = 0;          /* nprocs                           */
86 int     r_opt = 0;          /* resource release interval        */
87 int     w_opt = 0;          /* file write log file              */
88 int     v_opt = 0;          /* verify writes if set             */
89 int     U_opt = 0;          /* upanic() on varios conditions    */
90 int     V_opt = 0;          /* over-ride default validation fd type */
91 int     M_opt = 0;          /* data buffer allocation types     */
92 char    TagName[40];        /* name of this doio (see Monster)  */
93
94
95 /*
96  * Misc globals initialized in parse_cmdline()
97  */
98
99 char    *Prog = NULL;       /* set up in parse_cmdline()                */
100 int     Upanic_Conditions;  /* set by args to -U                        */
101 int     Release_Interval;   /* arg to -r                                */
102 int     Nprocs;             /* arg to -n                                */
103 char    *Write_Log;         /* arg to -w                                */
104 char    *Infile;            /* input file (defaults to stdin)           */
105 int     *Children;          /* pids of child procs                      */
106 int     Nchildren = 0;
107 int     Nsiblings = 0;      /* tfork'ed siblings                        */
108 int     Execd = 0;
109 int     Message_Interval = 0;
110 int     Npes = 0;           /* non-zero if built as an mpp multi-pe app */
111 int     Vpe = -1;           /* Virtual pe number if Npes >= 0           */
112 int     Reqno = 1;          /* request # - used in some error messages  */
113 int     Reqskipcnt = 0;     /* count of I/O requests that are skipped   */
114 int     Validation_Flags;
115 char    *(*Data_Check)();   /* function to call for data checking       */
116 int     (*Data_Fill)();     /* function to call for data filling        */
117 int     Nmemalloc = 0;      /* number of memory allocation strategies   */
118 int     delayop = 0;        /* delay between operations - type of delay */
119 int     delaytime = 0;      /* delay between operations - how long      */
120
121 struct wlog_file        Wlog;
122
123 int     active_mmap_rw = 0; /* Indicates that mmapped I/O is occurring. */
124                             /* Used by sigbus_action() in the child doio. */
125 int     havesigint = 0;
126
127 #define SKIP_REQ        -2      /* skip I/O request */
128
129 #define NMEMALLOC       32
130 #define MEM_DATA        1       /* data space                           */
131 #define MEM_SHMEM       2       /* System V shared memory               */
132 #define MEM_T3ESHMEM    3       /* T3E Shared Memory                    */
133 #define MEM_MMAP        4       /* mmap(2)                              */
134
135 #define MEMF_PRIVATE    0001
136 #define MEMF_AUTORESRV  0002
137 #define MEMF_LOCAL      0004
138 #define MEMF_SHARED     0010
139
140 #define MEMF_FIXADDR    0100
141 #define MEMF_ADDR       0200
142 #define MEMF_AUTOGROW   0400
143 #define MEMF_FILE       01000   /* regular file -- unlink on close      */
144 #define MEMF_MPIN       010000  /* use mpin(2) to lock pages in memory */
145
146 struct memalloc {
147         int     memtype;
148         int     flags;
149         int     nblks;
150         char    *name;
151         void    *space;         /* memory address of allocated space */
152         int     fd;             /* FD open for mmaping */
153         int     size;
154 }       Memalloc[NMEMALLOC];
155
156 /*
157  * Global file descriptors
158  */
159
160 int     Wfd_Append;         /* for appending to the write-log       */
161 int     Wfd_Random;         /* for overlaying write-log entries     */
162
163 /*
164  * Structure for maintaining open file test descriptors.  Used by
165  * alloc_fd().
166  */
167
168 struct fd_cache {
169         char    c_file[MAX_FNAME_LENGTH+1];
170         int     c_oflags;
171         int     c_fd;
172         long    c_rtc;
173         int     c_memalign;     /* from xfsctl(XFS_IOC_DIOINFO) */
174         int     c_miniosz;
175         int     c_maxiosz;
176         void    *c_memaddr;     /* mmapped address */
177         int     c_memlen;       /* length of above region */
178 };
179
180 #define FD_ALLOC_INCR   32      /* allocate this many fd_map structs    */
181                                 /* at a time */
182
183 /*
184  * Globals for tracking Sds and Core usage
185  */
186
187 char    *Memptr;                /* ptr to core buffer space             */
188 int     Memsize;                /* # bytes pointed to by Memptr         */
189                                 /* maintained by alloc_mem()            */
190
191 int     Sdsptr;                 /* sds offset (always 0)                */
192 int     Sdssize;                /* # bytes of allocated sds space       */
193                                 /* Maintained by alloc_sds()            */
194 char    Host[16];
195 char    Pattern[128];
196 int     Pattern_Length;
197
198 /*
199  * Signal handlers, and related globals
200  */
201
202 void    sigint_handler();       /* Catch SIGINT in parent doio, propagate
203                                  * to children, does not die. */
204
205 void    die_handler();          /* Bad sig in child doios, exit 1. */
206 void    cleanup_handler();      /* Normal kill, exit 0. */
207
208 void    sigbus_handler();       /* Handle sigbus--check active_mmap_rw to
209                                    decide if this should be a normal exit. */
210
211 void    cb_handler();           /* Posix aio callback handler. */
212 void    noop_handler();         /* Delayop alarm, does nothing. */
213 char    *hms();
214 char    *format_rw();
215 char    *format_sds();
216 char    *format_listio();
217 char    *check_file();
218 int     doio_fprintf(FILE *stream, char *format, ...);
219 void    doio_upanic();
220 void    doio();
221 void    help();
222 void    doio_delay();
223 int     alloc_fd( char *, int );
224 int     alloc_mem( int );
225 int     do_read( struct io_req * );
226 int     do_write( struct io_req * );
227 int     do_rw( struct io_req * );
228 int     do_sync( struct io_req * );
229 int     usage( FILE * );
230 int     aio_unregister( int );
231 int     parse_cmdline( int, char **, char * );
232 int     lock_file_region( char *, int, int, int, int );
233 struct  fd_cache *alloc_fdcache(char *, int);
234 int     aio_register( int, int, int );
235 #ifndef linux
236 int aio_wait(int);
237 #endif
238
239 /*
240  * Upanic conditions, and a map from symbolics to values
241  */
242
243 #define U_CORRUPTION    0001        /* upanic on data corruption    */
244 #define U_IOSW          0002        /* upanic on bad iosw           */
245 #define U_RVAL          0004        /* upanic on bad rval           */
246
247 #define U_ALL           (U_CORRUPTION | U_IOSW | U_RVAL)
248
249 /*
250  * Name-To-Value map
251  * Used to map cmdline arguments to values
252  */
253 struct smap {
254         char    *string;
255         int     value;
256 };
257
258 struct smap Upanic_Args[] = {
259         { "corruption", U_CORRUPTION    },
260         { "iosw",       U_IOSW          },
261         { "rval",       U_RVAL          },
262         { "all",        U_ALL           },
263         { NULL,         0               }
264 };
265
266 struct aio_info {
267         int                     busy;
268         int                     id;
269         int                     fd;
270         int                     strategy;
271         volatile int            done;
272         int                     sig;
273         int                     signalled;
274         struct sigaction        osa;
275 };
276
277 struct aio_info Aio_Info[MAX_AIO];
278
279 struct aio_info *aio_slot();
280 int     aio_done( struct aio_info * );
281
282 /* -C data-fill/check type */
283 #define C_DEFAULT       1
284 struct smap checkmap[] = {
285         { "default",    C_DEFAULT },
286         { NULL,         0 },
287 };
288
289 /* -d option delay types */
290 #define DELAY_SELECT    1
291 #define DELAY_SLEEP     2
292 #define DELAY_SGINAP    3
293 #define DELAY_ALARM     4
294 #define DELAY_ITIMER    5       /* POSIX timer                          */
295
296 struct smap delaymap[] = {
297         { "select",     DELAY_SELECT },
298         { "sleep",      DELAY_SLEEP },
299         { "alarm",      DELAY_ALARM },
300         { NULL, 0 },
301 };
302
303 /******
304 *
305 * strerror() does similar actions.
306
307 char *
308 syserrno(int err)
309 {
310     static char sys_errno[10];
311     sprintf(sys_errno, "%d", errno);
312     return(sys_errno);
313 }
314
315 ******/
316
317 int
318 main(argc, argv)
319 int     argc;
320 char    **argv;
321 {
322         int                     i, pid, stat, ex_stat;
323         struct sigaction        sa;
324         sigset_t                block_mask, old_mask;
325         umask(0);               /* force new file modes to known values */
326
327         TagName[0] = '\0';
328         parse_cmdline(argc, argv, OPTS);
329
330         random_range_seed(getpid());       /* initialize random number generator */
331
332         /*      
333          * If this is a re-exec of doio, jump directly into the doio function.
334          */
335
336         if (Execd) {
337                 doio();
338                 exit(E_SETUP);
339         }
340
341         /*
342          * Stop on all but a few signals...
343          */
344         sigemptyset(&sa.sa_mask);
345         sa.sa_handler = sigint_handler;
346         sa.sa_flags = SA_RESETHAND;     /* sigint is ignored after the */
347                                         /* first time */
348         for (i = 1; i <= NSIG; i++) {
349                 switch(i) {
350 #ifdef SIGRECOVERY
351                 case SIGRECOVERY:
352                         break;
353 #endif
354 #ifdef SIGCKPT
355                 case SIGCKPT:
356 #endif
357 #ifdef SIGRESTART
358                 case SIGRESTART:
359 #endif
360                 case SIGTSTP:
361                 case SIGSTOP:
362                 case SIGCONT:
363                 case SIGCLD:
364                 case SIGBUS:
365                 case SIGSEGV:
366                 case SIGQUIT:
367                         break;
368                 default:
369                         sigaction(i, &sa, NULL);
370                 }
371         }
372
373         /*
374          * If we're logging write operations, make a dummy call to wlog_open
375          * to initialize the write history file.  This call must be done in
376          * the parent, to ensure that the history file exists and/or has
377          * been truncated before any children attempt to open it, as the doio
378          * children are not allowed to truncate the file.
379          */
380
381         if (w_opt) {
382                 strcpy(Wlog.w_file, Write_Log);
383
384                 if (wlog_open(&Wlog, 1, 0666) < 0) {
385                         doio_fprintf(stderr,
386                                      "Could not create/truncate write log %s\n",
387                                      Write_Log);
388                         exit(2);
389                 }
390
391                 wlog_close(&Wlog);
392         }
393
394         /*
395          * Malloc space for the children pid array.  Initialize all entries
396          * to -1.
397          */
398
399         Children = (int *)malloc(sizeof(int) * Nprocs);
400         for (i = 0; i < Nprocs; i++) {
401                 Children[i] = -1;
402         }
403
404         sigemptyset(&block_mask);
405         sigaddset(&block_mask, SIGCHLD);
406         sigprocmask(SIG_BLOCK, &block_mask, &old_mask);
407
408         /*
409          * Fork Nprocs.  This [parent] process is a watchdog, to notify the
410          * invoker of procs which exit abnormally, and to make sure that all
411          * child procs get cleaned up.  If the -e option was used, we will also
412          * re-exec.  This is mostly for unicos/mk on mpp's, to ensure that not
413          * all of the doio's don't end up in the same pe.
414          *
415          * Note - if Nprocs is 1, or this doio is a multi-pe app (Npes > 1),
416          * jump directly to doio().  multi-pe apps can't fork(), and there is
417          * no reason to fork() for 1 proc.
418          */
419
420         if (Nprocs == 1 || Npes > 1) {
421                 doio();
422                 exit(0);
423         } else {
424                 for (i = 0; i < Nprocs; i++) {
425                         if ((pid = fork()) == -1) {
426                                 doio_fprintf(stderr,
427                                              "(parent) Could not fork %d children:  %s (%d)\n",
428                                              i+1, SYSERR, errno);
429                                 exit(E_SETUP);
430                         }
431                         
432                         Children[Nchildren] = pid;
433                         Nchildren++;
434                         
435                         if (pid == 0) {
436                                 if (e_opt) {
437                                         char *exec_path;
438
439                                         exec_path = argv[0];
440                                         argv[0] = (char *)malloc(strlen(exec_path + 1));
441                                         sprintf(argv[0], "-%s", exec_path);
442
443                                         execvp(exec_path, argv);
444                                         doio_fprintf(stderr,
445                                                      "(parent) Could not execvp %s:  %s (%d)\n",
446                                                      exec_path, SYSERR, errno);
447                                         exit(E_SETUP);
448                                 } else {
449                                         doio();
450                                         exit(E_SETUP);
451                                 }
452                         }
453                 }
454
455                 /*
456                  * Parent spins on wait(), until all children exit.
457                  */
458                 
459                 ex_stat = E_NORMAL;
460                 
461                 while (Nprocs) {
462                         if ((pid = wait(&stat)) == -1) {
463                                 if (errno == EINTR)
464                                         continue;
465                         }
466                         
467                         for (i = 0; i < Nchildren; i++)
468                                 if (Children[i] == pid)
469                                         Children[i] = -1;
470                         
471                         Nprocs--;
472                         
473                         if (WIFEXITED(stat)) {
474                                 switch (WEXITSTATUS(stat)) {
475                                 case E_NORMAL:
476                                         /* noop */
477                                         break;
478
479                                 case E_INTERNAL:
480                                         doio_fprintf(stderr,
481                                                      "(parent) pid %d exited because of an internal error\n",
482                                                      pid);
483                                         ex_stat |= E_INTERNAL;
484                                         break;
485
486                                 case E_SETUP:
487                                         doio_fprintf(stderr,
488                                                      "(parent) pid %d exited because of a setup error\n",
489                                                      pid);
490                                         ex_stat |= E_SETUP;
491                                         break;
492
493                                 case E_COMPARE:
494                                         doio_fprintf(stderr,
495                                                      "(parent) pid %d exited because of data compare errors\n",
496                                                      pid);
497
498                                         ex_stat |= E_COMPARE;
499
500                                         if (a_opt)
501                                                 kill(0, SIGINT);
502
503                                         break;
504
505                                 case E_USAGE:
506                                         doio_fprintf(stderr,
507                                                      "(parent) pid %d exited because of a usage error\n",
508                                                      pid);
509
510                                         ex_stat |= E_USAGE;
511                                         break;
512
513                                 default:
514                                         doio_fprintf(stderr,
515                                                      "(parent) pid %d exited with unknown status %d\n",
516                                                      pid, WEXITSTATUS(stat));
517                                         ex_stat |= E_INTERNAL;
518                                         break;
519                                 }
520                         } else if (WIFSIGNALED(stat) && WTERMSIG(stat) != SIGINT) {
521                                 doio_fprintf(stderr,
522                                              "(parent) pid %d terminated by signal %d\n",
523                                              pid, WTERMSIG(stat));
524                                 
525                                 ex_stat |= E_SIGNAL;
526                         }
527                         
528                         fflush(NULL);
529                 }
530         }
531
532         exit(ex_stat);
533
534 }  /* main */
535
536 /*
537  * main doio function.  Each doio child starts here, and never returns.
538  */
539
540 void
541 doio()
542 {
543         int                     rval, i, infd, nbytes;
544         char                    *cp;
545         struct io_req           ioreq;
546         struct sigaction        sa, def_action, ignore_action, exit_action;
547         struct sigaction        sigbus_action;
548
549         Memsize = Sdssize = 0;
550
551         /*
552          * Initialize the Pattern - write-type syscalls will replace Pattern[1]
553          * with the pattern passed in the request.  Make sure that
554          * strlen(Pattern) is not mod 16 so that out of order words will be
555          * detected.
556          */
557
558         gethostname(Host, sizeof(Host));
559         if ((cp = strchr(Host, '.')) != NULL)
560                 *cp = '\0';
561
562         Pattern_Length = sprintf(Pattern, "-:%d:%s:%s*", (int)getpid(), Host, Prog);
563
564         if (!(Pattern_Length % 16)) {
565                 Pattern_Length = sprintf(Pattern, "-:%d:%s:%s**",
566                                          (int)getpid(), Host, Prog);
567         }
568
569         /*
570          * Open a couple of descriptors for the write-log file.  One descriptor
571          * is for appending, one for random access.  Write logging is done for
572          * file corruption detection.  The program doio_check is capable of
573          * doing corruption detection based on a doio write-log.
574          */
575
576         if (w_opt) {
577
578                 strcpy(Wlog.w_file, Write_Log);
579         
580                 if (wlog_open(&Wlog, 0, 0666) == -1) {
581                         doio_fprintf(stderr,
582                                      "Could not open write log file (%s): wlog_open() failed\n",
583                                      Write_Log);
584                         exit(E_SETUP);
585                 }
586         }
587
588         /*
589          * Open the input stream - either a file or stdin
590          */
591
592         if (Infile == NULL) {
593                 infd = 0;
594         } else {
595                 if ((infd = open(Infile, O_RDWR)) == -1) {
596                         doio_fprintf(stderr,
597                                      "Could not open input file (%s):  %s (%d)\n",
598                                      Infile, SYSERR, errno);
599                         exit(E_SETUP);
600                 }
601         }
602
603         /*
604          * Define a set of signals that should never be masked.  Receipt of
605          * these signals generally indicates a programming error, and we want
606          * a corefile at the point of error.  We put SIGQUIT in this list so
607          * that ^\ will force a user core dump.
608          *
609          * Note:  the handler for these should be SIG_DFL, all of them 
610          * produce a corefile as the default action.
611          */
612
613         ignore_action.sa_handler = SIG_IGN;
614         ignore_action.sa_flags = 0;
615         sigemptyset(&ignore_action.sa_mask);
616
617         def_action.sa_handler = SIG_DFL;
618         def_action.sa_flags = 0;
619         sigemptyset(&def_action.sa_mask);
620
621         exit_action.sa_handler = cleanup_handler;
622         exit_action.sa_flags = 0;
623         sigemptyset(&exit_action.sa_mask);
624
625         sa.sa_handler = die_handler;
626         sa.sa_flags = 0;
627         sigemptyset(&sa.sa_mask);
628
629         sigbus_action.sa_handler = sigbus_handler;
630         sigbus_action.sa_flags = 0;
631         sigemptyset(&sigbus_action.sa_mask);
632
633         for (i = 1; i <= NSIG; i++) {
634                 switch(i) {
635                         /* Signals to terminate program on */
636                 case SIGINT:
637                         sigaction(i, &exit_action, NULL);
638                         break;
639
640                         /* This depends on active_mmap_rw */
641                 case SIGBUS:
642                         sigaction(i, &sigbus_action, NULL);
643                         break;
644
645                     /* Signals to Ignore... */
646                 case SIGSTOP:
647                 case SIGCONT:
648 #ifdef SIGRECOVERY
649                 case SIGRECOVERY:
650 #endif
651                         sigaction(i, &ignore_action, NULL);
652                         break;
653
654                     /* Signals to trap & report & die */
655                 /*case SIGTRAP:*/
656                 /*case SIGABRT:*/
657 #ifdef SIGERR   /* cray only signals */
658                 case SIGERR:
659                 case SIGBUFIO:
660                 case SIGINFO:
661 #endif
662                 /*case SIGFPE:*/
663                 case SIGURG:
664                 case SIGHUP:
665                 case SIGTERM:
666                 case SIGPIPE:
667                 case SIGIO:
668                 case SIGUSR1:
669                 case SIGUSR2:
670                         sigaction(i, &sa, NULL);
671                         break;
672
673
674                     /* Default Action for all other signals */
675                 default:
676                         sigaction(i, &def_action, NULL);
677                         break;
678                 }
679         }
680
681         /*
682          * Main loop - each doio proc does this until the read returns eof (0).
683          * Call the appropriate io function based on the request type.
684          */
685
686         while ((nbytes = read(infd, (char *)&ioreq, sizeof(ioreq)))) {
687
688                 /*
689                  * Periodically check our ppid.  If it is 1, the child exits to
690                  * help clean up in the case that the main doio process was
691                  * killed.
692                  */
693
694                 if (Reqno && ((Reqno % PPID_CHECK_INTERVAL) == 0)) {
695                         if (getppid() == 1) {
696                                 doio_fprintf(stderr,
697                                              "Parent doio process has exited\n");
698                                 alloc_mem(-1);
699                                 exit(E_SETUP);
700                         }
701                 }
702
703                 if (nbytes == -1) {
704                         doio_fprintf(stderr,
705                                      "read of %d bytes from input failed:  %s (%d)\n",
706                                      sizeof(ioreq), SYSERR, errno);
707                         alloc_mem(-1);
708                         exit(E_SETUP);
709                 }
710
711                 if (nbytes != sizeof(ioreq)) {
712                         doio_fprintf(stderr,
713                                      "read wrong # bytes from input stream, expected %d, got %d\n",
714                                      sizeof(ioreq), nbytes);
715                         alloc_mem(-1);
716                         exit(E_SETUP);
717                 }
718
719                 if (ioreq.r_magic != DOIO_MAGIC) {
720                         doio_fprintf(stderr,
721                                      "got a bad magic # from input stream.  Expected 0%o, got 0%o\n",
722                                      DOIO_MAGIC, ioreq.r_magic);
723                         alloc_mem(-1);
724                         exit(E_SETUP);
725                 }
726
727                 /*
728                  * If we're on a Release_Interval multiple, relase all ssd and
729                  * core space, and close all fd's in Fd_Map[].
730                  */
731
732                 if (Reqno && Release_Interval && ! (Reqno%Release_Interval)) {
733                         if (Memsize) {
734 #ifdef NOTDEF
735                                 sbrk(-1 * Memsize);
736 #else
737                                 alloc_mem(-1);
738 #endif
739                         }
740                         alloc_fd(NULL, 0);
741                 }
742
743                 switch (ioreq.r_type) {
744                 case READ:
745                 case READA:
746                         rval = do_read(&ioreq);
747                         break;
748
749                 case WRITE:
750                 case WRITEA:
751                         rval = do_write(&ioreq);
752                         break;
753
754                 case READV:
755                 case AREAD:
756                 case PREAD:
757                 case LREAD:
758                 case LREADA:
759                 case LSREAD:
760                 case LSREADA:
761                 case WRITEV:
762                 case AWRITE:
763                 case PWRITE:
764                 case MMAPR:
765                 case MMAPW:
766                 case LWRITE:
767                 case LWRITEA:
768                 case LSWRITE:
769                 case LSWRITEA:
770                 case LEREAD:
771                 case LEREADA:
772                 case LEWRITE:
773                 case LEWRITEA:
774                         rval = do_rw(&ioreq);
775                         break;
776                 case RESVSP:
777                 case UNRESVSP:
778                         rval = do_xfsctl(&ioreq);
779                         break;
780                 case FSYNC2:
781                 case FDATASYNC:
782                         rval = do_sync(&ioreq);
783                         break;
784                 default:
785                         doio_fprintf(stderr,
786                                      "Don't know how to handle io request type %d\n",
787                                      ioreq.r_type);
788                         alloc_mem(-1);
789                         exit(E_SETUP);
790                 }
791
792                 if (rval == SKIP_REQ){
793                         Reqskipcnt++;
794                 }
795                 else if (rval != 0) {
796                         alloc_mem(-1);
797                         doio_fprintf(stderr,
798                                      "doio(): operation %d returned != 0\n",
799                                      ioreq.r_type);
800                         exit(E_SETUP);
801                 }
802
803                 if (Message_Interval && Reqno % Message_Interval == 0) {
804                         doio_fprintf(stderr, "Info:  %d requests done (%d skipped) by this process\n", Reqno, Reqskipcnt);
805                 }
806
807                 Reqno++;
808
809                 if(delayop != 0)
810                         doio_delay();
811         }
812
813         /*
814          * Child exits normally
815          */
816         alloc_mem(-1);
817         exit(E_NORMAL);
818
819 }  /* doio */
820
821 void
822 doio_delay()
823 {
824         struct timeval tv_delay;
825         struct sigaction sa_al, sa_old;
826         sigset_t al_mask;
827
828         switch(delayop) {
829         case DELAY_SELECT:
830                 tv_delay.tv_sec = delaytime / 1000000;
831                 tv_delay.tv_usec = delaytime % 1000000;
832                 /*doio_fprintf(stdout, "delay_select: %d %d\n", 
833                             tv_delay.tv_sec, tv_delay.tv_usec);*/
834                 select(0, NULL, NULL, NULL, &tv_delay);
835                 break;
836
837         case DELAY_SLEEP:
838                 sleep(delaytime);
839                 break;
840
841         case DELAY_ALARM:
842                 sa_al.sa_flags = 0;
843                 sa_al.sa_handler = noop_handler;
844                 sigemptyset(&sa_al.sa_mask);
845                 sigaction(SIGALRM, &sa_al, &sa_old);
846                 sigemptyset(&al_mask);
847                 alarm(delaytime);
848                 sigsuspend(&al_mask);
849                 sigaction(SIGALRM, &sa_old, 0);
850                 break;
851         }
852 }
853
854
855 /*
856  * Format IO requests, returning a pointer to the formatted text.
857  *
858  * format_strat - formats the async i/o completion strategy
859  * format_rw    - formats a read[a]/write[a] request
860  * format_sds   - formats a ssread/sswrite request
861  * format_listio- formats a listio request
862  *
863  * ioreq is the doio io request structure.
864  */
865
866 struct smap sysnames[] = {
867         { "READ",       READ            },
868         { "WRITE",      WRITE           },
869         { "READA",      READA           },
870         { "WRITEA",     WRITEA          },
871         { "SSREAD",     SSREAD          },
872         { "SSWRITE",    SSWRITE         },
873         { "LISTIO",     LISTIO          },
874         { "LREAD",      LREAD           },
875         { "LREADA",     LREADA          },
876         { "LWRITE",     LWRITE          },
877         { "LWRITEA",    LWRITEA         },
878         { "LSREAD",     LSREAD          },
879         { "LSREADA",    LSREADA         },
880         { "LSWRITE",    LSWRITE         },
881         { "LSWRITEA",   LSWRITEA        },
882
883         /* Irix System Calls */
884         { "PREAD",      PREAD           },
885         { "PWRITE",     PWRITE          },
886         { "AREAD",      AREAD           },
887         { "AWRITE",     AWRITE          },
888         { "LLREAD",     LLREAD          },
889         { "LLAREAD",    LLAREAD         },
890         { "LLWRITE",    LLWRITE         },
891         { "LLAWRITE",   LLAWRITE        },
892         { "RESVSP",     RESVSP          },
893         { "UNRESVSP",   UNRESVSP        },
894
895         /* Irix and Linux System Calls */
896         { "READV",      READV           },
897         { "WRITEV",     WRITEV          },
898         { "MMAPR",      MMAPR           },
899         { "MMAPW",      MMAPW           },
900         { "FSYNC2",     FSYNC2          },
901         { "FDATASYNC",  FDATASYNC       },
902
903         { "unknown",    -1              },
904 };      
905
906 struct smap aionames[] = {
907         { "poll",       A_POLL          },
908         { "signal",     A_SIGNAL        },
909         { "recall",     A_RECALL        },
910         { "recalla",    A_RECALLA       },
911         { "recalls",    A_RECALLS       },
912         { "suspend",    A_SUSPEND       },
913         { "callback",   A_CALLBACK      },
914         { "synch",      0               },
915         { "unknown",    -1              },
916 };
917
918 char *
919 format_oflags(int oflags)
920 {
921         char flags[255];
922
923
924         flags[0]='\0';
925         switch(oflags & 03) {
926         case O_RDONLY:          strcat(flags,"O_RDONLY,");      break;
927         case O_WRONLY:          strcat(flags,"O_WRONLY,");      break;
928         case O_RDWR:            strcat(flags,"O_RDWR,");        break;
929         default:                strcat(flags,"O_weird");        break;
930         }
931
932         if(oflags & O_EXCL)
933                 strcat(flags,"O_EXCL,");
934
935         if(oflags & O_SYNC)
936                 strcat(flags,"O_SYNC,");
937
938         if(oflags & O_DIRECT)
939                 strcat(flags,"O_DIRECT,");
940
941         return(strdup(flags));
942 }
943
944 char *
945 format_strat(int strategy)
946 {
947         char msg[64];
948         char *aio_strat;
949
950         switch (strategy) {
951         case A_POLL:            aio_strat = "POLL";     break;
952         case A_SIGNAL:          aio_strat = "SIGNAL";   break;
953         case A_RECALL:          aio_strat = "RECALL";   break;
954         case A_RECALLA:         aio_strat = "RECALLA";  break;
955         case A_RECALLS:         aio_strat = "RECALLS";  break;
956         case A_SUSPEND:         aio_strat = "SUSPEND";  break;
957         case A_CALLBACK:        aio_strat = "CALLBACK"; break;
958         case 0:                 aio_strat = "<zero>";   break;
959         default:
960                 sprintf(msg, "<error:%#o>", strategy);
961                 aio_strat = strdup(msg);
962                 break;
963         }
964
965         return(aio_strat);
966 }
967
968 char *
969 format_rw(
970         struct  io_req  *ioreq,
971         int             fd,
972         void            *buffer,
973         int             signo,
974         char            *pattern,
975         void            *iosw
976         )
977 {
978         static char             *errbuf=NULL;
979         char                    *aio_strat, *cp;
980         struct read_req         *readp = &ioreq->r_data.read;
981         struct write_req        *writep = &ioreq->r_data.write;
982         struct read_req         *readap = &ioreq->r_data.read;
983         struct write_req        *writeap = &ioreq->r_data.write;
984
985         if(errbuf == NULL)
986                 errbuf = (char *)malloc(32768);
987
988         cp = errbuf;
989         cp += sprintf(cp, "Request number %d\n", Reqno);
990
991         switch (ioreq->r_type) {
992         case READ:
993                 cp += sprintf(cp, "syscall:  read(%d, %#lo, %d)\n",
994                               fd, (unsigned long) buffer, readp->r_nbytes);
995                 cp += sprintf(cp, "          fd %d is file %s - open flags are %#o\n",
996                               fd, readp->r_file, readp->r_oflags);
997                 cp += sprintf(cp, "          read done at file offset %d\n",
998                               readp->r_offset);
999                 break;
1000
1001         case WRITE:
1002                 cp += sprintf(cp, "syscall:  write(%d, %#lo, %d)\n",
1003                               fd, (unsigned long) buffer, writep->r_nbytes);
1004                 cp += sprintf(cp, "          fd %d is file %s - open flags are %#o\n",
1005                               fd, writep->r_file, writep->r_oflags);
1006                 cp += sprintf(cp, "          write done at file offset %d - pattern is %s\n",
1007                               writep->r_offset, pattern);
1008                 break;
1009
1010         case READA:
1011                 aio_strat = format_strat(readap->r_aio_strat);
1012
1013                 cp += sprintf(cp, "syscall:  reada(%d, %#lo, %d, %#lo, %d)\n",
1014                               fd, (unsigned long) buffer, readap->r_nbytes,
1015                               (unsigned long) iosw, signo);
1016                 cp += sprintf(cp, "          fd %d is file %s - open flags are %#o\n",
1017                               fd, readap->r_file, readp->r_oflags);
1018                 cp += sprintf(cp, "          reada done at file offset %d\n",
1019                               readap->r_offset);
1020                 cp += sprintf(cp, "          async io completion strategy is %s\n",
1021                               aio_strat);
1022                 break;
1023
1024         case WRITEA:
1025                 aio_strat = format_strat(writeap->r_aio_strat);
1026
1027                 cp += sprintf(cp, "syscall:  writea(%d, %#lo, %d, %#lo, %d)\n",
1028                               fd, (unsigned long) buffer, writeap->r_nbytes,
1029                               (unsigned long) iosw, signo);
1030                 cp += sprintf(cp, "          fd %d is file %s - open flags are %#o\n",
1031                               fd, writeap->r_file, writeap->r_oflags);
1032                 cp += sprintf(cp, "          writea done at file offset %d - pattern is %s\n",
1033                               writeap->r_offset, pattern);
1034                 cp += sprintf(cp, "          async io completion strategy is %s\n",
1035                               aio_strat);
1036                 break;
1037
1038         }
1039
1040         return errbuf;
1041 }
1042
1043 /*
1044  * Perform the various sorts of disk reads
1045  */
1046
1047 int
1048 do_read(req)
1049 struct io_req   *req;
1050 {
1051         int                     fd, offset, nbytes, oflags, rval;
1052         char                    *addr, *file;
1053         struct fd_cache         *fdc;
1054
1055         /*
1056          * Initialize common fields - assumes r_oflags, r_file, r_offset, and
1057          * r_nbytes are at the same offset in the read_req and reada_req
1058          * structures.
1059          */
1060
1061         file = req->r_data.read.r_file;
1062         oflags = req->r_data.read.r_oflags;
1063         offset = req->r_data.read.r_offset;
1064         nbytes = req->r_data.read.r_nbytes;
1065
1066         /*printf("read: %s, %#o, %d %d\n", file, oflags, offset, nbytes);*/
1067
1068         /*
1069          * Grab an open file descriptor
1070          * Note: must be done before memory allocation so that the direct i/o
1071          *      information is available in mem. allocate
1072          */
1073
1074         if ((fd = alloc_fd(file, oflags)) == -1)
1075                 return -1;
1076
1077         /*
1078          * Allocate core or sds - based on the O_SSD flag
1079          */
1080
1081 #ifndef wtob
1082 #define wtob(x) (x * sizeof(UINT64_T))
1083 #endif
1084
1085         /* get memory alignment for using DIRECT I/O */
1086         fdc = alloc_fdcache(file, oflags);
1087
1088         if ((rval = alloc_mem(nbytes + wtob(1) * 2 + fdc->c_memalign)) < 0) {
1089                 return rval;
1090         }
1091
1092         addr = Memptr;
1093
1094
1095         if( (req->r_data.read.r_uflags & F_WORD_ALIGNED) ) {
1096                 /*
1097                  * Force memory alignment for Direct I/O
1098                  */
1099                 if( (oflags & O_DIRECT) && ((long)addr % fdc->c_memalign != 0) ) {
1100                         addr += fdc->c_memalign - ((long)addr % fdc->c_memalign);
1101                 }
1102         } else {
1103                 addr += random_range(0, wtob(1) - 1, 1, NULL);
1104         }
1105
1106         switch (req->r_type) {
1107         case READ:
1108                 /* move to the desired file position. */
1109                 if (lseek(fd, offset, SEEK_SET) == -1) {
1110                         doio_fprintf(stderr,
1111                                      "lseek(%d, %d, SEEK_SET) failed:  %s (%d)\n",
1112                                      fd, offset, SYSERR, errno);
1113                         return -1;
1114                 }
1115
1116                 if ((rval = read(fd, addr, nbytes)) == -1) {
1117                         doio_fprintf(stderr,
1118                                      "read() request failed:  %s (%d)\n%s\n",
1119                                      SYSERR, errno,
1120                                      format_rw(req, fd, addr, -1, NULL, NULL));
1121                         doio_upanic(U_RVAL);
1122                         return -1;
1123                 } else if (rval != nbytes) {
1124                         doio_fprintf(stderr,
1125                                      "read() request returned wrong # of bytes - expected %d, got %d\n%s\n",
1126                                      nbytes, rval, 
1127                                      format_rw(req, fd, addr, -1, NULL, NULL));
1128                         doio_upanic(U_RVAL);
1129                         return -1;
1130                 }
1131                 break;
1132         }
1133
1134         return 0;               /* if we get here, everything went ok */
1135 }
1136
1137 /*
1138  * Perform the verious types of disk writes.
1139  */
1140
1141 int
1142 do_write(req)
1143 struct io_req   *req;
1144 {
1145         static int              pid = -1;
1146         int                     fd, nbytes, oflags;
1147         /* REFERENCED */
1148         int                     signo;
1149         int                     logged_write, rval, got_lock;
1150         long                    offset, woffset = 0;
1151         char                    *addr, pattern, *file, *msg;
1152         struct wlog_rec         wrec;
1153         struct fd_cache         *fdc;
1154
1155         /*
1156          * Misc variable setup
1157          */
1158
1159         signo   = 0;
1160         nbytes  = req->r_data.write.r_nbytes;
1161         offset  = req->r_data.write.r_offset;
1162         pattern = req->r_data.write.r_pattern;
1163         file    = req->r_data.write.r_file;
1164         oflags  = req->r_data.write.r_oflags;
1165
1166         /*printf("pwrite: %s, %#o, %d %d\n", file, oflags, offset, nbytes);*/
1167
1168         /*
1169          * Allocate core memory and possibly sds space.  Initialize the data
1170          * to be written.
1171          */
1172
1173         Pattern[0] = pattern;
1174
1175
1176         /*
1177          * Get a descriptor to do the io on
1178          */
1179
1180         if ((fd = alloc_fd(file, oflags)) == -1)
1181                 return -1;
1182
1183         /*printf("write: %d, %s, %#o, %d %d\n",
1184                fd, file, oflags, offset, nbytes);*/
1185
1186         /*
1187          * Allocate SDS space for backdoor write if desired
1188          */
1189
1190         /* get memory alignment for using DIRECT I/O */
1191         fdc = alloc_fdcache(file, oflags);
1192
1193         if ((rval = alloc_mem(nbytes + wtob(1) * 2 + fdc->c_memalign)) < 0) {
1194                 return rval;
1195         }
1196
1197         addr = Memptr;
1198
1199         if( (req->r_data.write.r_uflags & F_WORD_ALIGNED) ) {
1200                 /*
1201                  * Force memory alignment for Direct I/O
1202                  */
1203                 if( (oflags & O_DIRECT) && ((long)addr % fdc->c_memalign != 0) ) {
1204                         addr += fdc->c_memalign - ((long)addr % fdc->c_memalign);
1205                 }
1206         } else {
1207                 addr += random_range(0, wtob(1) - 1, 1, NULL);
1208         }
1209
1210         (*Data_Fill)(Memptr, nbytes, Pattern, Pattern_Length, 0);
1211         if( addr != Memptr )
1212                 memmove( addr, Memptr, nbytes);
1213
1214         rval = -1;
1215         got_lock = 0;
1216         logged_write = 0;
1217
1218         if (k_opt) {
1219                 if (lock_file_region(file, fd, F_WRLCK, offset, nbytes) < 0) {
1220                         alloc_mem(-1);
1221                         exit(E_INTERNAL);
1222                 }
1223
1224                 got_lock = 1;
1225         }
1226
1227         /*
1228          * Write a preliminary write-log entry.  This is done so that
1229          * doio_check can do corruption detection across an interrupt/crash.
1230          * Note that w_done is set to 0.  If doio_check sees this, it
1231          * re-creates the file extents as if the write completed, but does not
1232          * do any checking - see comments in doio_check for more details.
1233          */
1234
1235         if (w_opt) {
1236                 if (pid == -1) {
1237                         pid = getpid();
1238                 }
1239                 wrec.w_async = (req->r_type == WRITEA) ? 1 : 0;
1240                 wrec.w_oflags = oflags;
1241                 wrec.w_pid = pid;
1242                 wrec.w_offset = offset;
1243                 wrec.w_nbytes = nbytes;
1244
1245                 wrec.w_pathlen = strlen(file);
1246                 memcpy(wrec.w_path, file, wrec.w_pathlen);
1247                 wrec.w_hostlen = strlen(Host);
1248                 memcpy(wrec.w_host, Host, wrec.w_hostlen);
1249                 wrec.w_patternlen = Pattern_Length;
1250                 memcpy(wrec.w_pattern, Pattern, wrec.w_patternlen);
1251
1252                 wrec.w_done = 0;
1253
1254                 if ((woffset = wlog_record_write(&Wlog, &wrec, -1)) == -1) {
1255                         doio_fprintf(stderr,
1256                                      "Could not append to write-log:  %s (%d)\n",
1257                                      SYSERR, errno);
1258                 } else {
1259                         logged_write = 1;
1260                 }
1261         }
1262
1263         switch (req->r_type ) {
1264         case WRITE:
1265                 /*
1266                  * sync write
1267                  */
1268
1269                 if (lseek(fd, offset, SEEK_SET) == -1) {
1270                         doio_fprintf(stderr,
1271                                      "lseek(%d, %d, SEEK_SET) failed:  %s (%d)\n",
1272                                      fd, offset, SYSERR, errno);
1273                         return -1;
1274                 }
1275
1276                 rval = write(fd, addr, nbytes);
1277
1278                 if (rval == -1) {
1279                         doio_fprintf(stderr,
1280                                      "write() failed:  %s (%d)\n%s\n",
1281                                      SYSERR, errno,
1282                                      format_rw(req, fd, addr, -1, Pattern, NULL));
1283                         doio_fprintf(stderr,
1284                                      "write() failed:  %s\n\twrite(%d, %#o, %d)\n\toffset %d, nbytes%%miniou(%d)=%d, oflags=%#o memalign=%d, addr%%memalign=%d\n",
1285                                      strerror(errno),
1286                                      fd, addr, nbytes,
1287                                      offset,
1288                                      fdc->c_miniosz, nbytes%fdc->c_miniosz,
1289                                      oflags, fdc->c_memalign, (long)addr%fdc->c_memalign);
1290                         doio_upanic(U_RVAL);
1291                 } else if (rval != nbytes) {
1292                         doio_fprintf(stderr,
1293                                      "write() returned wrong # bytes - expected %d, got %d\n%s\n",
1294                                      nbytes, rval,
1295                                      format_rw(req, fd, addr, -1, Pattern, NULL));
1296                         doio_upanic(U_RVAL);
1297                         rval = -1;
1298                 }
1299
1300                 break;
1301         }
1302
1303         /*
1304          * Verify that the data was written correctly - check_file() returns
1305          * a non-null pointer which contains an error message if there are
1306          * problems.
1307          */
1308
1309         if (v_opt) {
1310                 msg = check_file(file, offset, nbytes, Pattern, Pattern_Length,
1311                                  0, oflags & O_PARALLEL);
1312                 if (msg != NULL) {
1313                         doio_fprintf(stderr, "%s%s\n",
1314                                      msg,
1315                                      format_rw(req, fd, addr, -1, Pattern, NULL)
1316                                 );
1317                         doio_upanic(U_CORRUPTION);
1318                         exit(E_COMPARE);
1319
1320                 }
1321         }
1322
1323         /*
1324          * General cleanup ...
1325          *
1326          * Write extent information to the write-log, so that doio_check can do
1327          * corruption detection.  Note that w_done is set to 1, indicating that
1328          * the write has been verified as complete.  We don't need to write the
1329          * filename on the second logging.
1330          */
1331
1332         if (w_opt && logged_write) {
1333                 wrec.w_done = 1;
1334                 wlog_record_write(&Wlog, &wrec, woffset);
1335         }
1336
1337         /*
1338          * Unlock file region if necessary
1339          */
1340
1341         if (got_lock) {
1342                 if (lock_file_region(file, fd, F_UNLCK, offset, nbytes) < 0) {
1343                         alloc_mem(-1);
1344                         exit(E_INTERNAL);
1345                 }
1346         }
1347
1348         return( (rval == -1) ? -1 : 0);
1349 }
1350
1351
1352 /*
1353  * Simple routine to lock/unlock a file using fcntl()
1354  */
1355
1356 int
1357 lock_file_region(fname, fd, type, start, nbytes)
1358 char    *fname;
1359 int     fd;
1360 int     type;
1361 int     start;
1362 int     nbytes;
1363 {
1364         struct flock    flk;
1365
1366         flk.l_type = type;
1367         flk.l_whence = 0;
1368         flk.l_start = start;
1369         flk.l_len = nbytes;
1370
1371         if (fcntl(fd, F_SETLKW, &flk) < 0) {
1372                 doio_fprintf(stderr,
1373                              "fcntl(%d, %d, %#o) failed for file %s, lock type %d, offset %d, length %d:  %s (%d), open flags: %#o\n",
1374                              fd, F_SETLKW, &flk, fname, type,
1375                              start, nbytes, SYSERR, errno,
1376                              fcntl(fd, F_GETFL, 0));
1377                 return -1;
1378         }
1379
1380         return 0;
1381 }
1382
1383 int
1384 do_listio(req)
1385 struct io_req   *req;
1386 {
1387         return -1;
1388 }
1389
1390 /* ---------------------------------------------------------------------------
1391  *
1392  * A new paradigm of doing the r/w system call where there is a "stub"
1393  * function that builds the info for the system call, then does the system
1394  * call; this is called by code that is common to all system calls and does
1395  * the syscall return checking, async I/O wait, iosw check, etc.
1396  *
1397  * Flags:
1398  *      WRITE, ASYNC, SSD/SDS,
1399  *      FILE_LOCK, WRITE_LOG, VERIFY_DATA,
1400  */
1401
1402 struct  status {
1403         int     rval;           /* syscall return */
1404         int     err;            /* errno */
1405         int     *aioid;         /* list of async I/O structures */
1406 };
1407
1408 struct syscall_info {
1409         char            *sy_name;
1410         int             sy_type;
1411         struct status   *(*sy_syscall)();
1412         int             (*sy_buffer)();
1413         char            *(*sy_format)();
1414         int             sy_flags;
1415         int             sy_bits;
1416 };
1417
1418 #define SY_WRITE                00001
1419 #define SY_ASYNC                00010
1420 #define SY_IOSW                 00020
1421 #define SY_SDS                  00100
1422
1423 char *
1424 fmt_ioreq(struct io_req *ioreq, struct syscall_info *sy, int fd)
1425 {
1426         static char             *errbuf=NULL;
1427         char                    *cp;
1428         struct rw_req           *io;
1429         struct smap             *aname;
1430
1431         if(errbuf == NULL)
1432                 errbuf = (char *)malloc(32768);
1433
1434         io = &ioreq->r_data.io;
1435
1436         /*
1437          * Look up async I/O completion strategy
1438          */
1439         for(aname=aionames;
1440             aname->value != -1 && aname->value != io->r_aio_strat;
1441             aname++)
1442                 ;
1443
1444         cp = errbuf;
1445         cp += sprintf(cp, "Request number %d\n", Reqno);
1446
1447         cp += sprintf(cp, "          fd %d is file %s - open flags are %#o %s\n",
1448                       fd, io->r_file, io->r_oflags, format_oflags(io->r_oflags));
1449
1450         if(sy->sy_flags & SY_WRITE) {
1451                 cp += sprintf(cp, "          write done at file offset %d - pattern is %c (%#o)\n",
1452                               io->r_offset,
1453                               (io->r_pattern == '\0') ? '?' : io->r_pattern,
1454                               io->r_pattern);
1455         } else {
1456                 cp += sprintf(cp, "          read done at file offset %d\n",
1457                       io->r_offset);
1458         }
1459
1460         if(sy->sy_flags & SY_ASYNC) {
1461                 cp += sprintf(cp, "          async io completion strategy is %s\n",
1462                               aname->string);
1463         }
1464
1465         cp += sprintf(cp, "          number of requests is %d, strides per request is %d\n",
1466                       io->r_nent, io->r_nstrides);
1467
1468         cp += sprintf(cp, "          i/o byte count = %d\n",
1469                       io->r_nbytes);
1470
1471         cp += sprintf(cp, "          memory alignment is %s\n",
1472                       (io->r_uflags & F_WORD_ALIGNED) ? "aligned" : "unaligned");
1473
1474         if(io->r_oflags & O_DIRECT) {
1475                 struct dioattr  finfo;
1476                 
1477                 if(xfsctl(io->r_file, fd, XFS_IOC_DIOINFO, &finfo) == -1) {
1478                         cp += sprintf(cp, "          Error %s (%d) getting direct I/O info\n",
1479                                       strerror(errno), errno);
1480                         finfo.d_mem = 1;
1481                         finfo.d_miniosz = 1;
1482                         finfo.d_maxiosz = 1;
1483                 }
1484
1485                 cp += sprintf(cp, "          DIRECT I/O: offset %% %d = %d length %% %d = %d\n",
1486                               finfo.d_miniosz,
1487                               io->r_offset % finfo.d_miniosz,
1488                               io->r_nbytes,
1489                               io->r_nbytes % finfo.d_miniosz);
1490                 cp += sprintf(cp, "          mem alignment 0x%x xfer size: small: %d large: %d\n",
1491                               finfo.d_mem, finfo.d_miniosz, finfo.d_maxiosz);
1492         }
1493         return(errbuf);
1494 }
1495
1496 struct status *
1497 sy_pread(req, sysc, fd, addr)
1498 struct io_req   *req;
1499 struct syscall_info *sysc;
1500 int fd;
1501 char *addr;
1502 {
1503         int rc;
1504         struct status   *status;
1505
1506         rc = pread(fd, addr, req->r_data.io.r_nbytes,
1507                    req->r_data.io.r_offset);
1508
1509         status = (struct status *)malloc(sizeof(struct status));
1510         if( status == NULL ){
1511                 doio_fprintf(stderr, "malloc failed, %s/%d\n",
1512                         __FILE__, __LINE__);
1513                 return NULL;
1514         }
1515         status->aioid = NULL;
1516         status->rval = rc;
1517         status->err = errno;
1518
1519         return(status);
1520 }
1521
1522 struct status *
1523 sy_pwrite(req, sysc, fd, addr)
1524 struct io_req   *req;
1525 struct syscall_info *sysc;
1526 int fd;
1527 char *addr;
1528 {
1529         int rc;
1530         struct status   *status;
1531
1532         rc = pwrite(fd, addr, req->r_data.io.r_nbytes,
1533                     req->r_data.io.r_offset);
1534
1535         status = (struct status *)malloc(sizeof(struct status));
1536         if( status == NULL ){
1537                 doio_fprintf(stderr, "malloc failed, %s/%d\n",
1538                         __FILE__, __LINE__);
1539                 return NULL;
1540         }
1541         status->aioid = NULL;
1542         status->rval = rc;
1543         status->err = errno;
1544
1545         return(status);
1546 }
1547
1548 char *
1549 fmt_pread(struct io_req *req, struct syscall_info *sy, int fd, char *addr)
1550 {
1551         static char     *errbuf = NULL;
1552         char            *cp;
1553
1554         if(errbuf == NULL){
1555                 errbuf = (char *)malloc(32768);
1556                 if( errbuf == NULL ){
1557                         doio_fprintf(stderr, "malloc failed, %s/%d\n",
1558                                 __FILE__, __LINE__);
1559                         return NULL;
1560                 }
1561         }
1562
1563         cp = errbuf;
1564         cp += sprintf(cp, "syscall:  %s(%d, 0x%p, %d)\n",
1565                       sy->sy_name, fd, addr, req->r_data.io.r_nbytes);
1566         return(errbuf);
1567 }
1568
1569 struct status *
1570 sy_readv(req, sysc, fd, addr)
1571 struct io_req   *req;
1572 struct syscall_info *sysc;
1573 int fd;
1574 char *addr;
1575 {
1576         struct status *sy_rwv();
1577         return sy_rwv(req, sysc, fd, addr, 0);
1578 }
1579
1580 struct status *
1581 sy_writev(req, sysc, fd, addr)
1582 struct io_req   *req;
1583 struct syscall_info *sysc;
1584 int fd;
1585 char *addr;
1586 {
1587         struct status *sy_rwv();
1588         return sy_rwv(req, sysc, fd, addr, 1);
1589 }
1590
1591 struct status *
1592 sy_rwv(req, sysc, fd, addr, rw)
1593 struct io_req   *req;
1594 struct syscall_info *sysc;
1595 int fd;
1596 char *addr;
1597 int rw;
1598 {
1599         int rc;
1600         struct status   *status;
1601         struct iovec    iov[2];
1602
1603         status = (struct status *)malloc(sizeof(struct status));
1604         if( status == NULL ){
1605                 doio_fprintf(stderr, "malloc failed, %s/%d\n",
1606                         __FILE__, __LINE__);
1607                 return NULL;
1608         }
1609         status->aioid = NULL;
1610
1611         /* move to the desired file position. */
1612         if ((rc=lseek(fd, req->r_data.io.r_offset, SEEK_SET)) == -1) {
1613                 status->rval = rc;
1614                 status->err = errno;
1615                 return(status);
1616         }
1617
1618         iov[0].iov_base = addr;
1619         iov[0].iov_len = req->r_data.io.r_nbytes;
1620
1621         if(rw)
1622                 rc = writev(fd, iov, 1);
1623         else
1624                 rc = readv(fd, iov, 1);
1625         status->aioid = NULL;
1626         status->rval = rc;
1627         status->err = errno;
1628         return(status);
1629 }
1630
1631 char *
1632 fmt_readv(struct io_req *req, struct syscall_info *sy, int fd, char *addr)
1633 {
1634         static char     errbuf[32768];
1635         char            *cp;
1636
1637         cp = errbuf;
1638         cp += sprintf(cp, "syscall:  %s(%d, (iov on stack), 1)\n",
1639                       sy->sy_name, fd);
1640         return(errbuf);
1641 }
1642
1643 struct status *
1644 sy_mmread(req, sysc, fd, addr)
1645 struct io_req *req;
1646 struct syscall_info *sysc;
1647 int fd;
1648 char *addr;
1649 {
1650         struct status *sy_mmrw();
1651         return sy_mmrw(req, sysc, fd, addr, 0);
1652 }
1653
1654 struct status *
1655 sy_mmwrite(req, sysc, fd, addr)
1656 struct io_req *req;
1657 struct syscall_info *sysc;
1658 int fd;
1659 char *addr;
1660 {
1661         struct status *sy_mmrw();
1662         return sy_mmrw(req, sysc, fd, addr, 1);
1663 }
1664
1665 struct status *
1666 sy_mmrw(req, sysc, fd, addr, rw)
1667 struct io_req *req;
1668 struct syscall_info *sysc;
1669 int fd;
1670 char *addr;
1671 int rw;
1672 {
1673         /*
1674          * mmap read/write
1675          * This version is oriented towards mmaping the file to memory
1676          * ONCE and keeping it mapped.
1677          */
1678         struct status           *status;
1679         void                    *mrc, *memaddr;
1680         struct fd_cache         *fdc;
1681         struct stat             sbuf;
1682
1683         status = (struct status *)malloc(sizeof(struct status));
1684         if( status == NULL ){
1685                 doio_fprintf(stderr, "malloc failed, %s/%d\n",
1686                         __FILE__, __LINE__);
1687                 return NULL;
1688         }
1689         status->aioid = NULL;
1690         status->rval = -1;
1691
1692         fdc = alloc_fdcache(req->r_data.io.r_file, req->r_data.io.r_oflags);
1693
1694         if( fdc->c_memaddr == NULL ) {
1695                 if( fstat(fd, &sbuf) < 0 ){
1696                         doio_fprintf(stderr, "fstat failed, errno=%d\n",
1697                                      errno);
1698                         status->err = errno;
1699                         return(status);
1700                 }
1701
1702                 fdc->c_memlen = (int)sbuf.st_size;
1703                 mrc = mmap(NULL, (int)sbuf.st_size,
1704                      rw ? PROT_WRITE|PROT_READ : PROT_READ,
1705                      MAP_SHARED, fd, 0);
1706
1707                 if( mrc == MAP_FAILED ) {
1708                         doio_fprintf(stderr, "mmap() failed - 0x%lx %d\n",
1709                                 mrc, errno);
1710                         status->err = errno;
1711                         return(status);
1712                 }
1713
1714                 fdc->c_memaddr = mrc;
1715         }
1716
1717         memaddr = (void *)((char *)fdc->c_memaddr + req->r_data.io.r_offset);
1718
1719         active_mmap_rw = 1;
1720         if(rw)
1721                 memcpy(memaddr, addr, req->r_data.io.r_nbytes);
1722         else
1723                 memcpy(addr, memaddr, req->r_data.io.r_nbytes);
1724         active_mmap_rw = 0;
1725
1726         status->rval = req->r_data.io.r_nbytes;
1727         status->err = 0;
1728         return(status);
1729 }
1730
1731 char *
1732 fmt_mmrw(struct io_req *req, struct syscall_info *sy, int fd, char *addr)
1733 {
1734         static char     errbuf[32768];
1735         char            *cp;
1736         struct fd_cache *fdc;
1737         void            *memaddr;
1738
1739         fdc = alloc_fdcache(req->r_data.io.r_file, req->r_data.io.r_oflags);
1740
1741         cp = errbuf;
1742         cp += sprintf(cp, "syscall:  %s(NULL, %d, %s, MAP_SHARED, %d, 0)\n",
1743                       sy->sy_name,
1744                       fdc->c_memlen,
1745                       (sy->sy_flags & SY_WRITE) ? "PROT_WRITE" : "PROT_READ",
1746                       fd);
1747
1748         cp += sprintf(cp, "\tfile is mmaped to: 0x%lx\n",
1749                       (unsigned long) fdc->c_memaddr);
1750
1751         memaddr = (void *)((char *)fdc->c_memaddr + req->r_data.io.r_offset);
1752
1753         cp += sprintf(cp, "\tfile-mem=0x%lx, length=%d, buffer=0x%lx\n",
1754                       (unsigned long) memaddr, req->r_data.io.r_nbytes,
1755                       (unsigned long) addr);
1756                       
1757         return(errbuf);
1758 }
1759
1760 struct syscall_info syscalls[] = {
1761         { "pread",                      PREAD,
1762           sy_pread,     NULL,           fmt_pread,
1763           0
1764         },
1765         { "pwrite",                     PWRITE,
1766           sy_pwrite,    NULL,           fmt_pread,
1767           SY_WRITE
1768         },
1769
1770         { "readv",                      READV,
1771           sy_readv,     NULL,           fmt_readv,
1772           0
1773         },
1774         { "writev",                     WRITEV,
1775           sy_writev,    NULL,           fmt_readv,
1776           SY_WRITE
1777         },
1778         { "mmap-read",                  MMAPR,
1779           sy_mmread,    NULL,           fmt_mmrw,
1780           0
1781         },
1782         { "mmap-write",                 MMAPW,
1783           sy_mmwrite,   NULL,           fmt_mmrw,
1784           SY_WRITE
1785         },
1786
1787         { NULL,                         0,
1788           0,            0,              0,
1789           0
1790         },
1791 };
1792
1793 int
1794 do_rw(req)
1795         struct io_req   *req;
1796 {
1797         static int              pid = -1;
1798         int                     fd, offset, nbytes, nstrides, nents, oflags;
1799         int                     rval, mem_needed, i;
1800         int                     logged_write, got_lock, woffset = 0, pattern;
1801         int                     min_byte, max_byte;
1802         char                    *addr, *file, *msg;
1803         struct status           *s;
1804         struct wlog_rec         wrec;
1805         struct syscall_info     *sy;
1806         struct fd_cache         *fdc;
1807
1808         /*
1809          * Initialize common fields - assumes r_oflags, r_file, r_offset, and
1810          * r_nbytes are at the same offset in the read_req and reada_req
1811          * structures.
1812          */
1813         file    = req->r_data.io.r_file;
1814         oflags  = req->r_data.io.r_oflags;
1815         offset  = req->r_data.io.r_offset;
1816         nbytes  = req->r_data.io.r_nbytes;
1817         nstrides= req->r_data.io.r_nstrides;
1818         nents   = req->r_data.io.r_nent;
1819         pattern = req->r_data.io.r_pattern;
1820
1821         if( nents >= MAX_AIO ) {
1822                 doio_fprintf(stderr, "do_rw: too many list requests, %d.  Maximum is %d\n",
1823                              nents, MAX_AIO);
1824                 return(-1);
1825         }
1826
1827         /*
1828          * look up system call info
1829          */
1830         for(sy=syscalls; sy->sy_name != NULL && sy->sy_type != req->r_type; sy++)
1831                 ;
1832
1833         if(sy->sy_name == NULL) {
1834                 doio_fprintf(stderr, "do_rw: unknown r_type %d.\n",
1835                              req->r_type);
1836                 return(-1);
1837         }
1838
1839         /*
1840          * Get an open file descriptor
1841          * Note: must be done before memory allocation so that the direct i/o
1842          *      information is available in mem. allocate
1843          */
1844
1845         if ((fd = alloc_fd(file, oflags)) == -1)
1846                 return -1;
1847
1848         /*
1849          * Allocate core memory and possibly sds space.  Initialize the
1850          * data to be written.  Make sure we get enough, based on the
1851          * memstride.
1852          *
1853          * need:
1854          *      1 extra word for possible partial-word address "bump"
1855          *      1 extra word for dynamic pattern overrun
1856          *      MPP_BUMP extra words for T3E non-hw-aligned memory address.
1857          */
1858
1859         if( sy->sy_buffer != NULL ) {
1860                 mem_needed = (*sy->sy_buffer)(req, 0, 0, NULL, NULL);
1861         } else {
1862                 mem_needed = nbytes;
1863         }
1864
1865         /* get memory alignment for using DIRECT I/O */
1866         fdc = alloc_fdcache(file, oflags);
1867
1868         if ((rval = alloc_mem(mem_needed + wtob(1) * 2 + fdc->c_memalign)) < 0) {
1869                 return rval;
1870         }
1871
1872         Pattern[0] = pattern;
1873
1874         /*
1875          * Allocate SDS space for backdoor write if desired
1876          */
1877
1878         if (oflags & O_SSD) {
1879                 doio_fprintf(stderr, "Invalid O_SSD flag was generated for non-Cray system\n");
1880                 fflush(stderr);
1881                 return -1;
1882         } else {
1883                 addr = Memptr;
1884
1885                 /*
1886                  * if io is not raw, bump the offset by a random amount
1887                  * to generate non-word-aligned io.
1888                  *
1889                  * On MPP systems, raw I/O must start on an 0x80 byte boundary.
1890                  * For non-aligned I/O, bump the address from 1 to 8 words.
1891                  */
1892
1893                 if (! (req->r_data.io.r_uflags & F_WORD_ALIGNED)) {
1894                         addr += random_range(0, wtob(1) - 1, 1, NULL);
1895                 }
1896
1897                 /*
1898                  * Force memory alignment for Direct I/O
1899                  */
1900                 if( (oflags & O_DIRECT) && ((long)addr % fdc->c_memalign != 0) ) {
1901                         addr += fdc->c_memalign - ((long)addr % fdc->c_memalign);
1902                 }
1903
1904                 /*
1905                  * FILL must be done on a word-aligned buffer.
1906                  * Call the fill function with Memptr which is aligned,
1907                  * then memmove it to the right place.
1908                  */
1909                 if (sy->sy_flags & SY_WRITE) {
1910                         (*Data_Fill)(Memptr, mem_needed, Pattern, Pattern_Length, 0);
1911                         if( addr != Memptr )
1912                             memmove( addr, Memptr, mem_needed);
1913                 }
1914         }
1915
1916         rval = 0;
1917         got_lock = 0;
1918         logged_write = 0;
1919
1920         /*
1921          * Lock data if this is a write and locking option is set
1922          */
1923         if (sy->sy_flags & SY_WRITE && k_opt) {
1924                 if( sy->sy_buffer != NULL ) {
1925                         (*sy->sy_buffer)(req, offset, 0, &min_byte, &max_byte);
1926                 } else {
1927                         min_byte = offset;
1928                         max_byte = offset + (nbytes * nstrides * nents);
1929                 }
1930
1931                 if (lock_file_region(file, fd, F_WRLCK,
1932                                      min_byte, (max_byte-min_byte+1)) < 0) {
1933                     doio_fprintf(stderr, 
1934                                 "file lock failed:\n%s\n",
1935                                 fmt_ioreq(req, sy, fd));
1936                     doio_fprintf(stderr, 
1937                                 "          buffer(req, %d, 0, 0x%x, 0x%x)\n",
1938                                 offset, min_byte, max_byte);
1939                     alloc_mem(-1);
1940                     exit(E_INTERNAL);
1941                 }
1942
1943                 got_lock = 1;
1944         }
1945
1946         /*
1947          * Write a preliminary write-log entry.  This is done so that
1948          * doio_check can do corruption detection across an interrupt/crash.
1949          * Note that w_done is set to 0.  If doio_check sees this, it
1950          * re-creates the file extents as if the write completed, but does not
1951          * do any checking - see comments in doio_check for more details.
1952          */
1953
1954         if (sy->sy_flags & SY_WRITE && w_opt) {
1955                 if (pid == -1) {
1956                         pid = getpid();
1957                 }
1958
1959                 wrec.w_async = (sy->sy_flags & SY_ASYNC) ? 1 : 0;
1960                 wrec.w_oflags = oflags;
1961                 wrec.w_pid = pid;
1962                 wrec.w_offset = offset;
1963                 wrec.w_nbytes = nbytes; /* mem_needed -- total length */
1964
1965                 wrec.w_pathlen = strlen(file);
1966                 memcpy(wrec.w_path, file, wrec.w_pathlen);
1967                 wrec.w_hostlen = strlen(Host);
1968                 memcpy(wrec.w_host, Host, wrec.w_hostlen);
1969                 wrec.w_patternlen = Pattern_Length;
1970                 memcpy(wrec.w_pattern, Pattern, wrec.w_patternlen);
1971
1972                 wrec.w_done = 0;
1973
1974                 if ((woffset = wlog_record_write(&Wlog, &wrec, -1)) == -1) {
1975                         doio_fprintf(stderr,
1976                                      "Could not append to write-log:  %s (%d)\n",
1977                                      SYSERR, errno);
1978                 } else {
1979                         logged_write = 1;
1980                 }
1981         }
1982
1983         s = (*sy->sy_syscall)(req, sy, fd, addr);
1984
1985         if( s->rval == -1 ) {
1986                 doio_fprintf(stderr,
1987                              "%s() request failed:  %s (%d)\n%s\n%s\n",
1988                              sy->sy_name, SYSERR, errno,
1989                              fmt_ioreq(req, sy, fd),
1990                              (*sy->sy_format)(req, sy, fd, addr));
1991
1992                 doio_upanic(U_RVAL);
1993
1994                 for(i=0; i < nents; i++) {
1995                         if(s->aioid == NULL)
1996                                 break;
1997                         aio_unregister(s->aioid[i]);
1998                 }
1999                 rval = -1;
2000         } else {
2001                 /*
2002                  * If the syscall was async, wait for I/O to complete
2003                  */
2004 #ifndef linux
2005                 if(sy->sy_flags & SY_ASYNC) {
2006                         for(i=0; i < nents; i++) {
2007                                 aio_wait(s->aioid[i]);
2008                         }
2009                 }
2010 #endif
2011
2012                 /*
2013                  * Check the syscall how-much-data-written return.  Look
2014                  * for this in either the return value or the 'iosw'
2015                  * structure.
2016                  */
2017
2018                 if( !(sy->sy_flags & SY_IOSW) ) {
2019
2020                         if(s->rval != mem_needed) {
2021                                 doio_fprintf(stderr,
2022                                              "%s() request returned wrong # of bytes - expected %d, got %d\n%s\n%s\n",
2023                                              sy->sy_name, nbytes, s->rval,
2024                                              fmt_ioreq(req, sy, fd),
2025                                              (*sy->sy_format)(req, sy, fd, addr));
2026                                 rval = -1;
2027                                 doio_upanic(U_RVAL);
2028                         }
2029                 }
2030         }
2031
2032
2033         /*
2034          * Verify that the data was written correctly - check_file() returns
2035          * a non-null pointer which contains an error message if there are
2036          * problems.
2037          */
2038
2039         if ( rval == 0 && sy->sy_flags & SY_WRITE && v_opt) {
2040                 msg = check_file(file, offset, nbytes*nstrides*nents,
2041                                  Pattern, Pattern_Length, 0,
2042                                  oflags & O_PARALLEL);
2043                 if (msg != NULL) {
2044                         doio_fprintf(stderr, "%s\n%s\n%s\n",
2045                                      msg,
2046                                      fmt_ioreq(req, sy, fd),
2047                                      (*sy->sy_format)(req, sy, fd, addr));
2048                         doio_upanic(U_CORRUPTION);
2049                         exit(E_COMPARE);
2050                 }
2051         }
2052
2053         /*
2054          * General cleanup ...
2055          *
2056          * Write extent information to the write-log, so that doio_check can do
2057          * corruption detection.  Note that w_done is set to 1, indicating that
2058          * the write has been verified as complete.  We don't need to write the
2059          * filename on the second logging.
2060          */
2061
2062         if (w_opt && logged_write) {
2063                 wrec.w_done = 1;
2064                 wlog_record_write(&Wlog, &wrec, woffset);
2065         }
2066
2067         /*
2068          * Unlock file region if necessary
2069          */
2070
2071         if (got_lock) {
2072                 if (lock_file_region(file, fd, F_UNLCK,
2073                                      min_byte, (max_byte-min_byte+1)) < 0) {
2074                         alloc_mem(-1);
2075                         exit(E_INTERNAL);
2076                 }
2077         }
2078
2079         if(s->aioid != NULL)
2080                 free(s->aioid);
2081         free(s);
2082         return (rval == -1) ? -1 : 0;
2083 }
2084
2085
2086 /*
2087  * xfsctl-based requests
2088  *   - XFS_IOC_RESVSP
2089  *   - XFS_IOC_UNRESVSP
2090  */
2091 int
2092 do_xfsctl(req)
2093         struct io_req   *req;
2094 {
2095         int                     fd, oflags, offset, nbytes;
2096         int                     rval, op = 0;
2097         int                     got_lock;
2098         int                     min_byte = 0, max_byte = 0;
2099         char                    *file, *msg = NULL;
2100         struct xfs_flock64      flk;
2101
2102         /*
2103          * Initialize common fields - assumes r_oflags, r_file, r_offset, and
2104          * r_nbytes are at the same offset in the read_req and reada_req
2105          * structures.
2106          */
2107         file    = req->r_data.io.r_file;
2108         oflags  = req->r_data.io.r_oflags;
2109         offset  = req->r_data.io.r_offset;
2110         nbytes  = req->r_data.io.r_nbytes;
2111
2112         flk.l_type=0;
2113         flk.l_whence=SEEK_SET;
2114         flk.l_start=offset;
2115         flk.l_len=nbytes;
2116
2117         /*
2118          * Get an open file descriptor
2119          */
2120
2121         if ((fd = alloc_fd(file, oflags)) == -1)
2122                 return -1;
2123
2124         rval = 0;
2125         got_lock = 0;
2126
2127         /*
2128          * Lock data if this is locking option is set
2129          */
2130         if (k_opt) {
2131                 min_byte = offset;
2132                 max_byte = offset + nbytes;
2133
2134                 if (lock_file_region(file, fd, F_WRLCK,
2135                                      min_byte, (nbytes+1)) < 0) {
2136                     doio_fprintf(stderr, 
2137                                 "file lock failed:\n");
2138                     doio_fprintf(stderr, 
2139                                 "          buffer(req, %d, 0, 0x%x, 0x%x)\n",
2140                                 offset, min_byte, max_byte);
2141                     alloc_mem(-1);
2142                     exit(E_INTERNAL);
2143                 }
2144
2145                 got_lock = 1;
2146         }
2147
2148         switch (req->r_type) {
2149         case RESVSP:    op=XFS_IOC_RESVSP;      msg="resvsp";   break;
2150         case UNRESVSP:  op=XFS_IOC_UNRESVSP;    msg="unresvsp"; break;
2151         }
2152
2153         rval = xfsctl(file, fd, op, &flk);
2154
2155         if( rval == -1 ) {
2156                 doio_fprintf(stderr,
2157 "xfsctl %s request failed: %s (%d)\n\txfsctl(%d, %s %d, {%d %lld ==> %lld}\n",
2158                              msg, SYSERR, errno,
2159                              fd, msg, op, flk.l_whence, 
2160                              (long long)flk.l_start, 
2161                              (long long)flk.l_len);
2162
2163                 doio_upanic(U_RVAL);
2164                 rval = -1;
2165         }
2166
2167         /*
2168          * Unlock file region if necessary
2169          */
2170
2171         if (got_lock) {
2172                 if (lock_file_region(file, fd, F_UNLCK,
2173                                      min_byte, (max_byte-min_byte+1)) < 0) {
2174                         alloc_mem(-1);
2175                         exit(E_INTERNAL);
2176                 }
2177         }
2178
2179         return (rval == -1) ? -1 : 0;
2180 }
2181
2182 /*
2183  *  fsync(2) and fdatasync(2)
2184  */
2185 int
2186 do_sync(req)
2187         struct io_req   *req;
2188 {
2189         int                     fd, oflags;
2190         int                     rval;
2191         char                    *file;
2192
2193         /*
2194          * Initialize common fields - assumes r_oflags, r_file, r_offset, and
2195          * r_nbytes are at the same offset in the read_req and reada_req
2196          * structures.
2197          */
2198         file    = req->r_data.io.r_file;
2199         oflags  = req->r_data.io.r_oflags;
2200
2201         /*
2202          * Get an open file descriptor
2203          */
2204
2205         if ((fd = alloc_fd(file, oflags)) == -1)
2206                 return -1;
2207
2208         rval = 0;
2209         switch(req->r_type) {
2210         case FSYNC2:
2211                 rval = fsync(fd);
2212                 break;
2213         case FDATASYNC:
2214                 rval = fdatasync(fd);
2215                 break;
2216         default:
2217                 rval = -1;
2218         }
2219         return (rval == -1) ? -1 : 0;
2220 }
2221
2222 int
2223 doio_pat_fill(char *addr, int mem_needed, char *Pattern, int Pattern_Length,
2224               int shift)
2225 {
2226         return pattern_fill(addr, mem_needed, Pattern, Pattern_Length, 0);
2227 }
2228
2229 char *
2230 doio_pat_check(buf, offset, length, pattern, pattern_length, patshift)
2231 char    *buf;
2232 int     offset;
2233 int     length;
2234 char    *pattern;
2235 int     pattern_length;
2236 int     patshift;
2237 {
2238         static char     errbuf[4096];
2239         int             nb, i, pattern_index;
2240         char            *cp, *bufend, *ep;
2241         char            actual[33], expected[33];
2242
2243         if (pattern_check(buf, length, pattern, pattern_length, patshift) != 0) {
2244                 ep = errbuf;
2245                 ep += sprintf(ep, "Corrupt regions follow - unprintable chars are represented as '.'\n");
2246                 ep += sprintf(ep, "-----------------------------------------------------------------\n");
2247
2248                 pattern_index = patshift % pattern_length;;
2249                 cp = buf;
2250                 bufend = buf + length;
2251
2252                 while (cp < bufend) {
2253                         if (*cp != pattern[pattern_index]) {
2254                                 nb = bufend - cp;
2255                                 if (nb > sizeof(expected)-1) {
2256                                         nb = sizeof(expected)-1;
2257                                 }
2258                             
2259                                 ep += sprintf(ep, "corrupt bytes starting at file offset %d\n", offset + (int)(cp-buf));
2260
2261                                 /*
2262                                  * Fill in the expected and actual patterns
2263                                  */
2264                                 bzero(expected, sizeof(expected));
2265                                 bzero(actual, sizeof(actual));
2266
2267                                 for (i = 0; i < nb; i++) {
2268                                         expected[i] = pattern[(pattern_index + i) % pattern_length];
2269                                         if (! isprint((int)expected[i])) {
2270                                                 expected[i] = '.';
2271                                         }
2272
2273                                         actual[i] = cp[i];
2274                                         if (! isprint((int)actual[i])) {
2275                                                 actual[i] = '.';
2276                                         }
2277                                 }
2278
2279                                 ep += sprintf(ep, "    1st %2d expected bytes:  %s\n", nb, expected);
2280                                 ep += sprintf(ep, "    1st %2d actual bytes:    %s\n", nb, actual);
2281                                 fflush(stderr);
2282                                 return errbuf;
2283                         } else {
2284                                 cp++;
2285                                 pattern_index++;
2286
2287                                 if (pattern_index == pattern_length) {
2288                                         pattern_index = 0;
2289                                 }
2290                         }
2291                 }
2292                 return errbuf;
2293         }
2294
2295         return(NULL);
2296 }
2297
2298
2299 /*
2300  * Check the contents of a file beginning at offset, for length bytes.  It
2301  * is assumed that there is a string of pattern bytes in this area of the
2302  * file.  Use normal buffered reads to do the verification.
2303  *
2304  * If there is a data mismatch, write a detailed message into a static buffer
2305  * suitable for the caller to print.  Otherwise print NULL.
2306  *
2307  * The fsa flag is set to non-zero if the buffer should be read back through
2308  * the FSA (unicos/mk).  This implies the file will be opened
2309  * O_PARALLEL|O_RAW|O_WELLFORMED to do the validation.  We must do this because
2310  * FSA will not allow the file to be opened for buffered io if it was
2311  * previously opened for O_PARALLEL io.
2312  */
2313
2314 char *
2315 check_file(file, offset, length, pattern, pattern_length, patshift, fsa)
2316 char    *file;
2317 int     offset;
2318 int     length;
2319 char    *pattern;
2320 int     pattern_length;
2321 int     patshift;
2322 int     fsa;
2323 {
2324         static char     errbuf[4096];
2325         int             fd, nb, flags;
2326         char            *buf, *em, *ep;
2327         struct fd_cache *fdc;
2328
2329         buf = Memptr;
2330
2331         if (V_opt) {
2332                 flags = Validation_Flags | O_RDONLY;
2333         } else {
2334                 flags = O_RDONLY;
2335         }
2336
2337         if ((fd = alloc_fd(file, flags)) == -1) {
2338                 sprintf(errbuf,
2339                         "Could not open file %s with flags %#o (%s) for data comparison:  %s (%d)\n",
2340                         file, flags, format_oflags(flags),
2341                         SYSERR, errno);
2342                 return errbuf;
2343         }
2344
2345         if (lseek(fd, offset, SEEK_SET) == -1) {
2346                 sprintf(errbuf, 
2347                         "Could not lseek to offset %d in %s for verification:  %s (%d)\n",
2348                         offset, file, SYSERR, errno);
2349                 return errbuf;
2350         }
2351
2352         /* Guarantee a properly aligned address on Direct I/O */
2353         fdc = alloc_fdcache(file, flags);
2354         if( (flags & O_DIRECT) && ((long)buf % fdc->c_memalign != 0) ) {
2355                 buf += fdc->c_memalign - ((long)buf % fdc->c_memalign);
2356         }
2357
2358         if ((nb = read(fd, buf, length)) == -1) {
2359                 sprintf(errbuf,
2360                         "Could not read %d bytes from %s for verification:  %s (%d)\n\tread(%d, 0x%p, %d)\n\tbuf %% alignment(%d) = %ld\n",
2361                         length, file, SYSERR, errno,
2362                         fd, buf, length,
2363                         fdc->c_memalign, (long)buf % fdc->c_memalign);
2364                 return errbuf;
2365         }
2366
2367         if (nb != length) {
2368                 sprintf(errbuf,
2369                         "Read wrong # bytes from %s.  Expected %d, got %d\n",
2370                         file, length, nb);
2371                 return errbuf;
2372         }
2373     
2374         if( (em = (*Data_Check)(buf, offset, length, pattern, pattern_length, patshift)) != NULL ) {
2375                 ep = errbuf;
2376                 ep += sprintf(ep, "*** DATA COMPARISON ERROR ***\n");
2377                 ep += sprintf(ep, "check_file(%s, %d, %d, %s, %d, %d) failed\n\n",
2378                               file, offset, length, pattern, pattern_length, patshift);
2379                 ep += sprintf(ep, "Comparison fd is %d, with open flags %#o\n",
2380                               fd, flags);
2381                 strcpy(ep, em);
2382                 return(errbuf);
2383         }
2384         return NULL;
2385 }
2386
2387 /*
2388  * Function to single-thread stdio output.
2389  */
2390
2391 int
2392 doio_fprintf(FILE *stream, char *format, ...)
2393 {
2394         static int      pid = -1;
2395         char            *date;
2396         int             rval;
2397         struct flock    flk;
2398         va_list         arglist;
2399
2400         date = hms(time(0));
2401
2402         if (pid == -1) {
2403                 pid = getpid();
2404         }
2405
2406         flk.l_whence = flk.l_start = flk.l_len = 0;
2407         flk.l_type = F_WRLCK;
2408         fcntl(fileno(stream), F_SETLKW, &flk);
2409
2410         va_start(arglist, format);
2411         rval = fprintf(stream, "\n%s%s (%5d) %s\n", Prog, TagName, pid, date);
2412         rval += fprintf(stream, "---------------------\n");
2413         vfprintf(stream, format, arglist);
2414         va_end(arglist);
2415
2416         fflush(stream);
2417
2418         flk.l_type = F_UNLCK;
2419         fcntl(fileno(stream), F_SETLKW, &flk);
2420  
2421         return rval;
2422 }
2423
2424 /*
2425  * Simple function for allocating core memory.  Uses Memsize and Memptr to
2426  * keep track of the current amount allocated.
2427  */
2428
2429 int
2430 alloc_mem(nbytes)
2431 int nbytes;
2432 {
2433         char            *cp;
2434         void            *addr;
2435         int             me = 0, flags, key, shmid;
2436         static int      mturn = 0;      /* which memory type to use */
2437         struct memalloc *M;
2438         char            filename[255];
2439 #ifdef linux
2440         struct shmid_ds shm_ds;
2441         bzero( &shm_ds, sizeof(struct shmid_ds) );
2442 #endif
2443
2444         /* nbytes = -1 means "free all allocated memory" */
2445         if( nbytes == -1 ) {
2446
2447                 for(me=0; me < Nmemalloc; me++) {
2448                         if(Memalloc[me].space == NULL)
2449                                 continue;
2450
2451                         switch(Memalloc[me].memtype) {
2452                         case MEM_DATA:
2453                                 free(Memalloc[me].space);
2454                                 Memalloc[me].space = NULL;
2455                                 Memptr = NULL;
2456                                 Memsize = 0;
2457                                 break;
2458                         case MEM_SHMEM:
2459                                 shmdt(Memalloc[me].space);
2460                                 Memalloc[me].space = NULL;
2461                                 shmctl(Memalloc[me].fd, IPC_RMID, &shm_ds);
2462                                 break;
2463                         case MEM_MMAP:
2464                                 munmap(Memalloc[me].space, 
2465                                        Memalloc[me].size);
2466                                 close(Memalloc[me].fd);
2467                                 if(Memalloc[me].flags & MEMF_FILE) {
2468                                         unlink(Memalloc[me].name);
2469                                 }
2470                                 Memalloc[me].space = NULL;
2471                                 break;
2472                         default:
2473                                 doio_fprintf(stderr, "alloc_mem: HELP! Unknown memory space type %d index %d\n",
2474                                              Memalloc[me].memtype, me);
2475                                 break;
2476                         }
2477                 }
2478                 return 0;
2479         }
2480
2481         /*
2482          * Select a memory area (currently round-robbin)
2483          */
2484
2485         if(mturn >= Nmemalloc)
2486                 mturn=0;
2487
2488         M = &Memalloc[mturn];
2489
2490         switch(M->memtype) {
2491         case MEM_DATA:
2492                 if( nbytes > M->size ) {
2493                         if( M->space != NULL ){
2494                                 free(M->space);
2495                         }
2496                         M->space = NULL;
2497                         M->size = 0;
2498                 }
2499
2500                 if( M->space == NULL ) {
2501                         if( (cp = malloc( nbytes )) == NULL ) {
2502                                 doio_fprintf(stderr, "malloc(%d) failed:  %s (%d)\n",
2503                                              nbytes, SYSERR, errno);
2504                                 return -1;
2505                         }
2506                         M->space = (void *)cp;
2507                         M->size = nbytes;
2508                 }
2509                 break;
2510
2511         case MEM_MMAP:
2512                 if( nbytes > M->size ) {
2513                         if( M->space != NULL ) {
2514                                 munmap(M->space, M->size);
2515                                 close(M->fd);
2516                                 if( M->flags & MEMF_FILE )
2517                                         unlink( M->name );
2518                         }
2519                         M->space = NULL;
2520                         M->size = 0;
2521                 }
2522
2523                 if( M->space == NULL ) {
2524                         if(strchr(M->name, '%')) {
2525                                 sprintf(filename, M->name, getpid());
2526                                 M->name = strdup(filename);
2527                         }
2528
2529                         if( (M->fd = open(M->name, O_CREAT|O_RDWR, 0666)) == -1) {
2530                                 doio_fprintf(stderr, "alloc_mmap: error %d (%s) opening '%s'\n",
2531                                              errno, SYSERR, 
2532                                              M->name);
2533                                 return(-1);
2534                         }
2535
2536                         addr = NULL;
2537                         flags = 0;
2538                         M->size = nbytes * 4;
2539
2540                         /* bias addr if MEMF_ADDR | MEMF_FIXADDR */
2541                         /* >>> how to pick a memory address? */
2542
2543                         /* bias flags on MEMF_PRIVATE etc */
2544                         if(M->flags & MEMF_PRIVATE)
2545                                 flags |= MAP_PRIVATE;
2546                         if(M->flags & MEMF_SHARED)
2547                                 flags |= MAP_SHARED;
2548
2549 /*printf("alloc_mem, about to mmap, fd=%d, name=(%s)\n", M->fd, M->name);*/
2550                         if( (M->space = mmap(addr, M->size,
2551                                              PROT_READ|PROT_WRITE,
2552                                              flags, M->fd, 0))
2553                             == MAP_FAILED) {
2554                                 doio_fprintf(stderr, "alloc_mem: mmap error. errno %d (%s)\n\tmmap(addr 0x%x, size %d, read|write 0x%x, mmap flags 0x%x [%#o], fd %d, 0)\n\tfile %s\n",
2555                                              errno, SYSERR,
2556                                              addr, M->size,
2557                                              PROT_READ|PROT_WRITE,
2558                                              flags, M->flags, M->fd,
2559                                              M->name);
2560                                 doio_fprintf(stderr, "\t%s%s%s%s%s",
2561                                              (flags & MAP_PRIVATE) ? "private " : "",
2562                                              (flags & MAP_SHARED) ? "shared" : "");
2563                                 return(-1);
2564                         }
2565                 }
2566                 break;
2567                 
2568         case MEM_SHMEM:
2569                 if( nbytes > M->size ) {
2570                         if( M->space != NULL ) {
2571                                 shmctl( M->fd, IPC_RMID, &shm_ds );
2572                         }
2573                         M->space = NULL;
2574                         M->size = 0;
2575                 }
2576
2577                 if(M->space == NULL) {
2578                         if(!strcmp(M->name, "private")) {
2579                                 key = IPC_PRIVATE;
2580                         } else {
2581                                 sscanf(M->name, "%i", &key);
2582                         }
2583
2584                         M->size = M->nblks ? M->nblks * 512 : nbytes;
2585
2586                         if( nbytes > M->size ){
2587 #ifdef DEBUG
2588                                 doio_fprintf(stderr, "MEM_SHMEM: nblks(%d) too small:  nbytes=%d  Msize=%d, skipping this req.\n",
2589                                              M->nblks, nbytes, M->size );
2590 #endif
2591                                 return SKIP_REQ;
2592                         }
2593
2594                         shmid = shmget(key, M->size, IPC_CREAT|0666);
2595                         if( shmid == -1 ) {
2596                                 doio_fprintf(stderr, "shmget(0x%x, %d, CREAT) failed: %s (%d)\n",
2597                                              key, M->size, SYSERR, errno);
2598                                 return(-1);
2599                         }
2600                         M->fd = shmid;
2601                         M->space = shmat(shmid, NULL, SHM_RND);
2602                         if( M->space == (void *)-1 ) {
2603                                 doio_fprintf(stderr, "shmat(0x%x, NULL, SHM_RND) failed: %s (%d)\n", 
2604                                              shmid, SYSERR, errno);
2605                                 return(-1);
2606                         }
2607                 }
2608                 break;
2609
2610         default:
2611                 doio_fprintf(stderr, "alloc_mem: HELP! Unknown memory space type %d index %d\n",
2612                              Memalloc[me].memtype, mturn);
2613                 break;
2614         }
2615
2616         Memptr = M->space;
2617         Memsize = M->size;
2618
2619         mturn++;
2620         return 0;
2621 }
2622
2623 /*
2624  * Function to maintain a file descriptor cache, so that doio does not have
2625  * to do so many open() and close() calls.  Descriptors are stored in the
2626  * cache by file name, and open flags.  Each entry also has a _rtc value
2627  * associated with it which is used in aging.  If doio cannot open a file
2628  * because it already has too many open (ie. system limit hit) it will close
2629  * the one in the cache that has the oldest _rtc value.
2630  *
2631  * If alloc_fd() is called with a file of NULL, it will close all descriptors
2632  * in the cache, and free the memory in the cache.
2633  */
2634
2635 int
2636 alloc_fd(file, oflags)
2637 char    *file;
2638 int     oflags;
2639 {
2640         struct fd_cache *fdc;
2641         struct fd_cache *alloc_fdcache(char *file, int oflags);
2642
2643         fdc = alloc_fdcache(file, oflags);
2644         if(fdc != NULL)
2645                 return(fdc->c_fd);
2646         else
2647                 return(-1);
2648 }
2649
2650 struct fd_cache *
2651 alloc_fdcache(file, oflags)
2652 char    *file;
2653 int     oflags;
2654 {
2655         int                     fd;
2656         struct fd_cache         *free_slot, *oldest_slot, *cp;
2657         static int              cache_size = 0;
2658         static struct fd_cache  *cache = NULL;
2659         struct dioattr  finfo;
2660
2661         /*
2662          * If file is NULL, it means to free up the fd cache.
2663          */
2664
2665         if (file == NULL && cache != NULL) {
2666                 for (cp = cache; cp < &cache[cache_size]; cp++) {
2667                         if (cp->c_fd != -1) {
2668                                 close(cp->c_fd);
2669                         }
2670                         if (cp->c_memaddr != NULL) {
2671                                 munmap(cp->c_memaddr, cp->c_memlen);
2672                         }
2673                 }
2674
2675                 free(cache);
2676                 cache = NULL;
2677                 cache_size = 0;
2678                 return 0;
2679         }
2680
2681         free_slot = NULL;
2682         oldest_slot = NULL;
2683
2684         /*
2685          * Look for a fd in the cache.  If one is found, return it directly.
2686          * Otherwise, when this loop exits, oldest_slot will point to the
2687          * oldest fd slot in the cache, and free_slot will point to an
2688          * unoccupied slot if there are any.
2689          */
2690
2691         for (cp = cache; cp != NULL && cp < &cache[cache_size]; cp++) {
2692                 if (cp->c_fd != -1 &&
2693                     cp->c_oflags == oflags &&
2694                     strcmp(cp->c_file, file) == 0) {
2695                         cp->c_rtc = Reqno;
2696                         return cp;
2697                 }
2698
2699                 if (cp->c_fd == -1) {
2700                         if (free_slot == NULL) {
2701                                 free_slot = cp;
2702                         }
2703                 } else {
2704                         if (oldest_slot == NULL || 
2705                             cp->c_rtc < oldest_slot->c_rtc) {
2706                                 oldest_slot = cp;
2707                         }
2708                 }
2709         }
2710
2711         /*
2712          * No matching file/oflags pair was found in the cache.  Attempt to
2713          * open a new fd.
2714          */
2715
2716         if ((fd = open(file, oflags, 0666)) < 0) {
2717                 if (errno != EMFILE) {
2718                         doio_fprintf(stderr,
2719                                      "Could not open file %s with flags %#o (%s): %s (%d)\n",
2720                                      file, oflags, format_oflags(oflags),
2721                                      SYSERR, errno);
2722                         alloc_mem(-1);
2723                         exit(E_SETUP);
2724                 }
2725
2726                 /*
2727                  * If we get here, we have as many open fd's as we can have.
2728                  * Close the oldest one in the cache (pointed to by
2729                  * oldest_slot), and attempt to re-open.
2730                  */
2731
2732                 close(oldest_slot->c_fd);
2733                 oldest_slot->c_fd = -1;
2734                 free_slot = oldest_slot;
2735
2736                 if ((fd = open(file, oflags, 0666)) < 0) {
2737                         doio_fprintf(stderr,
2738                                      "Could not open file %s with flags %#o (%s):  %s (%d)\n",
2739                                      file, oflags, format_oflags(oflags),
2740                                      SYSERR, errno);
2741                         alloc_mem(-1);
2742                         exit(E_SETUP);
2743                 }
2744         }
2745
2746 /*printf("alloc_fd: new file %s flags %#o fd %d\n", file, oflags, fd);*/
2747
2748         /*
2749          * If we get here, fd is our open descriptor.  If free_slot is NULL,
2750          * we need to grow the cache, otherwise free_slot is the slot that
2751          * should hold the fd info.
2752          */
2753
2754         if (free_slot == NULL) {
2755                 cache = (struct fd_cache *)realloc(cache, sizeof(struct fd_cache) * (FD_ALLOC_INCR + cache_size));
2756                 if (cache == NULL) {
2757                         doio_fprintf(stderr, "Could not malloc() space for fd chace");
2758                         alloc_mem(-1);
2759                         exit(E_SETUP);
2760                 }
2761
2762                 cache_size += FD_ALLOC_INCR;
2763
2764                 for (cp = &cache[cache_size-FD_ALLOC_INCR];
2765                      cp < &cache[cache_size]; cp++) {
2766                         cp->c_fd = -1;
2767                 }
2768
2769                 free_slot = &cache[cache_size - FD_ALLOC_INCR];
2770         }
2771
2772         /*
2773          * finally, fill in the cache slot info
2774          */
2775
2776         free_slot->c_fd = fd;
2777         free_slot->c_oflags = oflags;
2778         strcpy(free_slot->c_file, file);
2779         free_slot->c_rtc = Reqno;
2780
2781         if (oflags & O_DIRECT) {
2782                 if (xfsctl(file, fd, XFS_IOC_DIOINFO, &finfo) == -1) {
2783                         finfo.d_mem = 1;
2784                         finfo.d_miniosz = 1;
2785                         finfo.d_maxiosz = 1;
2786                 }
2787         } else {
2788                 finfo.d_mem = 1;
2789                 finfo.d_miniosz = 1;
2790                 finfo.d_maxiosz = 1;
2791         }
2792
2793         free_slot->c_memalign = finfo.d_mem;
2794         free_slot->c_miniosz = finfo.d_miniosz;
2795         free_slot->c_maxiosz = finfo.d_maxiosz;
2796         free_slot->c_memaddr = NULL;
2797         free_slot->c_memlen = 0;
2798
2799         return free_slot;
2800 }
2801
2802 /*
2803  *
2804  *                      Signal Handling Section
2805  *
2806  *
2807  */
2808
2809 void
2810 cleanup_handler()
2811 {
2812         havesigint=1; /* in case there's a followup signal */
2813         alloc_mem(-1);
2814         exit(0);
2815 }
2816
2817 void
2818 die_handler(sig)
2819 int sig;
2820 {
2821         doio_fprintf(stderr, "terminating on signal %d\n", sig);
2822         alloc_mem(-1);
2823         exit(1);
2824 }
2825
2826 void
2827 sigbus_handler(sig)
2828 int sig;
2829 {
2830         /* See sigbus_handler() in the 'ifdef sgi' case for details.  Here,
2831            we don't have the siginfo stuff so the guess is weaker but we'll
2832            do it anyway.
2833         */
2834
2835         if( active_mmap_rw && havesigint )
2836                 cleanup_handler();
2837         else
2838                 die_handler(sig);
2839 }
2840
2841 void
2842 noop_handler(sig)
2843 int sig;
2844 {
2845         return;
2846 }
2847
2848
2849 /*
2850  * SIGINT handler for the parent (original doio) process.  It simply sends
2851  * a SIGINT to all of the doio children.  Since they're all in the same
2852  * pgrp, this can be done with a single kill().
2853  */
2854
2855 void
2856 sigint_handler()
2857 {
2858         int     i;
2859
2860         for (i = 0; i < Nchildren; i++) {
2861                 if (Children[i] != -1) {
2862                         kill(Children[i], SIGINT);
2863                 }
2864         }
2865 }
2866
2867 /*
2868  * Signal handler used to inform a process when async io completes.  Referenced
2869  * in do_read() and do_write().  Note that the signal handler is not
2870  * re-registered.
2871  */
2872
2873 void
2874 aio_handler(sig)
2875 int     sig;
2876 {
2877         int             i;
2878         struct aio_info *aiop;
2879
2880         for (i = 0; i < sizeof(Aio_Info) / sizeof(Aio_Info[0]); i++) {
2881                 aiop = &Aio_Info[i];
2882
2883                 if (aiop->strategy == A_SIGNAL && aiop->sig == sig) {
2884                         aiop->signalled++;
2885
2886                         if (aio_done(aiop)) {
2887                                 aiop->done++;
2888                         }
2889                 }
2890         }
2891 }
2892
2893 /*
2894  * dump info on all open aio slots
2895  */
2896 void
2897 dump_aio()
2898 {
2899         int             i, count;
2900
2901         count=0;
2902         for (i = 0; i < sizeof(Aio_Info) / sizeof(Aio_Info[0]); i++) {
2903                 if (Aio_Info[i].busy) {
2904                         count++;
2905                         fprintf(stderr,
2906                                 "Aio_Info[%03d] id=%d fd=%d signal=%d signaled=%d\n",
2907                                 i, Aio_Info[i].id,
2908                                 Aio_Info[i].fd,
2909                                 Aio_Info[i].sig,
2910                                 Aio_Info[i].signalled);
2911                         fprintf(stderr, "\tstrategy=%s\n",
2912                                 format_strat(Aio_Info[i].strategy));
2913                 }
2914         }
2915         fprintf(stderr, "%d active async i/os\n", count);
2916 }
2917
2918 struct aio_info *
2919 aio_slot(aio_id)
2920 int     aio_id;
2921 {
2922         int             i;
2923         static int      id = 1;
2924         struct aio_info *aiop;
2925
2926         aiop = NULL;
2927
2928         for (i = 0; i < sizeof(Aio_Info) / sizeof(Aio_Info[0]); i++) {
2929                 if (aio_id == -1) {
2930                         if (! Aio_Info[i].busy) {
2931                                 aiop = &Aio_Info[i];
2932                                 aiop->busy = 1;
2933                                 aiop->id = id++;
2934                                 break;
2935                         }
2936                 } else {
2937                         if (Aio_Info[i].busy && Aio_Info[i].id == aio_id) {
2938                                 aiop = &Aio_Info[i];
2939                                 break;
2940                         }
2941                 }
2942         }
2943
2944         if( aiop == NULL ){
2945                 doio_fprintf(stderr,"aio_slot(%d) not found.  Request %d\n", 
2946                              aio_id, Reqno);
2947                 dump_aio();
2948                 alloc_mem(-1);
2949                 exit(E_INTERNAL);
2950         }
2951
2952         return aiop;
2953 }
2954
2955 int
2956 aio_register(fd, strategy, sig)
2957 int             fd;
2958 int             strategy;
2959 int             sig;
2960 {
2961         struct aio_info         *aiop;
2962         void                    aio_handler();
2963         struct sigaction        sa;
2964
2965         aiop = aio_slot(-1);
2966
2967         aiop->fd = fd;
2968         aiop->strategy = strategy;
2969         aiop->done = 0;
2970
2971         if (strategy == A_SIGNAL) {
2972                 aiop->sig = sig;
2973                 aiop->signalled = 0;
2974
2975                 sa.sa_handler = aio_handler;
2976                 sa.sa_flags = 0;
2977                 sigemptyset(&sa.sa_mask);
2978
2979                 sigaction(sig, &sa, &aiop->osa);
2980         } else {
2981                 aiop->sig = -1;
2982                 aiop->signalled = 0;
2983         }
2984
2985         return aiop->id;
2986 }
2987
2988 int
2989 aio_unregister(aio_id)
2990 int     aio_id;
2991 {
2992         struct aio_info *aiop;
2993
2994         aiop = aio_slot(aio_id);
2995
2996         if (aiop->strategy == A_SIGNAL) {
2997                 sigaction(aiop->sig, &aiop->osa, NULL);
2998         }
2999
3000         aiop->busy = 0;
3001         return 0;
3002 }
3003
3004 #ifndef linux
3005 int
3006 aio_wait(aio_id)
3007 int     aio_id;
3008 {
3009 #ifdef RECALL_SIZEOF
3010         long            mask[RECALL_SIZEOF];
3011 #endif
3012         sigset_t        sigset;
3013         struct aio_info *aiop;
3014
3015 /*printf("aio_wait: errno %d return %d\n", aiop->aio_errno, aiop->aio_ret);*/
3016
3017         return 0;
3018 }
3019 #endif /* !linux */
3020
3021 /*
3022  * Format specified time into HH:MM:SS format.  t is the time to format
3023  * in seconds (as returned from time(2)).
3024  */
3025
3026 char *
3027 hms(t)
3028 time_t  t;
3029 {
3030         static char     ascii_time[9];
3031         struct tm       *ltime;
3032
3033         ltime = localtime(&t);
3034         strftime(ascii_time, sizeof(ascii_time), "%H:%M:%S", ltime);
3035
3036         return ascii_time;
3037 }
3038
3039 /*
3040  * Simple routine to check if an async io request has completed.
3041  */
3042
3043 int
3044 aio_done(struct aio_info *ainfo)
3045 {
3046         return -1;   /* invalid */
3047 }
3048
3049 /*
3050  * Routine to handle upanic() - it first attempts to set the panic flag.  If
3051  * the flag cannot be set, an error message is issued.  A call to upanic
3052  * with PA_PANIC is then done unconditionally, in case the panic flag was set
3053  * from outside the program (as with the panic(8) program).
3054  *
3055  * Note - we only execute the upanic code if -U was used, and the passed in
3056  * mask is set in the Upanic_Conditions bitmask.
3057  */
3058
3059 void
3060 doio_upanic(mask)
3061 int     mask;
3062 {
3063         if (U_opt == 0 || (mask & Upanic_Conditions) == 0) {
3064                 return;
3065         }
3066         doio_fprintf(stderr, "WARNING - upanic() failed\n");
3067 }
3068
3069 /*
3070  * Parse cmdline options/arguments and set appropriate global variables.
3071  * If the cmdline is valid, return 0 to caller.  Otherwise exit with a status
3072  * of 1.
3073  */
3074
3075 int
3076 parse_cmdline(argc, argv, opts)
3077 int     argc;
3078 char    **argv;
3079 char    *opts;
3080 {
3081         int             c;
3082         char            cc, *cp, *tok = NULL;
3083         extern int      opterr;
3084         extern int      optind;
3085         extern char     *optarg;
3086         struct smap     *s;
3087         char            *memargs[NMEMALLOC];
3088         int             nmemargs, ma;
3089         void            parse_memalloc(char *arg);
3090         void            parse_delay(char *arg);
3091         void            dump_memalloc();
3092
3093         if (*argv[0] == '-') {
3094                 argv[0]++;
3095                 Execd = 1;
3096         }
3097         
3098         if ((Prog = strrchr(argv[0], '/')) == NULL) {
3099                 Prog = argv[0];
3100         } else {
3101                 Prog++;
3102         }
3103         
3104         opterr = 0;
3105         while ((c = getopt(argc, argv, opts)) != EOF) {
3106                 switch ((char)c) {
3107                 case 'a':
3108                         a_opt++;
3109                         break;
3110
3111                 case 'C':
3112                         C_opt++;
3113                         for(s=checkmap; s->string != NULL; s++)
3114                                 if(!strcmp(s->string, optarg))
3115                                         break;
3116                         if (s->string == NULL) {
3117                                 fprintf(stderr,
3118                                         "%s%s:  Illegal -C arg (%s).  Must be one of: ", 
3119                                         Prog, TagName, tok);
3120
3121                                 for (s = checkmap; s->string != NULL; s++)
3122                                         fprintf(stderr, "%s ", s->string);
3123                                 fprintf(stderr, "\n");
3124                                 exit(1);
3125                         }
3126
3127                         switch(s->value) {
3128                         case C_DEFAULT:
3129                                 Data_Fill = doio_pat_fill;
3130                                 Data_Check = doio_pat_check;
3131                                 break;
3132                         default:
3133                                 fprintf(stderr,
3134                                         "%s%s:  Unrecognised -C arg '%s' %d", 
3135                                         Prog, TagName, s->string, s->value);
3136                                 exit(1);
3137                         }
3138                         break;
3139
3140                 case 'd':       /* delay between i/o ops */
3141                         parse_delay(optarg);
3142                         break;
3143
3144                 case 'e':
3145                         if (Npes > 1 && Nprocs > 1) {
3146                                 fprintf(stderr, "%s%s:  Warning - Program is a multi-pe application - exec option is ignored.\n", Prog, TagName);
3147                         }
3148                         e_opt++;
3149                         break;
3150
3151                 case 'h':
3152                         help(stdout);
3153                         exit(0);
3154                         break;
3155
3156                 case 'k':
3157                         k_opt++;
3158                         break;
3159
3160                 case 'm':
3161                         Message_Interval = strtol(optarg, &cp, 10);
3162                         if (*cp != '\0' || Message_Interval < 0) {
3163                                 fprintf(stderr, "%s%s:  Illegal -m arg (%s):  Must be an integer >= 0\n", Prog, TagName, optarg);
3164                                 exit(1);
3165                         }
3166                         m_opt++;
3167                         break;
3168
3169                 case 'M':       /* memory allocation types */
3170                         nmemargs = string_to_tokens(optarg, memargs, 32, ",");
3171                         for(ma=0; ma < nmemargs; ma++) {
3172                                 parse_memalloc(memargs[ma]);
3173                         }
3174                         /*dump_memalloc();*/
3175                         M_opt++;
3176                         break;
3177
3178                 case 'N':
3179                         sprintf( TagName, "(%.39s)", optarg );
3180                         break;
3181
3182                 case 'n':
3183                         Nprocs = strtol(optarg, &cp, 10);
3184                         if (*cp != '\0' || Nprocs < 1) {
3185                                 fprintf(stderr,
3186                                         "%s%s:  Illegal -n arg (%s):  Must be integer > 0\n",
3187                                         Prog, TagName, optarg);
3188                                 exit(E_USAGE);
3189                         }
3190
3191                         if (Npes > 1 && Nprocs > 1) {
3192                                 fprintf(stderr, "%s%s:  Program has been built as a multi-pe app.  -n1 is the only nprocs value allowed\n", Prog, TagName);
3193                                 exit(E_SETUP);
3194                         }
3195                         n_opt++;
3196                         break;
3197
3198                 case 'r':
3199                         Release_Interval = strtol(optarg, &cp, 10);
3200                         if (*cp != '\0' || Release_Interval < 0) {
3201                                 fprintf(stderr,
3202                                         "%s%s:  Illegal -r arg (%s):  Must be integer >= 0\n",
3203                                         Prog, TagName, optarg);
3204                                 exit(E_USAGE);
3205                         }
3206
3207                         r_opt++;
3208                         break;
3209
3210                 case 'w':
3211                         Write_Log = optarg;
3212                         w_opt++;
3213                         break;
3214
3215                 case 'v':
3216                         v_opt++;
3217                         break;
3218
3219                 case 'V':
3220                         if (strcasecmp(optarg, "sync") == 0) {
3221                                 Validation_Flags = O_SYNC;
3222                         } else if (strcasecmp(optarg, "buffered") == 0) {
3223                                 Validation_Flags = 0;
3224                         } else if (strcasecmp(optarg, "direct") == 0) {
3225                                 Validation_Flags = O_DIRECT;
3226                         } else {
3227                                 if (sscanf(optarg, "%i%c", &Validation_Flags, &cc) != 1) {
3228                                         fprintf(stderr, "%s:  Invalid -V argument (%s) - must be a decimal, hex, or octal\n", Prog, optarg);
3229                                         fprintf(stderr, "    number, or one of the following strings:  'sync',\n");
3230                                         fprintf(stderr, "    'buffered', 'parallel', 'ldraw', or 'raw'\n");
3231                                         exit(E_USAGE);
3232                                 }
3233                         }
3234                         V_opt++;
3235                         break;
3236                 case 'U':
3237                         tok = strtok(optarg, ",");
3238                         while (tok != NULL) {
3239                                 for (s = Upanic_Args; s->string != NULL; s++)
3240                                         if (strcmp(s->string, tok) == 0)
3241                                                 break;
3242
3243                                 if (s->string == NULL) {
3244                                         fprintf(stderr,
3245                                                 "%s%s:  Illegal -U arg (%s).  Must be one of: ", 
3246                                                 Prog, TagName, tok);
3247
3248                                         for (s = Upanic_Args; s->string != NULL; s++)
3249                                                 fprintf(stderr, "%s ", s->string);
3250
3251                                         fprintf(stderr, "\n");
3252
3253                                         exit(1);
3254                                 }
3255
3256                                 Upanic_Conditions |= s->value;
3257                                 tok = strtok(NULL, ",");
3258                         }
3259
3260                         U_opt++;
3261                         break;
3262
3263                 case '?':
3264                         usage(stderr);
3265                         exit(E_USAGE);
3266                         break;
3267                 }
3268         }
3269         
3270         /*
3271          * Supply defaults
3272          */
3273         
3274         if (! C_opt) {
3275                 Data_Fill = doio_pat_fill;
3276                 Data_Check = doio_pat_check;
3277         }
3278
3279         if (! U_opt)
3280                 Upanic_Conditions = 0;
3281
3282         if (! n_opt)
3283                 Nprocs = 1;
3284         
3285         if (! r_opt)
3286                 Release_Interval = DEF_RELEASE_INTERVAL;
3287
3288         if (! M_opt) {
3289                 Memalloc[Nmemalloc].memtype = MEM_DATA;
3290                 Memalloc[Nmemalloc].flags = 0;
3291                 Memalloc[Nmemalloc].name = NULL;
3292                 Memalloc[Nmemalloc].space = NULL;
3293                 Nmemalloc++;
3294         }
3295
3296         /*
3297          * Initialize input stream
3298          */
3299
3300         if (argc == optind) {
3301                 Infile = NULL;
3302         } else {
3303                 Infile = argv[optind++];
3304         }
3305
3306         if (argc != optind) {
3307                 usage(stderr);
3308                 exit(E_USAGE);
3309         }
3310
3311         return 0;
3312 }       
3313
3314
3315
3316 /*
3317  * Parse memory allocation types
3318  *
3319  * Types are:
3320  *  Data
3321  *  T3E-shmem:blksize[:nblks]
3322  *  SysV-shmem:shmid:blksize:nblks
3323  *      if shmid is "private", use IPC_PRIVATE
3324  *      and nblks is not required
3325  *
3326  *  mmap:flags:filename:blksize[:nblks]
3327  *   flags are one of:
3328  *      p - private (MAP_PRIVATE)
3329  *      a - private, MAP_AUTORESRV
3330  *      l - local (MAP_LOCAL)
3331  *      s - shared (nblks required)
3332  *
3333  *   plus any of:
3334  *      f - fixed address (MAP_FIXED)
3335  *      A - use an address without MAP_FIXED
3336  *      a - autogrow (map once at startup)
3337  *
3338  *  mmap:flags:devzero
3339  *      mmap /dev/zero  (shared not allowd)
3340  *      maps the first 4096 bytes of /dev/zero
3341  *
3342  * - put a directory at the beginning of the shared
3343  *   regions saying what pid has what region.
3344  *      DIRMAGIC
3345  *      BLKSIZE
3346  *      NBLKS
3347  *      nblks worth of directories - 1 int pids
3348  */
3349 void
3350 parse_memalloc(char *arg)
3351 {
3352         char            *allocargs[NMEMALLOC];
3353         int             nalloc;
3354         struct memalloc *M;
3355
3356         if(Nmemalloc >= NMEMALLOC) {
3357                 doio_fprintf(stderr, "Error - too many memory types (%d).\n", 
3358                         Nmemalloc);
3359                 return;
3360         }
3361
3362         M = &Memalloc[Nmemalloc];
3363
3364         nalloc = string_to_tokens(arg, allocargs, 32, ":");
3365         if(!strcmp(allocargs[0], "data")) {
3366                 M->memtype = MEM_DATA;
3367                 M->flags = 0;
3368                 M->name = NULL;
3369                 M->space = NULL;
3370                 Nmemalloc++;
3371                 if(nalloc >= 2) {
3372                         if(strchr(allocargs[1], 'p'))
3373                                 M->flags |= MEMF_MPIN;
3374                 }
3375         } else if(!strcmp(allocargs[0], "mmap")) {
3376                 /* mmap:flags:filename[:size] */
3377                 M->memtype = MEM_MMAP;
3378                 M->flags = 0;
3379                 M->space = NULL;
3380                 if(nalloc >= 1) {
3381                         if(strchr(allocargs[1], 'p'))
3382                                 M->flags |= MEMF_PRIVATE;
3383                         if(strchr(allocargs[1], 'a'))
3384                                 M->flags |= MEMF_AUTORESRV;
3385                         if(strchr(allocargs[1], 'l'))
3386                                 M->flags |= MEMF_LOCAL;
3387                         if(strchr(allocargs[1], 's'))
3388                                 M->flags |= MEMF_SHARED;
3389
3390                         if(strchr(allocargs[1], 'f'))
3391                                 M->flags |= MEMF_FIXADDR;
3392                         if(strchr(allocargs[1], 'A'))
3393                                 M->flags |= MEMF_ADDR;
3394                         if(strchr(allocargs[1], 'G'))
3395                                 M->flags |= MEMF_AUTOGROW;
3396
3397                         if(strchr(allocargs[1], 'U'))
3398                                 M->flags |= MEMF_FILE;
3399                 } else {
3400                         M->flags |= MEMF_PRIVATE;
3401                 }
3402
3403                 if(nalloc > 2) {
3404                         if(!strcmp(allocargs[2], "devzero")) {
3405                                 M->name = "/dev/zero";
3406                                 if(M->flags & 
3407                                    ((MEMF_PRIVATE|MEMF_LOCAL) == 0))
3408                                         M->flags |= MEMF_PRIVATE;
3409                         } else {
3410                                 M->name = allocargs[2];
3411                         }
3412                 } else {
3413                         M->name = "/dev/zero";
3414                         if(M->flags & 
3415                            ((MEMF_PRIVATE|MEMF_LOCAL) == 0))
3416                                 M->flags |= MEMF_PRIVATE;
3417                 }
3418                 Nmemalloc++;
3419
3420         } else if(!strcmp(allocargs[0], "shmem")) {
3421                 /* shmem:shmid:size */
3422                 M->memtype = MEM_SHMEM;
3423                 M->flags = 0;
3424                 M->space = NULL;
3425                 if(nalloc >= 2) {
3426                         M->name = allocargs[1];
3427                 } else {
3428                         M->name = NULL;
3429                 }
3430                 if(nalloc >= 3) {
3431                         sscanf(allocargs[2], "%i", &M->nblks);
3432                 } else {
3433                         M->nblks = 0;
3434                 }
3435                 if(nalloc >= 4) {
3436                         if(strchr(allocargs[3], 'p'))
3437                                 M->flags |= MEMF_MPIN;
3438                 }
3439
3440                 Nmemalloc++;
3441         } else {
3442                 doio_fprintf(stderr, "Error - unknown memory type '%s'.\n",
3443                         allocargs[0]);
3444                 exit(1);
3445         }
3446 }
3447
3448 void
3449 dump_memalloc()
3450 {
3451         int     ma;
3452         char    *mt;
3453
3454         if(Nmemalloc == 0) {
3455                 printf("No memory allocation strategies devined\n");
3456                 return;
3457         }
3458
3459         for(ma=0; ma < Nmemalloc; ma++) {
3460                 switch(Memalloc[ma].memtype) {
3461                 case MEM_DATA:  mt = "data";    break;
3462                 case MEM_SHMEM: mt = "shmem";   break;
3463                 case MEM_MMAP:  mt = "mmap";    break;
3464                 default:        mt = "unknown"; break;
3465                 }
3466                 printf("mstrat[%d] = %d %s\n", ma, Memalloc[ma].memtype, mt);
3467                 printf("\tflags=%#o name='%s' nblks=%d\n",
3468                        Memalloc[ma].flags,
3469                        Memalloc[ma].name,
3470                        Memalloc[ma].nblks);
3471         }
3472 }
3473
3474 /*
3475  * -d <op>:<time> - doio inter-operation delay
3476  *      currently this permits ONE type of delay between operations.
3477  */
3478
3479 void
3480 parse_delay(char *arg)
3481 {
3482         char            *delayargs[NMEMALLOC];
3483         int             ndelay;
3484         struct smap     *s;
3485
3486         ndelay = string_to_tokens(arg, delayargs, 32, ":");
3487         if(ndelay < 2) {
3488                 doio_fprintf(stderr,
3489                         "Illegal delay arg (%s). Must be operation:time\n", arg);
3490                 exit(1);
3491         }
3492         for(s=delaymap; s->string != NULL; s++)
3493                 if(!strcmp(s->string, delayargs[0]))
3494                         break;
3495         if (s->string == NULL) {
3496                 fprintf(stderr,
3497                         "Illegal Delay arg (%s).  Must be one of: ", arg);
3498
3499                 for (s = delaymap; s->string != NULL; s++)
3500                         fprintf(stderr, "%s ", s->string);
3501                 fprintf(stderr, "\n");
3502                 exit(1);
3503         }
3504
3505         delayop = s->value;
3506
3507         sscanf(delayargs[1], "%i", &delaytime);
3508
3509         if(ndelay > 2) {
3510                 fprintf(stderr,
3511                         "Warning: extra delay arguments ignored.\n");
3512         }
3513 }
3514
3515
3516 /*
3517  * Usage clause - obvious
3518  */
3519
3520 int
3521 usage(stream)
3522 FILE    *stream;
3523 {
3524         /*
3525          * Only do this if we are on vpe 0, to avoid seeing it from every
3526          * process in the application.
3527          */
3528
3529         if (Npes > 1 && Vpe != 0) {
3530                 return 0;
3531         }
3532
3533         fprintf(stream, "usage%s:  %s [-aekv] [-m message_interval] [-n nprocs] [-r release_interval] [-w write_log] [-V validation_ftype] [-U upanic_cond] [infile]\n", TagName, Prog);
3534         return 0;
3535 }
3536
3537 void
3538 help(stream)
3539 FILE    *stream;
3540 {
3541         /*
3542          * Only the app running on vpe 0 gets to issue help - this prevents
3543          * everybody in the application from doing this.
3544          */
3545
3546         if (Npes > 1 && Vpe != 0) {
3547                 return;
3548         }
3549
3550         usage(stream);
3551         fprintf(stream, "\n");
3552         fprintf(stream, "\t-a                   abort - kill all doio processes on data compare\n");
3553         fprintf(stream, "\t                     errors.  Normally only the erroring process exits\n");
3554         fprintf(stream, "\t-C data-pattern-type \n");
3555         fprintf(stream, "\t                     Available data patterns are:\n");
3556         fprintf(stream, "\t                     default - repeating pattern\n");
3557         fprintf(stream, "\t-d Operation:Time    Inter-operation delay.\n");
3558         fprintf(stream, "\t                     Operations are:\n");
3559         fprintf(stream, "\t                         select:time (1 second=1000000)\n");
3560         fprintf(stream, "\t                         sleep:time (1 second=1)\n");
3561         fprintf(stream, "\t                         alarm:time (1 second=1)\n");
3562         fprintf(stream, "\t-e                   Re-exec children before entering the main\n");
3563         fprintf(stream, "\t                     loop.  This is useful for spreading\n");
3564         fprintf(stream, "\t                     procs around on multi-pe systems.\n");
3565         fprintf(stream, "\t-k                   Lock file regions during writes using fcntl()\n");
3566         fprintf(stream, "\t-v                   Verify writes - this is done by doing a buffered\n");
3567         fprintf(stream, "\t                     read() of the data if file io was done, or\n");
3568         fprintf(stream, "\t                     an ssread()of the data if sds io was done\n");
3569         fprintf(stream, "\t-M                   Data buffer allocation method\n");
3570         fprintf(stream, "\t                     alloc-type[,type]\n");
3571         fprintf(stream, "\t                         data\n");
3572         fprintf(stream, "\t                         shmem:shmid:size\n");
3573         fprintf(stream, "\t                         mmap:flags:filename\n");
3574         fprintf(stream, "\t                             p - private\n");
3575         fprintf(stream, "\t                             s - shared (shared file must exist\n"),
3576         fprintf(stream, "\t                                 and have needed length)\n");
3577         fprintf(stream, "\t                             f - fixed address (not used)\n");
3578         fprintf(stream, "\t                             a - specify address (not used)\n");
3579         fprintf(stream, "\t                             U - Unlink file when done\n");
3580         fprintf(stream, "\t                             The default flag is private\n");
3581         fprintf(stream, "\n");
3582         fprintf(stream, "\t-m message_interval  Generate a message every 'message_interval'\n");
3583         fprintf(stream, "\t                     requests.  An interval of 0 suppresses\n");
3584         fprintf(stream, "\t                     messages.  The default is 0.\n");
3585         fprintf(stream, "\t-N tagname           Tag name, for Monster.\n");
3586         fprintf(stream, "\t-n nprocs            # of processes to start up\n");
3587         fprintf(stream, "\t-r release_interval  Release all memory and close\n");
3588         fprintf(stream, "\t                     files every release_interval operations.\n");
3589         fprintf(stream, "\t                     By default procs never release memory\n");
3590         fprintf(stream, "\t                     or close fds unless they have to.\n");
3591         fprintf(stream, "\t-V validation_ftype  The type of file descriptor to use for doing data\n");
3592         fprintf(stream, "\t                     validation.  validation_ftype may be an octal,\n");
3593         fprintf(stream, "\t                     hex, or decimal number representing the open()\n");
3594         fprintf(stream, "\t                     flags, or may be one of the following strings:\n");
3595         fprintf(stream, "\t                     'buffered' - validate using bufferd read\n");
3596         fprintf(stream, "\t                     'sync'     - validate using O_SYNC read\n");
3597         fprintf(stream, "\t                     'direct    - validate using O_DIRECT read'\n");
3598         fprintf(stream, "\t                     By default, 'parallel'\n");
3599         fprintf(stream, "\t                     is used if the write was done with O_PARALLEL\n");
3600         fprintf(stream, "\t                     or 'buffered' for all other writes.\n");
3601         fprintf(stream, "\t-w write_log         File to log file writes to.  The doio_check\n");
3602         fprintf(stream, "\t                     program can reconstruct datafiles using the\n");
3603         fprintf(stream, "\t                     write_log, and detect if a file is corrupt\n");
3604         fprintf(stream, "\t                     after all procs have exited.\n");
3605         fprintf(stream, "\t-U upanic_cond       Comma separated list of conditions that will\n");
3606         fprintf(stream, "\t                     cause a call to upanic(PA_PANIC).\n");
3607         fprintf(stream, "\t                     'corruption' -> upanic on bad data comparisons\n");
3608         fprintf(stream, "\t                     'iosw'     ---> upanic on unexpected async iosw\n");
3609         fprintf(stream, "\t                     'rval'     ---> upanic on unexpected syscall rvals\n");
3610         fprintf(stream, "\t                     'all'      ---> all of the above\n");
3611         fprintf(stream, "\n");
3612         fprintf(stream, "\tinfile               Input stream - default is stdin - must be a list\n");
3613         fprintf(stream, "\t                     of io_req structures (see doio.h).  Currently\n");
3614         fprintf(stream, "\t                     only the iogen program generates the proper\n");
3615         fprintf(stream, "\t                     format\n");
3616 }       
3617