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