Quantcast

[PATCH 0/3] xfstests: remove unused code and resolve warnings

classic Classic list List threaded Threaded
14 messages Options
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[PATCH 0/3] xfstests: remove unused code and resolve warnings

Rich Johnston
This patchset:
   1. Removes the unsupported sgi and CRAY conditionals
   2. Removes the unused conditional NO_XFS
   3. Resolves compiler/configure warnings

_______________________________________________
xfs mailing list
[hidden email]
http://oss.sgi.com/mailman/listinfo/xfs
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[PATCH 1/3] xfstests: remove unsupported conditionals

Rich Johnston
This patch removes the unsupported sgi and CRAY.

Signed-off-by: Rich Johnston <[hidden email]>

---
 dmapi/src/common/lib/dmport.h         |   16
 dmapi/src/common/lib/util.c           |   16
 dmapi/src/sample_hsm/wbee.c           |    2
 dmapi/src/simple/dm_create_session.c  |    3
 dmapi/src/simple/dm_destroy_session.c |    3
 dmapi/src/simple/dm_find_eventmsg.c   |    3
 dmapi/src/simple/dm_getall_sessions.c |    3
 dmapi/src/simple/dm_getall_tokens.c   |    3
 dmapi/src/simple/dm_query_session.c   |    3
 dmapi/src/suite1/cmd/get_mountinfo.c  |    4
 dmapi/src/suite1/cmd/make_rt_sparse.c |    7
 dmapi/src/suite1/cmd/print_event.c    |    8
 dmapi/src/suite1/cmd/print_fshandle.c |   21
 dmapi/src/suite2/src/check_dmapi.c    |   25
 dmapi/src/suite2/src/dm_test_daemon.c |   20
 dmapi/src/suite2/src/mmap.c           |   12
 dmapi/src/suite2/src/test_invis.c     |   43
 include/test.h                        |   17
 include/tlibio.h                      |   40
 include/usctest.h                     |    2
 include/write_log.h                   |    8
 lib/datapid.c                         |  179 ---
 lib/random_range.c                    |   34
 lib/str_to_bytes.c                    |    6
 lib/tlibio.c                          |  777 --------------
 ltp/doio.c                            | 1866 +---------------------------------
 ltp/doio.h                            |    6
 ltp/growfiles.c                       |  162 --
 ltp/iogen.c                           |  307 -----
 src/dirperf.c                         |    2
 src/dmiperf.c                         |    6
 src/global.h                          |    5
 src/multi_open_unlink.c               |    4
 src/randholes.c                       |    5
 34 files changed, 101 insertions(+), 3517 deletions(-)

Index: b/dmapi/src/common/lib/dmport.h
===================================================================
--- a/dmapi/src/common/lib/dmport.h
+++ b/dmapi/src/common/lib/dmport.h
@@ -294,22 +294,6 @@ typedef struct dm_timestruct dm_timestru
 
 -------------- end of SGI-specific hack documentation --------------- */
 
-#ifdef __sgi
-
-#include <sys/dmi.h>
-
-/* In the dm_fileattr_t structure, Veritas used 'timeval' structures for all
-   the time fields while XDSM uses 'time_t' structures.  Define some symbols
-   that can be used for the time fields with all implementation types.
-*/
-
-#define FA_ATIME fa_atime
-#define FA_MTIME fa_mtime
-#define FA_CTIME fa_ctime
-#define FA_DTIME fa_dtime
-
-#endif /* __sgi */
-
 #ifdef linux
 
 #include <dmapi.h>
Index: b/dmapi/src/common/lib/util.c
===================================================================
--- a/dmapi/src/common/lib/util.c
+++ b/dmapi/src/common/lib/util.c
@@ -380,11 +380,7 @@ save_filedata(
  nread = dm_read_invis(sid, hanp, hlen, DM_NO_TOKEN, off,
  (dm_ssize_t)CHUNKSIZE, filebuf);
  if (nread != CHUNKSIZE) {
-#ifdef __sgi
- errno_msg("%s/%d: invis read err: got %lld, expected %lld, buf %d",
-#else
  errno_msg("%s/%d: invis read err: got %d, expected %d, buf %d",
-#endif
  __FILE__, __LINE__,
  nread, (dm_ssize_t)CHUNKSIZE, i);
  retval = 1;
@@ -406,11 +402,7 @@ save_filedata(
  nread  = dm_read_invis(sid, hanp, hlen, DM_NO_TOKEN, off,
  (dm_ssize_t)lastbuf, filebuf);
  if (nread != lastbuf) {
-#ifdef __sgi
- errno_msg("%s/%d: invis read error- got %lld, expected %lld, last buf",
-#else
  errno_msg("%s/%d: invis read error- got %d, expected %d, last buf",
-#endif
  __FILE__, __LINE__,
  nread, lastbuf);
  retval = 1;
@@ -419,11 +411,7 @@ save_filedata(
 
  nwrite = write(stg_fd, filebuf, (int)lastbuf);
  if (nwrite != lastbuf) {
-#ifdef __sgi
- errno_msg("%s/%d: write error %d, expected %lld, last buffer",
-#else
  errno_msg("%s/%d: write error %d, expected %d, last buffer",
-#endif
  __FILE__, __LINE__,
  nwrite, lastbuf);
  retval = 1;
@@ -845,7 +833,7 @@ static char buffer[256];
 }
 
 
-#if defined(__sgi) || defined(linux)
+#if defined(linux)
 
 extern char *
 xflags_to_string(
@@ -913,7 +901,7 @@ print_state(
  fprintf(stdout, "dt_blksize     %d\n", dmstat->dt_blksize);
  fprintf(stdout, "dt_blocks      %lld\n", (long long) dmstat->dt_blocks);
 
-#if defined(__sgi) || defined(linux)
+#if defined(linux)
  fprintf(stdout, "dt_xfs_igen    %d\n",  dmstat->dt_xfs_igen);
  fprintf(stdout, "dt_xfs_xflags  %s\n",
  xflags_to_string(dmstat->dt_xfs_xflags));
Index: b/dmapi/src/sample_hsm/wbee.c
===================================================================
--- a/dmapi/src/sample_hsm/wbee.c
+++ b/dmapi/src/sample_hsm/wbee.c
@@ -245,7 +245,7 @@ check_lockstate(
  errno_msg("Can't query file access rights");
  return(1);
  }
-#if defined(__sgi) || defined(linux)
+#if defined(linux)
  /*
  * There are no access rights on the SGI. 1 means it's
  * there.
Index: b/dmapi/src/simple/dm_create_session.c
===================================================================
--- a/dmapi/src/simple/dm_create_session.c
+++ b/dmapi/src/simple/dm_create_session.c
@@ -22,9 +22,6 @@
 #ifdef linux
 #include <dmapi.h>
 #endif
-#ifdef __sgi
-#include <sys/dmi.h>
-#endif
 
 int
 main( int argc, char **argv )
Index: b/dmapi/src/simple/dm_destroy_session.c
===================================================================
--- a/dmapi/src/simple/dm_destroy_session.c
+++ b/dmapi/src/simple/dm_destroy_session.c
@@ -22,9 +22,6 @@
 #ifdef linux
 #include <dmapi.h>
 #endif
-#ifdef __sgi
-#include <sys/dmi.h>
-#endif
 
 int
 main( int argc, char **argv )
Index: b/dmapi/src/simple/dm_find_eventmsg.c
===================================================================
--- a/dmapi/src/simple/dm_find_eventmsg.c
+++ b/dmapi/src/simple/dm_find_eventmsg.c
@@ -22,9 +22,6 @@
 #ifdef linux
 #include <dmapi.h>
 #endif
-#ifdef __sgi
-#include <sys/dmi.h>
-#endif
 
 int
 main( int argc, char **argv )
Index: b/dmapi/src/simple/dm_getall_sessions.c
===================================================================
--- a/dmapi/src/simple/dm_getall_sessions.c
+++ b/dmapi/src/simple/dm_getall_sessions.c
@@ -24,9 +24,6 @@
 #ifdef linux
 #include <dmapi.h>
 #endif
-#ifdef __sgi
-#include <sys/dmi.h>
-#endif
 
 int
 main( int argc, char **argv )
Index: b/dmapi/src/simple/dm_getall_tokens.c
===================================================================
--- a/dmapi/src/simple/dm_getall_tokens.c
+++ b/dmapi/src/simple/dm_getall_tokens.c
@@ -23,9 +23,6 @@
 #ifdef linux
 #include <dmapi.h>
 #endif
-#ifdef __sgi
-#include <sys/dmi.h>
-#endif
 
 int
 main( int argc, char **argv )
Index: b/dmapi/src/simple/dm_query_session.c
===================================================================
--- a/dmapi/src/simple/dm_query_session.c
+++ b/dmapi/src/simple/dm_query_session.c
@@ -22,9 +22,6 @@
 #ifdef linux
 #include <dmapi.h>
 #endif
-#ifdef __sgi
-#include <sys/dmi.h>
-#endif
 
 int
 main( int argc, char **argv )
Index: b/dmapi/src/suite1/cmd/get_mountinfo.c
===================================================================
--- a/dmapi/src/suite1/cmd/get_mountinfo.c
+++ b/dmapi/src/suite1/cmd/get_mountinfo.c
@@ -43,11 +43,7 @@ in the call, and sid is the session ID w
 #define HDR  "%s: token %d sequence %d\n"
 #define VALS "\t%-15s %s\n"
 #define VALD "\t%-15s %d\n"
-#ifdef __sgi
-#define VALLLD "\t%-15s %lld\n"
-#else
 #define VALLLD "\t%-15s %ld\n"
-#endif
 
 #ifndef linux
 extern char *sys_errlist[];
Index: b/dmapi/src/suite1/cmd/make_rt_sparse.c
===================================================================
--- a/dmapi/src/suite1/cmd/make_rt_sparse.c
+++ b/dmapi/src/suite1/cmd/make_rt_sparse.c
@@ -21,13 +21,6 @@
  */
 
 #include <sys/types.h>
-#ifdef __sgi
-#include <sys/fs/xfs_itable.h>
-#include <sys/syssgi.h>
-#include <sys/uuid.h>
-#include <sys/fs/xfs_fsops.h>
-#endif
-
 #include <errno.h>
 #include <fcntl.h>
 #include <malloc.h>
Index: b/dmapi/src/suite1/cmd/print_event.c
===================================================================
--- a/dmapi/src/suite1/cmd/print_event.c
+++ b/dmapi/src/suite1/cmd/print_event.c
@@ -965,10 +965,10 @@ set_disposition(
  /* Metadata events. */
 
  DMEV_SET(DM_EVENT_ATTRIBUTE, eventlist);
-#if ! defined ( __sgi ) && ! defined ( VERITAS_21 ) && !defined(linux)
+#if !defined(VERITAS_21) && !defined(linux)
  DMEV_SET(DM_EVENT_CANCEL, eventlist); /* not supported on SGI */
 #endif
-#if !defined( __sgi) && !defined(linux)
+#if !defined(linux)
  DMEV_SET(DM_EVENT_CLOSE, eventlist); /* not supported on SGI */
 #endif
  DMEV_SET(DM_EVENT_DESTROY, eventlist);
@@ -1051,10 +1051,10 @@ set_events(
  /* Metadata events. */
 
  DMEV_SET(DM_EVENT_ATTRIBUTE, eventlist);
-#if ! defined ( __sgi ) && ! defined ( VERITAS_21 ) && ! defined(linux)
+#if !defined(VERITAS_21) && !defined(linux)
  DMEV_SET(DM_EVENT_CANCEL, eventlist); /* not supported on SGI */
 #endif
-#if !defined( __sgi) && !defined(linux)
+#if !defined(linux)
  DMEV_SET(DM_EVENT_CLOSE, eventlist); /* not supported on SGI */
 #endif
  DMEV_SET(DM_EVENT_DESTROY, eventlist);
Index: b/dmapi/src/suite1/cmd/print_fshandle.c
===================================================================
--- a/dmapi/src/suite1/cmd/print_fshandle.c
+++ b/dmapi/src/suite1/cmd/print_fshandle.c
@@ -22,17 +22,10 @@
 
 #include <sys/types.h>
 #include <string.h>
-#ifdef __sgi
-#include <sys/syssgi.h>
-#include <sys/uuid.h>
-#include <sys/fs/xfs_fsops.h>
-#endif
-
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
-
 #include <lib/dmport.h>
 
 char *Progname;
@@ -56,11 +49,6 @@ main(
  int argc,
  char **argv)
 {
-#ifdef __sgi
- xfs_fsop_geom_t geom;
- char *uuid_str;
- u_int status;
-#endif
  char *name;
  int fd;
  void *fshanp;
@@ -85,15 +73,6 @@ main(
  strerror(errno));
  exit(1);
  }
-
-#ifdef __sgi
- syssgi(SGI_XFS_FSOPERATIONS, fd, XFS_FS_GEOMETRY, NULL, &geom);
-
- uuid_to_string(&geom.uuid, &uuid_str, &status);
-
- fprintf(stdout, "fshandle %s, uuid %s, %s\n",
- buffer, uuid_str, argv[1]);
-#endif
  fprintf(stdout, "fshandle %s, %s\n",
  buffer, argv[1]);
  exit(0);
Index: b/dmapi/src/suite2/src/check_dmapi.c
===================================================================
--- a/dmapi/src/suite2/src/check_dmapi.c
+++ b/dmapi/src/suite2/src/check_dmapi.c
@@ -123,31 +123,6 @@ main(
   exit(1);
  }
 
- /*--------------------------------
- * EXAMINE /usr/include/sys/dmi.h:
- *--------------------------------
- */
-#ifdef __sgi
-#define DMAPI_HDR "/usr/include/sys/dmi.h"
-
- if (stat(DMAPI_HDR, &stat_buf)==-1){
-  if (errno==ENOENT) {
-    printf( "You are missing a vital DMAPI file: %s\n", DMAPI_HDR);
-  }
-  else {
-    printf( "ERROR: could not stat %s (%s)\n", DMAPI_HDR, strerror(errno));
-  }
- }
- else {
-  if (stat_buf.st_size <= 15000) {
-    printf("You appear to have an old version of a vital DMAPI file: %s\n", DMAPI_HDR);
-  }
-  else if (Vflag) {
-    printf("(You appear to have the correct version of %s\n", DMAPI_HDR);
-  }
- }
-#endif
-
  /*--------------------------
  * RESOLVE KERNEL PRESENCE:
  *--------------------------
Index: b/dmapi/src/suite2/src/dm_test_daemon.c
===================================================================
--- a/dmapi/src/suite2/src/dm_test_daemon.c
+++ b/dmapi/src/suite2/src/dm_test_daemon.c
@@ -736,7 +736,7 @@ handle_message(
       respcode = ENOSPC;
       break;
 
-    case DM_EVENT_DEBUT: /* not supported on SGI */
+    case DM_EVENT_DEBUT:
       printf(HDR VALS,
      "debut", msg->ev_token, msg->ev_sequence,
      "object", hans1);
@@ -843,7 +843,7 @@ handle_message(
       respond = 0;
       break;
 
-    case DM_EVENT_CLOSE: /* not supported on SGI */
+    case DM_EVENT_CLOSE:
       printf(HDR VALS,
      "close", msg->ev_token, msg->ev_sequence,
      "object", hans1);
@@ -1024,11 +1024,11 @@ set_disposition(
  /* Metadata events. */
 
  DMEV_SET(DM_EVENT_ATTRIBUTE, eventlist);
-#if ! defined ( __sgi ) && ! defined ( VERITAS ) && ! defined(linux)
- DMEV_SET(DM_EVENT_CANCEL, eventlist); /* not supported on SGI */
+#if !defined(VERITAS) && !defined(linux)
+ DMEV_SET(DM_EVENT_CANCEL, eventlist);
 #endif
-#if !defined(__sgi) && !defined(linux)
- DMEV_SET(DM_EVENT_CLOSE, eventlist); /* not supported on SGI */
+#if !defined(linux)
+ DMEV_SET(DM_EVENT_CLOSE, eventlist);
 #endif
  DMEV_SET(DM_EVENT_DESTROY, eventlist);
 
@@ -1103,11 +1103,11 @@ set_events(
  /* Metadata events. */
 
  DMEV_SET(DM_EVENT_ATTRIBUTE, eventlist);
-#if ! defined ( __sgi ) && ! defined ( VERITAS ) && !defined(linux)
- DMEV_SET(DM_EVENT_CANCEL, eventlist); /* not supported on SGI */
+#if !defined(VERITAS) && !defined(linux)
+ DMEV_SET(DM_EVENT_CANCEL, eventlist);
 #endif
-#if !defined(__sgi) && !defined(linux)
- DMEV_SET(DM_EVENT_CLOSE, eventlist); /* not supported on SGI */
+#if !defined(linux)
+ DMEV_SET(DM_EVENT_CLOSE, eventlist);
 #endif
  DMEV_SET(DM_EVENT_DESTROY, eventlist);
 
Index: b/dmapi/src/suite2/src/mmap.c
===================================================================
--- a/dmapi/src/suite2/src/mmap.c
+++ b/dmapi/src/suite2/src/mmap.c
@@ -94,18 +94,9 @@ static struct {
  FLAG(PROT_READ, FL_PROT),
  FLAG(PROT_WRITE, FL_PROT),
  FLAG(PROT_EXEC, FL_PROT),
-#ifdef __sgi
- FLAG(PROT_EXECUTE, FL_PROT),
-#endif
  FLAG(MAP_SHARED, FL_MAP),
  FLAG(MAP_PRIVATE, FL_MAP),
  FLAG(MAP_FIXED, FL_MAP),
-#ifdef __sgi
- FLAG(MAP_RENAME, FL_MAP),
- FLAG(MAP_AUTOGROW, FL_MAP),
- FLAG(MAP_LOCAL, FL_MAP),
- FLAG(MAP_AUTORESRV, FL_MAP),
-#endif
  FLAG(MAP_NONE, FL_MAP),
 };
 
@@ -145,9 +136,6 @@ main(int argc, char * argv[])
  ifile->flags[FL_PROT].value = PROT_READ;
  ifile->flags[FL_OPEN].value = O_RDONLY;
  ofile->flags[FL_MAP].value = MAP_SHARED;
-#ifdef __sgi
- ofile->flags[FL_MAP].value = MAP_AUTOGROW;
-#endif
  ofile->flags[FL_PROT].value = PROT_WRITE;
  ofile->flags[FL_OPEN].value = O_RDWR|O_CREAT;
 
Index: b/dmapi/src/suite2/src/test_invis.c
===================================================================
--- a/dmapi/src/suite2/src/test_invis.c
+++ b/dmapi/src/suite2/src/test_invis.c
@@ -210,18 +210,9 @@ main(
       test_file);
     }
     else {
-#ifdef __sgi
-      if ((statbuf.st_atim.tv_sec == checkbuf.st_atim.tv_sec) &&
-      (statbuf.st_atim.tv_nsec == checkbuf.st_atim.tv_nsec) &&
-      (statbuf.st_mtim.tv_sec == checkbuf.st_mtim.tv_sec) &&
-      (statbuf.st_mtim.tv_nsec == checkbuf.st_mtim.tv_nsec) &&
-      (statbuf.st_ctim.tv_sec == checkbuf.st_ctim.tv_sec) &&
-      (statbuf.st_ctim.tv_nsec == checkbuf.st_ctim.tv_nsec))
-#else
       if ((statbuf.st_atime == checkbuf.st_atime) &&
       (statbuf.st_mtime == checkbuf.st_mtime) &&
       (statbuf.st_ctime == checkbuf.st_ctime))
-#endif
  {
  if (Vflag) {
   printf("Report: time stamp unchanged by write\n");
@@ -267,18 +258,9 @@ main(
       test_file);
     }
     else {
-#ifdef __sgi
-      if ((statbuf.st_atim.tv_sec == checkbuf.st_atim.tv_sec) &&
-      (statbuf.st_atim.tv_nsec == checkbuf.st_atim.tv_nsec) &&
-      (statbuf.st_mtim.tv_sec == checkbuf.st_mtim.tv_sec) &&
-      (statbuf.st_mtim.tv_nsec == checkbuf.st_mtim.tv_nsec) &&
-      (statbuf.st_ctim.tv_sec == checkbuf.st_ctim.tv_sec) &&
-      (statbuf.st_ctim.tv_nsec == checkbuf.st_ctim.tv_nsec))
-#else
       if ((statbuf.st_atime == checkbuf.st_atime) &&
       (statbuf.st_mtime == checkbuf.st_mtime) &&
       (statbuf.st_ctime == checkbuf.st_ctime))
-#endif
  {
  if (Vflag) {
   printf("Report: time stamp unchanged by read\n");
@@ -344,31 +326,6 @@ main(
     printf("Report: \"0x%x\" was written and \"0x%x\" was read "
    "at byte %d million.\n", ch, *(u_char *)bufp, ch);
   }
-
-#ifdef __sgi
-  /* Try writing a character in the 2 gigabyte (2^31) range */
-  sprintf(bufp, "%c", ch);
-  if (dm_write_invis(sid, hanp, hlen, DM_NO_TOKEN, 0,
-     2147840000, 1, bufp)==-1){
-    printf("Error invis-writing %s at 2 gigabytes: %s\n",
-   (u_char *)bufp, ERR_NAME);
-  }
-  else if (dm_read_invis(sid, hanp, hlen, DM_NO_TOKEN,
- 2147840000, 1, bufp)==-1){
-    printf("Error invis-reading at 2 gigabytes: %s\n",
-   ERR_NAME);
-  }
-  else if (((u_char *)bufp)[0]!=ch) {
-    printf("Error: wanted to read %c and instead got %s.\n",
-   ch, (u_char *)bufp);
-  }
-  else if (Vflag) {
-    printf("Report: \"0x%x\" was written and \"0x%x\" was read "
-   "at 2147840000 bytes\n\t(a bit over 2 gigabytes).\n",
-   ch, *(u_char *)bufp);
-  }
-#endif
-
   printf("\t(errno subtests beginning...)\n");
   /**** WRITE tests ****/
   /*---------------------------------------------------------*/
Index: b/include/test.h
===================================================================
--- a/include/test.h
+++ b/include/test.h
@@ -36,23 +36,6 @@
 #define TCONF    32   /* Test not appropriate for configuration flag */
 
 /*
- * To determine if you are on a Umk or Unicos system,
- * use sysconf(_SC_CRAY_SYSTEM).  But since _SC_CRAY_SYSTEM
- * is not defined until 90, it will be define here if not already
- * defined.
- * if ( sysconf(_SC_CRAY_SYSTEM) == 1 )
- *    on UMK
- * else   # returned 0 or -1
- *    on Unicos
- * This is only being done on CRAY systems.
- */
-#ifdef CRAY
-#ifndef _SC_CRAY_SYSTEM
-#define _SC_CRAY_SYSTEM  140
-#endif /* ! _SC_CRAY_SYSTEM */
-#endif /* CRAY */
-
-/*
  * Ensure that NUMSIGS is defined.
  * It should be defined in signal.h or sys/signal.h on
  * UNICOS/mk and IRIX systems.   On UNICOS systems,
Index: b/include/tlibio.h
===================================================================
--- a/include/tlibio.h
+++ b/include/tlibio.h
@@ -23,54 +23,27 @@
 #define LIO_IO_SYNCV            00020   /* single-buffer readv/writev */
 #define LIO_IO_SYNCP            00040   /* pread/pwrite */
 
-#ifdef sgi
-#define LIO_IO_ATYPES           00077   /* all io types */
-#define LIO_IO_TYPES            00061   /* all io types, non-async */
-#endif /* sgi */
 #ifdef linux
 #define LIO_IO_TYPES            00021   /* all io types */
 #endif /* linux */
-#ifdef CRAY
-#define LIO_IO_TYPES            00017   /* all io types */
-#endif /* CRAY */
 
 #define LIO_WAIT_NONE           00010000 /* return asap -- use with care */
 #define LIO_WAIT_ACTIVE         00020000 /* spin looking at iosw fields, or EINPROGRESS */
 #define LIO_WAIT_RECALL         00040000 /* call recall(2)/aio_suspend(3) */
 #define LIO_WAIT_SIGPAUSE       00100000 /* call pause */
 #define LIO_WAIT_SIGACTIVE      00200000 /* spin waiting for signal */
-#ifdef sgi
-#define LIO_WAIT_CBSUSPEND      00400000 /* aio_suspend waiting for callback */
-#define LIO_WAIT_SIGSUSPEND     01000000 /* aio_suspend waiting for signal */
-#define LIO_WAIT_ATYPES         01760000 /* all async wait types, except nowait */
-#define LIO_WAIT_TYPES          00020000 /* all sync wait types (sorta) */
-#endif /* sgi */
+
 #ifdef linux
 #define LIO_WAIT_TYPES          00300000 /* all wait types, except nowait */
 #endif /* linux */
-#ifdef CRAY
-#define LIO_WAIT_TYPES          00360000 /* all wait types, except nowait */
-#endif /* CRAY */
 
 /* meta wait io  */
 /*  00  000 0000 */
 
-#ifdef sgi
-/* all callback wait types */
-#define LIO_WAIT_CBTYPES (LIO_WAIT_CBSUSPEND)
-/* all signal wait types */
-#define LIO_WAIT_SIGTYPES (LIO_WAIT_SIGPAUSE|LIO_WAIT_SIGACTIVE|LIO_WAIT_SIGSUSPEND)
-/* all aio_{read,write} or lio_listio */
-#define LIO_IO_ASYNC_TYPES (LIO_IO_ASYNC|LIO_IO_SLISTIO|LIO_IO_ALISTIO)
-#endif /* sgi */
 #ifdef linux
 /* all signal wait types */
 #define LIO_WAIT_SIGTYPES (LIO_WAIT_SIGPAUSE)
 #endif /* linux */
-#ifdef CRAY
-/* all signal wait types */
-#define LIO_WAIT_SIGTYPES (LIO_WAIT_SIGPAUSE|LIO_WAIT_SIGACTIVE)
-#endif /* CRAY */
 
 /*
  * This bit provides a way to randomly pick an io type and wait method.
@@ -110,17 +83,6 @@ int  lio_read_buffer(int fd, int method,
      int sig, char **errmsg, long wrd);
 int  lio_random_methods(long mask);
 
-#if CRAY
-#include <sys/iosw.h>
-int  lio_wait4asyncio(int method, int fd, struct iosw **statptr);
-int  lio_check_asyncio(char *io_type, int size, struct iosw *status);
-#endif /* CRAY */
-#ifdef sgi
-#include <aio.h>
-int  lio_wait4asyncio(int method, int fd, aiocb_t *aiocbp);
-int  lio_check_asyncio(char *io_type, int size, aiocb_t *aiocbp, int method);
-#endif /* sgi */
-
 /*
  * Define the structure that contains the infomation that is used
  * by the parsing and help functions.
Index: b/include/usctest.h
===================================================================
--- a/include/usctest.h
+++ b/include/usctest.h
@@ -89,11 +89,9 @@
 #endif
 #endif
 
-#ifndef CRAY
 #ifndef BSIZE
 #define BSIZE BBSIZE
 #endif
-#endif
 
 /***********************************************************************
  * Define option_t structure type.
Index: b/include/write_log.h
===================================================================
--- a/include/write_log.h
+++ b/include/write_log.h
@@ -91,18 +91,10 @@ struct wlog_rec {
  */
 
 struct wlog_rec_disk {
-#ifdef sgi /* sgi is pissy about fields > 32 bit, even cc -mips3 */
-    uint    w_offset    : 32;    /* file offset          */
-    uint    w_extra0    : 32;       /* EXTRA BITS IN WORD 0         */
-#endif
 #ifdef linux
     uint    w_offset    : 32;    /* file offset          */
     uint    w_extra0    : 32;       /* EXTRA BITS IN WORD 0         */
 #endif
-#ifdef CRAY
-    uint    w_offset    : 44;    /* file offset          */
-    uint    w_extra0    : 20;       /* EXTRA BITS IN WORD 0         */
-#endif
 
     uint    w_nbytes    : 32;    /* # bytes written        */
     uint    w_oflags : 32;    /* low-order open() flags    */
Index: b/lib/datapid.c
===================================================================
--- a/lib/datapid.c
+++ b/lib/datapid.c
@@ -75,87 +75,8 @@ char *buffer;
 int bsize;
 int offset;
 {
-#if CRAY
-
-   int cnt;
-   int tmp;
-   char *chr;
-   long *wptr;
-   long word;
-   int woff; /* file offset for the word */
-   int boff; /* buffer offset or index */
-   int num_full_words;
-
-    num_full_words = bsize/NBPW;
-    boff = 0;
-
-    if ( cnt=(offset % NBPW) ) { /* partial word */
-
- woff = offset - cnt;
-#if DEBUG
-printf("partial at beginning, cnt = %d, woff = %d\n", cnt, woff);
-#endif
-
- word = ((LOWER16BITS(pid) << 48) | (LOWER32BITS(woff) << 16) | LOWER16BITS(pid));
-
- chr = (char *)&word;
-
- for (tmp=0; tmp<cnt; tmp++) {   /* skip unused bytes */
-    chr++;
-        }
-
- for (; boff<(NBPW-cnt) && boff<bsize; boff++, chr++) {
-    buffer[boff] = *chr;
- }
-    }
-
-    /*
-     * full words
-     */
-
-    num_full_words = (bsize-boff)/NBPW;
-
-    woff = offset+boff;
-
-    for (cnt=0; cnt<num_full_words; woff += NBPW, cnt++ ) {
-
- word = ((LOWER16BITS(pid) << 48) | (LOWER32BITS(woff) << 16) | LOWER16BITS(pid));
-
- chr = (char *)&word;
- for(tmp=0; tmp<NBPW; tmp++, chr++) {
-    buffer[boff++] = *chr;
- }
-/****** Only if wptr is a word ellined
- wptr = (long *)&buffer[boff];
- *wptr = word;
- boff += NBPW;
-*****/
-
-    }
-
-    /*
-     * partial word at end of buffer
-     */
-
-    if ( cnt=((bsize-boff) % NBPW) ) {
-#if DEBUG
-printf("partial at end\n");
-#endif
- word = ((LOWER16BITS(pid) << 48) | (LOWER32BITS(woff) << 16) | LOWER16BITS(pid));
-
- chr = (char *)&word;
-
- for (tmp=0; tmp<cnt && boff<bsize; tmp++, chr++) {
-    buffer[boff++] = *chr;
- }
-    }
-
-    return bsize;
-
-#else
  return -1; /* not support on non-64 bits word machines  */
 
-#endif
 
 }
 
@@ -171,112 +92,12 @@ int bsize;
 int offset;
 char **errmsg;
 {
-#if CRAY
-
-   int cnt;
-   int tmp;
-   char *chr;
-   long *wptr;
-   long word;
-   int woff; /* file offset for the word */
-   int boff; /* buffer offset or index */
-   int num_full_words;
-
-
-    if ( errmsg != NULL ) {
-        *errmsg = Errmsg;
-    }
-
-
-    num_full_words = bsize/NBPW;
-    boff = 0;
-
-    if ( cnt=(offset % NBPW) ) { /* partial word */
- woff = offset - cnt;
- word = ((LOWER16BITS(pid) << 48) | (LOWER32BITS(woff) << 16) | LOWER16BITS(pid));
-
- chr = (char *)&word;
-
- for (tmp=0; tmp<cnt; tmp++) {   /* skip unused bytes */
-    chr++;
-        }
-
- for (; boff<(NBPW-cnt) && boff<bsize; boff++, chr++) {
-    if (buffer[boff] != *chr) {
- sprintf(Errmsg, "Data mismatch at offset %d, exp:%#o, act:%#o",
-    offset+boff, *chr, buffer[boff]);
- return offset+boff;
-    }
- }
-    }
-
-    /*
-     * full words
-     */
-
-    num_full_words = (bsize-boff)/NBPW;
-
-    woff = offset+boff;
-
-    for (cnt=0; cnt<num_full_words; woff += NBPW, cnt++ ) {
- word = ((LOWER16BITS(pid) << 48) | (LOWER32BITS(woff) << 16) | LOWER16BITS(pid));
-
- chr = (char *)&word;
- for(tmp=0; tmp<NBPW; tmp++, boff++, chr++) {
-    if ( buffer[boff] != *chr ) {
-        sprintf(Errmsg, "Data mismatch at offset %d, exp:%#o, act:%#o",
-            woff, *chr, buffer[boff]);
-        return woff;
-    }
- }
-
-/****** only if a word elined
- wptr = (long *)&buffer[boff];
- if ( *wptr != word ) {
-    sprintf(Errmsg, "Data mismatch at offset %d, exp:%#o, act:%#o",
-        woff, word, *wptr);
-    return woff;
- }
- boff += NBPW;
-******/
-    }
-
-    /*
-     * partial word at end of buffer
-     */
-
-    if ( cnt=((bsize-boff) % NBPW) ) {
-#if DEBUG
-printf("partial at end\n");
-#endif
- word = ((LOWER16BITS(pid) << 48) | (LOWER32BITS(woff) << 16) | LOWER16BITS(pid));
-
- chr = (char *)&word;
-
-
- for (tmp=0; tmp<cnt && boff<bsize; boff++, tmp++, chr++) {
-    if ( buffer[boff] != *chr ) {
- sprintf(Errmsg, "Data mismatch at offset %d, exp:%#o, act:%#o",
-    offset+boff, *chr, buffer[boff]);
- return offset+boff;
-    }
- }
-    }
-
-    sprintf(Errmsg, "all %d bytes match desired pattern", bsize);
-    return -1;      /* buffer is ok */
-
-#else
-
     if ( errmsg != NULL ) {
         *errmsg = Errmsg;
     }
     sprintf(Errmsg, "Not supported on this OS.");
     return 0;
 
-#endif
-
-
 }       /* end of datapidchk */
 
 #if UNIT_TEST
Index: b/lib/random_range.c
===================================================================
--- a/lib/random_range.c
+++ b/lib/random_range.c
@@ -338,27 +338,7 @@ char **errp;
  }
 
      nmults = ((max - min) / mult) + 1;
-#if CRAY
-        /*
-         * If max is less than 2gb, then the value can fit in 32 bits
-         * and the standard lrand48() routine can be used.
-         */
-        if ( max <= (long)2147483647 ) {
-            return (long) (min + (((long)lrand48() % nmults) * mult));
-        } else {
-            /*
-             * max is greater than 2gb - meeds more than 32 bits.
-             * Since lrand48 only will get a number up to 32bits.
-             */
-    long randnum;
-            randnum=divider(min, max, 0, -1);
-            return (long) (min + ((randnum % nmults) * mult));
-        }
-
-#else
         return (min + ((lrand48() % nmults) * mult));
-#endif
-
 }
 
 /*
@@ -430,7 +410,7 @@ char **errp;
  }
 
      nmults = ((max - min) / mult) + 1;
-#if CRAY || (_MIPS_SZLONG == 64)
+#if (_MIPS_SZLONG == 64)
         /*
          * If max is less than 2gb, then the value can fit in 32 bits
          * and the standard lrand48() routine can be used.
@@ -648,8 +628,6 @@ random_bit(long mask)
     /*
      * get the number of bits set in mask
      */
-#ifndef CRAY
-
         bit=1L;
         for ( nshift=0; nshift<sizeof(long)*8; nshift++) {
                 if ( mask & bit )
@@ -657,10 +635,6 @@ random_bit(long mask)
                 bit=bit<<1;
         }
 
-#else
-        nbits=_popcnt(mask);
-#endif  /* if CRAY */
-
     /*
      * randomly choose a bit.
      */
@@ -740,14 +714,10 @@ char **argv;
     int ind;
     int cnt, iter=10;
     int imin=0, imult=1, itmin, itmax=0;
-#if CRAY
-    int imax=6*GIG; /* higher than 32 bits */
-#else
     int imax=1048576;
-#endif
 
     long lret, lmin=0, lmult=1, ltmin, ltmax=0;
-#if CRAY || (_MIPS_SZLONG == 64)
+#if (_MIPS_SZLONG == 64)
     long lmax=6*(long)GIG; /* higher than 32 bits */
 #else
     long lmax=1048576;
Index: b/lib/str_to_bytes.c
===================================================================
--- a/lib/str_to_bytes.c
+++ b/lib/str_to_bytes.c
@@ -43,11 +43,7 @@
  *
  ****************************************************************************/
 
-#if CRAY
-#define B_MULT BSIZE /* block size */
-#elif sgi
-#define B_MULT BBSIZE /* block size */
-#elif linux
+#if linux
 #define B_MULT DEV_BSIZE /* block size */
 #endif
 
Index: b/lib/tlibio.c
===================================================================
--- a/lib/tlibio.c
+++ b/lib/tlibio.c
@@ -38,16 +38,6 @@
  * char **errmsg, long wrd);
  *  int  lio_read_buffer(int fd, int method, char *buffer, int size,
  * char **errmsg, long wrd);
- *
- *  #ifdef CRAY
- *  int  lio_wait4asyncio(int method, int fd, struct iosw **statptr)
- *  int  lio_check_asyncio(char *io_type, int size, struct iosw *status)
- *  #endif
- *  #ifdef sgi
- *  int  lio_wait4asyncio(int method, int fd, aiocb_t *aiocbp)
- *  int  lio_check_asyncio(char *io_type, int size, aiocb_t *aiocbp, int method)
- *  #endif
- *
  *  int  lio_parse_io_arg1(char *string)
  *  void lio_help1(char *prefix);
  *
@@ -76,19 +66,9 @@
 #include <sys/types.h>
 #include <sys/file.h>
 #include <signal.h>
-#ifdef CRAY
-#include <sys/secparm.h>
-#include <sys/iosw.h>
-#include <sys/listio.h>
-#else
-/* for linux or sgi */
 #include <sys/uio.h> /* readv(2)/writev(2) */
 #include <string.h>
 #include <strings.h>
-#endif
-#ifdef sgi
-#include <aio.h>
-#endif
 #include <stdlib.h> /* atoi, abs */
 
 #include "tlibio.h" /* defines LIO* marcos */
@@ -109,9 +89,6 @@
 #ifndef linux
 static void lio_async_signal_handler();
 #endif
-#ifdef sgi
-static void lio_async_callback_handler();
-#endif
 
 /*
  * Define the structure as used in lio_parse_arg1 and lio_help1
@@ -121,17 +98,10 @@ struct lio_info_type  Lio_info1[] = {
     { "p", LIO_IO_ASYNC|LIO_WAIT_SIGACTIVE, "async i/o using a loop to wait for a signal" },
     { "b", LIO_IO_ASYNC|LIO_WAIT_SIGPAUSE, "async i/o using pause" },
     { "a", LIO_IO_ASYNC|LIO_WAIT_RECALL, "async i/o using recall/aio_suspend" },
-#ifdef sgi
-    { "r",
- LIO_RANDOM|LIO_IO_TYPES|LIO_WAIT_TYPES, "random sync i/o types and wait methods" },
-    { "R",
- LIO_RANDOM|LIO_IO_ATYPES|LIO_WAIT_ATYPES, "random i/o types and wait methods" },
-#else
     { "r",
  LIO_RANDOM|LIO_IO_TYPES|LIO_WAIT_TYPES, "random i/o types and wait methods" },
     { "R",
  LIO_RANDOM|LIO_IO_TYPES|LIO_WAIT_TYPES, "random i/o types and wait methods" },
-#endif
     { "l", LIO_IO_SLISTIO|LIO_WAIT_RECALL, "single stride sync listio" },
     { "L", LIO_IO_ALISTIO|LIO_WAIT_RECALL, "single stride async listio using recall" },
     { "X", LIO_IO_ALISTIO|LIO_WAIT_SIGPAUSE, "single stride async listio using pause" },
@@ -165,10 +135,6 @@ char Lio_SysCall[PATH_MAX]; /* string co
 
 static volatile int Received_signal = 0; /* number of signals received */
 static volatile int Rec_signal;
-#ifdef sgi
-static volatile int Received_callback = 0; /* number of callbacks received */
-static volatile int Rec_callback;
-#endif
 static char Errormsg[500];
 static int Debug_level = 0;
 
@@ -416,25 +382,6 @@ lio_async_signal_handler(int sig)
 }
 #endif
 
-#ifdef sgi
-/***********************************************************************
- * This is an internal callback handler.
- * If the handler is called, it will increment the Received_callback
- * global variable.
- ***********************************************************************/
-static void
-lio_async_callback_handler(sigval_t sigval)
-{
- if ( Debug_level )
-    printf("DEBUG %s/%d: received callback, nbytes=%d, a callback called %d times\n",
- __FILE__, __LINE__, sigval.sival_int, Received_callback+1);
-
- Received_callback++;
-
- return;
-}
-#endif /* sgi */
-
 /***********************************************************************
  * lio_random_methods
  * This function will randomly choose an io type and wait method
@@ -523,18 +470,7 @@ long wrd; /* to allow future features, u
     int omethod = method;
     int listio_cmd; /* Holds the listio/lio_listio cmd */
 #endif
-#ifdef  CRAY
-    struct listreq request; /* Used when a listio is wanted */
-    struct iosw status, *statptr[1];  
-#else
-    /* for linux or sgi */
     struct iovec iov; /* iovec for writev(2) */
-#endif
-#ifdef sgi
-    aiocb_t aiocbp; /* POSIX aio control block */
-    aiocb_t *aiolist[1]; /* list of aio control blocks for lio_listio */
-    off64_t poffset; /* pwrite(2) offset */
-#endif
 
     /*
      * If LIO_RANDOM bit specified, get new method randomly.
@@ -551,64 +487,9 @@ long wrd; /* to allow future features, u
  *errmsg = Errormsg;
 
     Rec_signal=Received_signal; /* get the current number of signals received */
-#ifdef sgi
-    Rec_callback=Received_callback; /* get the current number of callbacks received */
-#endif
-
-#ifdef  CRAY
-    bzero(&status, sizeof(struct iosw));
-    bzero(&request, sizeof(struct listreq));
-    statptr[0] = &status;
-#else
-    /* for linux or sgi */
     bzero(&iov, sizeof(struct iovec));
     iov.iov_base = buffer;
     iov.iov_len = size;
-#endif
-#ifdef sgi
-    bzero(&aiocbp, sizeof(aiocb_t));
-    aiocbp.aio_fildes = fd;
-    aiocbp.aio_nbytes = size;
-    aiocbp.aio_buf = buffer;
-/*    aiocbp.aio_offset = lseek( fd, 0, SEEK_CUR ); -- set below */
-    aiocbp.aio_sigevent.sigev_notify = SIGEV_NONE;
-    aiocbp.aio_sigevent.sigev_signo = 0;
-    aiocbp.aio_sigevent.sigev_func = NULL;
-    aiocbp.aio_sigevent.sigev_value.sival_int = 0;
-    aiolist[0] = &aiocbp;
-
-    if( (ret = lseek( fd, 0, SEEK_CUR )) == -1 ){
- ret = 0;
- /* If there is an error and it is not ESPIPE then kick out the error.
- * If the fd is a fifo then we have to make sure that
- * lio_random_methods() didn't select pwrite/pread; if it did then
- * switch to write/read.
- */
- if( errno == ESPIPE ){
- if( method & LIO_IO_SYNCP ){
- if( omethod & LIO_RANDOM ){
- method &= ~LIO_IO_SYNCP;
- method |= LIO_IO_SYNC;
- if( Debug_level > 2 )
- printf("DEBUG %s/%d: random chosen method switched to %#o for fifo\n", __FILE__, __LINE__, method );
- }
- else if( Debug_level ){
- printf("DEBUG %s/%d: pwrite will fail when it writes to a fifo\n",
-       __FILE__, __LINE__ );
- }
- }
- /* else: let it ride */
- }
- else{
- sprintf(Errormsg, "%s/%d lseek(fd=%d,0,SEEK_CUR) failed, errno=%d  %s",
- __FILE__, __LINE__, fd, errno, strerror(errno));
- return -errno;
- }
-    }
-    poffset = (off64_t)ret;
-    aiocbp.aio_offset = ret;
-
-#endif
 
     /*
      * If the LIO_USE_SIGNAL bit is not set, only use the signal
@@ -622,11 +503,6 @@ long wrd; /* to allow future features, u
  sig=0; /* ignore signal parameter */
     }
 
-#ifdef sgi
-    if ( sig && (method & LIO_WAIT_CBTYPES) )
- sig=0; /* ignore signal parameter */
-#endif
-
     /*
      * only setup signal hander if sig was specified and
      * a sig wait method was specified.
@@ -635,27 +511,6 @@ long wrd; /* to allow future features, u
      *** restoring the signal handler could be added ***
      */
 
-    if ( sig &&  (method & LIO_WAIT_SIGTYPES) ){
-#ifdef CRAY
-        sigctl(SCTL_REG, sig, lio_async_signal_handler);
-#endif
-#ifdef sgi
-        aiocbp.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
- aiocbp.aio_sigevent.sigev_signo = sig;
-        sigset(sig, lio_async_signal_handler);
-#endif /* sgi */
-    }
-#ifdef sgi
-    else if( method & LIO_WAIT_CBTYPES ){
- /* sival_int just has to be something that I can use
- * to identify the callback, and "size" happens to be handy...
- */
- aiocbp.aio_sigevent.sigev_notify = SIGEV_CALLBACK;
- aiocbp.aio_sigevent.sigev_func = lio_async_callback_handler;
- aiocbp.aio_sigevent.sigev_value.sival_int = size;
-    }
-#endif
-
     /*
      * Determine the system call that will be called and produce
      * the string of the system call and place it in Lio_SysCall.
@@ -700,182 +555,6 @@ long wrd; /* to allow future features, u
 
     }
 
-    else if ( method & LIO_IO_ASYNC ) {
-#ifdef CRAY
- sprintf(Lio_SysCall,
-    "writea(%d, buf, %d, &status, %d)", fd, size, sig);
- io_type="writea";
-
-        if ( Debug_level ) {
-    printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
-        }
-
- sigoff();
- if ((ret = writea(fd, buffer, size, &status, sig)) == -1) {
-    sprintf(Errormsg,
- "%s/%d writea(%d, buf, %d, &stat, %d) ret:-1, errno=%d %s",
-    __FILE__, __LINE__,
- fd, size, sig, errno, strerror(errno));
-    sigon();
-    return -errno;
- }
-#endif
-#ifdef sgi
- sprintf(Lio_SysCall,
-    "aio_write(fildes=%d, buf, nbytes=%d, signo=%d)", fd, size, sig);
- io_type="aio_write";
-
-        if ( Debug_level ) {
-    printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
-        }
-
- if( sig )
- sighold( sig );
- if ((ret = aio_write(&aiocbp)) == -1) {
-    sprintf(Errormsg,
- "%s/%d aio_write(fildes=%d, buf, nbytes=%d, signo=%d) ret:-1, errno=%d %s",
-    __FILE__, __LINE__,
- fd, size, sig, errno, strerror(errno));
-    if( sig )
- sigrelse( sig );
-    return -errno;
- }
-#endif
-    } /* LIO_IO_ASYNC */
-
-    else if ( method & LIO_IO_SLISTIO ) {
-#ifdef CRAY
- request.li_opcode = LO_WRITE;
- request.li_fildes = fd;
-        request.li_buf = buffer;
-        request.li_nbyte = size;
-        request.li_status = &status;
-        request.li_signo = sig;
-        request.li_nstride = 0;
-        request.li_filstride = 0;
-        request.li_memstride = 0;
-
- listio_cmd=LC_WAIT;
- io_type="listio(2) sync write";
-
- sprintf(Lio_SysCall,
- "listio(LC_WAIT, &req, 1) LO_WRITE, fd:%d, nbyte:%d",
-                fd, size);
-
-        if ( Debug_level ) {
-    printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
-        }
-
- sigoff();
- if ( listio(listio_cmd, &request, 1) == -1 ) {
-            sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
-    __FILE__, __LINE__,
- Lio_SysCall, fd, size, errno, strerror(errno));
-    sigon();
-            return -errno;
-        }
-
- if ( Debug_level > 1 )
-            printf("DEBUG %s/%d: %s did not return -1\n",
- __FILE__, __LINE__, Lio_SysCall);
-
- ret=lio_check_asyncio(io_type, size,  &status);
- return ret;
-
-#endif
-#ifdef sgi
-
- aiocbp.aio_lio_opcode = LIO_WRITE;
- listio_cmd=LIO_WAIT;
- io_type="lio_listio(3) sync write";
-
- sprintf(Lio_SysCall,
- "lio_listio(LIO_WAIT, aiolist, 1, NULL) LIO_WRITE, fd:%d, nbyte:%d, sig:%d",
-                fd, size, sig );
-
-        if ( Debug_level ) {
-    printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
-        }
-
- if( sig )
-    sighold( sig );
- if ( lio_listio(listio_cmd, aiolist, 1, NULL) == -1 ) {
-            sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
-    __FILE__, __LINE__,
- Lio_SysCall, fd, size, errno, strerror(errno));
-    if( sig )
- sigrelse( sig );
-            return -errno;
-        }
-
- if ( Debug_level > 1 )
-            printf("DEBUG %s/%d: %s did not return -1\n",
- __FILE__, __LINE__, Lio_SysCall);
-
- ret=lio_check_asyncio(io_type, size,  &aiocbp, method);
- return ret;
-#endif
-    } /* LIO_IO_SLISTIO */
-
-    else if ( method & LIO_IO_ALISTIO ) {
-#ifdef CRAY
- request.li_opcode = LO_WRITE;
- request.li_fildes = fd;
-        request.li_buf = buffer;
-        request.li_nbyte = size;
-        request.li_status = &status;
-        request.li_signo = sig;
-        request.li_nstride = 0;
-        request.li_filstride = 0;
-        request.li_memstride = 0;
-
- listio_cmd=LC_START;
- io_type="listio(2) async write";
-
- sprintf(Lio_SysCall,
- "listio(LC_START, &req, 1) LO_WRITE, fd:%d, nbyte:%d",
-                fd, size);
-
-        if ( Debug_level ) {
-    printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
-        }
-
- sigoff();
- if ( listio(listio_cmd, &request, 1) == -1 ) {
-            sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
-    __FILE__, __LINE__,
- Lio_SysCall, fd, size, errno, strerror(errno));
-    sigon();
-            return -errno;
-        }
-#endif
-#ifdef sgi
- aiocbp.aio_lio_opcode = LIO_WRITE;
- listio_cmd=LIO_NOWAIT;
- io_type="lio_listio(3) async write";
-
- sprintf(Lio_SysCall,
- "lio_listio(LIO_NOWAIT, aiolist, 1, NULL) LIO_WRITE, fd:%d, nbyte:%d",
-                fd, size);
-
-        if ( Debug_level ) {
-    printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
-        }
-
- if( sig )
- sighold( sig );
- if ( lio_listio(listio_cmd, aiolist, 1, NULL) == -1 ) {
-            sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
-    __FILE__, __LINE__,
- Lio_SysCall, fd, size, errno, strerror(errno));
-    if( sig )
- sigrelse( sig );
-            return -errno;
-        }
-#endif
-    }/* LIO_IO_ALISTIO */
-
-#ifndef CRAY
     else if ( method & LIO_IO_SYNCV ) {
  io_type="writev(2)";
 
@@ -904,38 +583,6 @@ long wrd; /* to allow future features, u
 
         return ret;
     } /* LIO_IO_SYNCV */
-#endif
-
-#ifdef sgi
-    else if ( method & LIO_IO_SYNCP ) {
- io_type="pwrite(2)";
-
- sprintf(Lio_SysCall,
- "pwrite(%d, buf, %d, %lld)", fd, size, poffset);
-
-        if ( Debug_level ) {
-    printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
-        }
- if ((ret = pwrite(fd, buffer, size, poffset)) == -1) {
-    sprintf(Errormsg, "%s/%d pwrite(%d, buf, %d, %lld) ret:-1, errno=%d %s",
-    __FILE__, __LINE__,
- fd, size, poffset, errno, strerror(errno));
-    return -errno;
- }
-
- if ( ret != size ) {
-            sprintf(Errormsg,
- "%s/%d pwrite(%d, buf, %d, %lld) returned=%d",
-    __FILE__, __LINE__,
-    fd, size, poffset, ret);
-        }
-        else if ( Debug_level > 1 )
-            printf("DEBUG %s/%d: pwrite completed without error (ret %d)\n",
-                __FILE__, __LINE__, ret);
-
-        return ret;
-    } /* LIO_IO_SYNCP */
-#endif
 
     else {
  printf("DEBUG %s/%d: No I/O method chosen\n", __FILE__, __LINE__ );
@@ -943,16 +590,6 @@ long wrd; /* to allow future features, u
     }
 
     /*
-     * wait for async io to complete.
-     */
-#ifdef CRAY
-    ret=lio_wait4asyncio(method, fd, statptr);
-#endif
-#ifdef sgi
-    ret=lio_wait4asyncio(method, fd, &aiocbp);
-#endif
-
-    /*
      * If there was an error waiting for async i/o to complete,
      * return the error value (errno) to the caller.
      * Note: Errormsg should already have been updated.
@@ -976,13 +613,6 @@ long wrd; /* to allow future features, u
      * have been updated but the actual i/o size if returned.
      */
     
-#ifdef CRAY
-    ret=lio_check_asyncio(io_type, size, &status);
-#endif
-#ifdef sgi
-    ret=lio_check_asyncio(io_type, size, &aiocbp, method);
-#endif
-
     return ret;
 } /* end of lio_write_buffer */
 
@@ -1042,18 +672,7 @@ long wrd; /* to allow future features, u
     int listio_cmd; /* Holds the listio/lio_listio cmd */
     int omethod = method;
 #endif
-#ifdef  CRAY
-    struct listreq request; /* Used when a listio is wanted */
-    struct iosw status, *statptr[1];  
-#else
-    /* for linux or sgi */
     struct iovec iov; /* iovec for readv(2) */
-#endif
-#ifdef sgi
-    aiocb_t aiocbp; /* POSIX aio control block */
-    aiocb_t *aiolist[1]; /* list of aio control blocks for lio_listio */
-    off64_t poffset; /* pread(2) offset */
-#endif
 
     /*
      * If LIO_RANDOM bit specified, get new method randomly.
@@ -1070,64 +689,9 @@ long wrd; /* to allow future features, u
  *errmsg = Errormsg;
 
     Rec_signal=Received_signal; /* get the current number of signals received */
-#ifdef sgi
-    Rec_callback=Received_callback; /* get the current number of callbacks received */
-#endif
-
-#ifdef  CRAY
-    bzero(&status, sizeof(struct iosw));
-    bzero(&request, sizeof(struct listreq));
-    statptr[0] = &status;
-#else
-    /* for linux or sgi */
     bzero(&iov, sizeof(struct iovec));
     iov.iov_base = buffer;
     iov.iov_len = size;
-#endif
-#ifdef sgi
-    bzero(&aiocbp, sizeof(aiocb_t));
-    aiocbp.aio_fildes = fd;
-    aiocbp.aio_nbytes = size;
-    aiocbp.aio_buf = buffer;
-/*    aiocbp.aio_offset = lseek( fd, 0, SEEK_CUR ); -- set below */
-    aiocbp.aio_sigevent.sigev_notify = SIGEV_NONE;
-    aiocbp.aio_sigevent.sigev_signo = 0;
-    aiocbp.aio_sigevent.sigev_func = NULL;
-    aiocbp.aio_sigevent.sigev_value.sival_int = 0;
-    aiolist[0] = &aiocbp;
-
-    if( (ret = lseek( fd, 0, SEEK_CUR )) == -1 ){
- ret = 0;
- /* If there is an error and it is not ESPIPE then kick out the error.
- * If the fd is a fifo then we have to make sure that
- * lio_random_methods() didn't select pwrite/pread; if it did then
- * switch to write/read.
- */
- if( errno == ESPIPE ){
- if( method & LIO_IO_SYNCP ){
- if( omethod & LIO_RANDOM ){
- method &= ~LIO_IO_SYNCP;
- method |= LIO_IO_SYNC;
- if( Debug_level > 2 )
- printf("DEBUG %s/%d: random chosen method switched to %#o for fifo\n", __FILE__, __LINE__, method );
- }
- else if( Debug_level ){
- printf("DEBUG %s/%d: pread will fail when it reads from a fifo\n",
-       __FILE__, __LINE__ );
- }
- }
- /* else: let it ride */
- }
- else{
- sprintf(Errormsg, "%s/%d lseek(fd=%d,0,SEEK_CUR) failed, errno=%d  %s",
- __FILE__, __LINE__, fd, errno, strerror(errno));
- return -errno;
- }
-    }
-    poffset = (off64_t)ret;
-    aiocbp.aio_offset = ret;
-
-#endif
 
     /*
      * If the LIO_USE_SIGNAL bit is not set, only use the signal
@@ -1141,11 +705,6 @@ long wrd; /* to allow future features, u
         sig=0;  /* ignore signal parameter */
     }
 
-#ifdef sgi
-    if ( sig && (method & LIO_WAIT_CBTYPES) )
- sig=0; /* ignore signal parameter */
-#endif
-
     /*
      * only setup signal hander if sig was specified and
      * a sig wait method was specified.
@@ -1154,27 +713,6 @@ long wrd; /* to allow future features, u
      *** restoring the signal handler could be added ***
      */
 
-    if ( sig &&  (method & LIO_WAIT_SIGTYPES) ){
-#ifdef CRAY
-    sigctl(SCTL_REG, sig, lio_async_signal_handler);
-#endif
-#ifdef sgi
-    aiocbp.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
-    aiocbp.aio_sigevent.sigev_signo = sig;
-    sigset(sig, lio_async_signal_handler);
-#endif /* CRAY */
-    }
-#ifdef sgi
-    else if( method & LIO_WAIT_CBTYPES ){
-    aiocbp.aio_sigevent.sigev_notify = SIGEV_CALLBACK;
-    aiocbp.aio_sigevent.sigev_func = lio_async_callback_handler;
-    /* sival_int just has to be something that I can use
-     * to identify the callback, and "size" happens to be handy...
-     */
-    aiocbp.aio_sigevent.sigev_value.sival_int = size;
-    }
-#endif
-
     /*
      * Determine the system call that will be called and produce
      * the string of the system call and place it in Lio_SysCall.
@@ -1219,180 +757,6 @@ long wrd; /* to allow future features, u
 
     }
 
-    else if ( method & LIO_IO_ASYNC ) {
-#ifdef CRAY
- sprintf(Lio_SysCall,
-    "reada(%d, buf, %d, &status, %d)", fd, size, sig);
- io_type="reada";
-
-        if ( Debug_level ) {
-    printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
-        }
-
- sigoff();
- if ((ret = reada(fd, buffer, size, &status, sig)) == -1) {
-    sprintf(Errormsg,
- "%s/%d reada(%d, buf, %d, &stat, %d) ret:-1, errno=%d %s",
-    __FILE__, __LINE__,
- fd, size, sig, errno, strerror(errno));
-    sigon();
-    return -errno;
- }
-#endif
-#ifdef sgi
- sprintf(Lio_SysCall,
-    "aio_read(fildes=%d, buf, nbytes=%d, signo=%d)", fd, size, sig);
- io_type="aio_read";
-
-        if ( Debug_level ) {
-    printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
-        }
-
- if( sig )
- sighold( sig );
- if ((ret = aio_read(&aiocbp)) == -1) {
-    sprintf(Errormsg,
- "%s/%d aio_read(fildes=%d, buf, nbytes=%d, signo=%d) ret:-1, errno=%d %s",
-    __FILE__, __LINE__,
- fd, size, sig, errno, strerror(errno));
-    if( sig )
- sigrelse( sig );
-    return -errno;
- }
-#endif
-    } /* LIO_IO_ASYNC */
-
-    else if ( method & LIO_IO_SLISTIO ) {
-#ifdef CRAY
- request.li_opcode = LO_READ;
- request.li_fildes = fd;
-        request.li_buf = buffer;
-        request.li_nbyte = size;
-        request.li_status = &status;
-        request.li_signo = sig;
-        request.li_nstride = 0;
-        request.li_filstride = 0;
-        request.li_memstride = 0;
-
- listio_cmd=LC_WAIT;
- io_type="listio(2) sync read";
-
- sprintf(Lio_SysCall,
- "listio(LC_WAIT, &req, 1) LO_READ, fd:%d, nbyte:%d",
-                fd, size);
-
-        if ( Debug_level ) {
-    printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
-        }
-
- sigoff();
- if ( listio(listio_cmd, &request, 1) == -1 ) {
-            sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
-    __FILE__, __LINE__,
- Lio_SysCall, fd, size, errno, strerror(errno));
-    sigon();
-            return -errno;
-        }
-
- if ( Debug_level > 1 )
-            printf("DEBUG %s/%d: %s did not return -1\n",
- __FILE__, __LINE__, Lio_SysCall);
-
- ret=lio_check_asyncio(io_type, size,  &status);
- return ret;
-#endif
-#ifdef sgi
- aiocbp.aio_lio_opcode = LIO_READ;
- listio_cmd=LIO_WAIT;
- io_type="lio_listio(3) sync read";
-
- sprintf(Lio_SysCall,
- "lio_listio(LIO_WAIT, aiolist, 1, NULL) LIO_READ, fd:%d, nbyte:%d",
-                fd, size);
-
-        if ( Debug_level ) {
-    printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
-        }
-
- if( sig )
- sighold( sig );
- if ( lio_listio(listio_cmd, aiolist, 1, NULL) == -1 ) {
-            sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
-    __FILE__, __LINE__,
- Lio_SysCall, fd, size, errno, strerror(errno));
-    if( sig )
- sigrelse( sig );
-            return -errno;
-        }
-
- if ( Debug_level > 1 )
-            printf("DEBUG %s/%d: %s did not return -1\n",
- __FILE__, __LINE__, Lio_SysCall);
-
- ret=lio_check_asyncio(io_type, size,  &aiocbp, method);
- return ret;
-#endif
-    }/* LIO_IO_SLISTIO */
-
-    else if ( method & LIO_IO_ALISTIO ) {
-#ifdef CRAY
- request.li_opcode = LO_READ;
- request.li_fildes = fd;
-        request.li_buf = buffer;
-        request.li_nbyte = size;
-        request.li_status = &status;
-        request.li_signo = sig;
-        request.li_nstride = 0;
-        request.li_filstride = 0;
-        request.li_memstride = 0;
-
- listio_cmd=LC_START;
- io_type="listio(2) async read";
-
- sprintf(Lio_SysCall,
- "listio(LC_START, &req, 1) LO_READ, fd:%d, nbyte:%d",
-                fd, size);
-
-        if ( Debug_level ) {
-    printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
-        }
-
- sigoff();
- if ( listio(listio_cmd, &request, 1) == -1 ) {
-            sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
-    __FILE__, __LINE__,
- Lio_SysCall, fd, size, errno, strerror(errno));
-    sigon();
-            return -errno;
-        }
-#endif
-#ifdef sgi
- aiocbp.aio_lio_opcode = LIO_READ;
- listio_cmd=LIO_NOWAIT;
- io_type="lio_listio(3) async read";
-
- sprintf(Lio_SysCall,
- "lio_listio(LIO_NOWAIT, aiolist, 1, NULL) LIO_READ, fd:%d, nbyte:%d",
-                fd, size);
-
-        if ( Debug_level ) {
-    printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
-        }
-
- if( sig )
- sighold( sig );
- if ( lio_listio(listio_cmd, aiolist, 1, NULL) == -1 ) {
-            sprintf(Errormsg, "%s/%d %s failed, fd:%d, nbyte:%d errno=%d %s",
-    __FILE__, __LINE__,
- Lio_SysCall, fd, size, errno, strerror(errno));
-    if( sig )
- sigrelse( sig );
-            return -errno;
-        }
-#endif
-    } /* LIO_IO_ALISTIO */
-
-#ifndef CRAY
     else if ( method & LIO_IO_SYNCV ) {
  io_type="readv(2)";
 
@@ -1421,38 +785,6 @@ long wrd; /* to allow future features, u
 
         return ret;
     } /* LIO_IO_SYNCV */
-#endif
-
-#ifdef sgi
-    else if ( method & LIO_IO_SYNCP ) {
- io_type="pread(2)";
-
- sprintf(Lio_SysCall,
- "pread(%d, buf, %d, %lld)", fd, size, poffset);
-
-        if ( Debug_level ) {
-    printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
-        }
- if ((ret = pread(fd, buffer, size, poffset)) == -1) {
-    sprintf(Errormsg, "%s/%d pread(%d, buf, %d, %lld) ret:-1, errno=%d %s",
-    __FILE__, __LINE__,
- fd, size, poffset, errno, strerror(errno));
-    return -errno;
- }
-
- if ( ret != size ) {
-            sprintf(Errormsg,
- "%s/%d pread(%d, buf, %d, %lld) returned=%d",
-    __FILE__, __LINE__,
-    fd, size, poffset, ret);
-        }
-        else if ( Debug_level > 1 )
-            printf("DEBUG %s/%d: pread completed without error (ret %d)\n",
-                __FILE__, __LINE__, ret);
-
-        return ret;
-    } /* LIO_IO_SYNCP */
-#endif
 
     else {
  printf("DEBUG %s/%d: No I/O method chosen\n", __FILE__, __LINE__ );
@@ -1460,17 +792,6 @@ long wrd; /* to allow future features, u
     }
 
     /*
-     * wait for async io to complete.
-     * Note: Sync io should have returned prior to getting here.
-     */
-#ifdef CRAY
-    ret=lio_wait4asyncio(method, fd, statptr);
-#endif
-#ifdef sgi
-    ret=lio_wait4asyncio(method, fd, &aiocbp);
-#endif
-
-    /*
      * If there was an error waiting for async i/o to complete,
      * return the error value (errno) to the caller.
      * Note: Errormsg should already have been updated.
@@ -1494,13 +815,6 @@ long wrd; /* to allow future features, u
      * have been updated but the actual i/o size if returned.
      */
     
-#ifdef CRAY
-    ret=lio_check_asyncio(io_type, size, &status);
-#endif
-#ifdef sgi
-    ret=lio_check_asyncio(io_type, size, &aiocbp, method);
-#endif
-
     return ret;
 } /* end of lio_read_buffer */
 
@@ -1518,37 +832,9 @@ long wrd; /* to allow future features, u
  * (rrl 04/96)
  ***********************************************************************/
 int
-#ifdef CRAY
-lio_check_asyncio(char *io_type, int size, struct iosw *status)
-#else
 lio_check_asyncio(char *io_type, int size, aiocb_t *aiocbp, int method)
-#endif
 {
     int ret;
-
-#ifdef CRAY
-    if ( status->sw_error ) {
-        sprintf(Errormsg,
-            "%s/%d %s, sw_error set = %d %s, sw_count = %d",
- __FILE__, __LINE__, io_type,
-            status->sw_error, strerror(status->sw_error), status->sw_count);
-        return -status->sw_error;
-    }
-    else if ( status->sw_count != size ) {
-        sprintf(Errormsg,
-            "%s/%d %s, sw_count not as expected(%d), but actual:%d",
- __FILE__, __LINE__, io_type,
-            size, status->sw_count);
-    }
-    else if ( Debug_level > 1 ) {
-        printf("DEBUG %s/%d: %s completed without error (sw_error == 0, sw_count == %d)\n",
-            __FILE__, __LINE__, io_type, status->sw_count);
-    }
-
-    return status->sw_count;
-
-#else
-
     int cnt = 1;
 
     /* The I/O may have been synchronous with signal completion.  It doesn't
@@ -1609,8 +895,6 @@ lio_check_asyncio(char *io_type, int siz
 
     return ret;
 
-#endif
-
 } /* end of lio_check_asyncio */
 
 
@@ -1633,39 +917,16 @@ lio_check_asyncio(char *io_type, int siz
  * (rrl 04/96)
  ***********************************************************************/
 int
-#ifdef CRAY
-lio_wait4asyncio(int method, int fd, struct iosw **statptr)
-#else
 lio_wait4asyncio(int method, int fd, aiocb_t *aiocbp)
-#endif
 {
     int cnt;
-#ifdef sgi
-    int ret;
-    const aiocb_t *aioary[1];
-#endif
 
     if ( (method & LIO_WAIT_RECALL)
-#ifdef sgi
- || (method & LIO_WAIT_CBSUSPEND)
- || (method & LIO_WAIT_SIGSUSPEND)
-#endif
  || ((method & LIO_WAIT_TYPES) == 0) ){
  /*
  * If method has LIO_WAIT_RECALL bit set or method does
  * not have any wait method bits set (default), use recall/aio_suspend.
          */
-#ifdef CRAY
-        if ( Debug_level > 2 )
-            printf("DEBUG %s/%d: wait method : recall\n", __FILE__, __LINE__);
-        sigon();
-        if ( recall(fd, 1, statptr) ) {
-    sprintf(Errormsg, "%s/%d recall(%d, 1, stat) failed, errno:%d %s",
-    __FILE__, __LINE__,
- fd, errno, strerror(errno));
-    return -errno;
- }
-#else
         if ( Debug_level > 2 )
             printf("DEBUG %s/%d: wait method : aio_suspend, sigev_notify=%s\n", __FILE__, __LINE__,
      (aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL ? "signal" :
@@ -1698,24 +959,10 @@ lio_wait4asyncio(int method, int fd, aio
  fd, errno, strerror(errno));
     return -errno;
  }
-#endif
-
     } else if ( method & LIO_WAIT_ACTIVE ) {
         if ( Debug_level > 2 )
             printf("DEBUG %s/%d: wait method : active\n", __FILE__, __LINE__);
-#ifdef CRAY
-        sigon();
- /*
-         * loop until sw_flag, sw_count or sw_error field elements
- * change to non-zero.
- */
-        cnt=0;
-        while ( (*statptr)->sw_flag == 0 &&
- (*statptr)->sw_count == 0 &&
- (*statptr)->sw_error == 0 ) {
-   cnt++;
- }
-#else
+
  /* loop while aio_error() returns EINPROGRESS */
  cnt=0;
  while(1){
@@ -1726,7 +973,6 @@ lio_wait4asyncio(int method, int fd, aio
  ++cnt;
  }
 
-#endif
  if ( Debug_level > 5 && cnt && (cnt % 50) == 0 )
  printf("DEBUG %s/%d: wait active cnt = %d\n",
     __FILE__, __LINE__, cnt);
@@ -1734,37 +980,20 @@ lio_wait4asyncio(int method, int fd, aio
     } else if ( method & LIO_WAIT_SIGPAUSE ) {
         if ( Debug_level > 2 )
             printf("DEBUG %s/%d: wait method : sigpause\n", __FILE__, __LINE__);
-#ifdef sgi
- /* note: don't do the sigon() for CRAY in this case.  why? -- roehrich 6/11/97 */
- if( aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL )
- sigrelse( aiocbp->aio_sigevent.sigev_signo );
- else {
- printf("DEBUG %s/%d: sigev_notify != SIGEV_SIGNAL\n", __FILE__, __LINE__ );
- return -1;
- }
-#endif
         pause();
 
     } else if ( method & LIO_WAIT_SIGACTIVE ) {
         if ( Debug_level > 2 )
             printf("DEBUG %s/%d: wait method : sigactive\n", __FILE__, __LINE__);
-#ifdef CRAY
-        sigon();
-#else
  if( aiocbp->aio_sigevent.sigev_notify == SIGEV_SIGNAL )
  sigrelse( aiocbp->aio_sigevent.sigev_signo );
  else {
  printf("DEBUG %s/%d: sigev_notify != SIGEV_SIGNAL\n", __FILE__, __LINE__ );
  return -1;
  }
-#endif
  /* loop waiting for signal */
         while ( Received_signal == Rec_signal ){
-#ifdef CRAY
-                sigon();
-#else
  sigrelse( aiocbp->aio_sigevent.sigev_signo );
-#endif
  }
 
     } else if ( method & LIO_WAIT_NONE ) {
@@ -1779,10 +1008,6 @@ lio_wait4asyncio(int method, int fd, aio
  */
  sprintf(Errormsg, "%s/%d LIO_WAIT_NONE was selected (this is broken)\n",
  __FILE__, __LINE__ );
-#ifdef CRAY
-        sigon();
-#endif
-/*        return 1;*/
         return -1;
     }
     else {
Index: b/ltp/doio.c
===================================================================
--- a/ltp/doio.c
+++ b/ltp/doio.c
@@ -29,12 +29,6 @@
 
 #include "global.h"
 
-#ifdef sgi
-#include <aio.h> /* for aio_read,write */
-#include <inttypes.h> /* for uint64_t type */
-#include <siginfo.h> /* signal handlers & SA_SIGINFO */
-#endif
-
 #include <sys/uio.h> /* for struct iovec (readv)*/
 #include <sys/mman.h> /* for mmap(2) */
 #include <sys/ipc.h> /* for i/o buffer in shared memory */
@@ -55,7 +49,7 @@ int do_xfsctl(struct io_req *);
 #include "string_to_tokens.h"
 
 #ifndef O_SSD
-#define O_SSD 0     /* so code compiles on a CRAY2 */
+#define O_SSD 0                /* so code compiles on a CRAY2 */
 #endif
 
 #define UINT64_T unsigned long long
@@ -66,11 +60,7 @@ int do_xfsctl(struct io_req *);
 
 #define PPID_CHECK_INTERVAL 5 /* check ppid every <-- iterations */
 #define MAX_AIO 256 /* maximum number of async I/O ops */
-#ifdef _CRAYMPP
-#define MPP_BUMP 16 /* page un-alignment for MPP */
-#else
 #define MPP_BUMP 0
-#endif
 
 
 #define SYSERR strerror(errno)
@@ -187,10 +177,8 @@ struct fd_cache {
  int c_miniosz;
  int c_maxiosz;
 #endif
-#ifndef CRAY
  void *c_memaddr; /* mmapped address */
  int c_memlen; /* length of above region */
-#endif
 };
 
 #define FD_ALLOC_INCR 32      /* allocate this many fd_map structs */
@@ -221,10 +209,8 @@ void sigint_handler(); /* Catch SIGINT i
 void die_handler(); /* Bad sig in child doios, exit 1. */
 void cleanup_handler(); /* Normal kill, exit 0. */
 
-#ifndef CRAY
 void sigbus_handler(); /* Handle sigbus--check active_mmap_rw to
    decide if this should be a normal exit. */
-#endif
 
 void cb_handler(); /* Posix aio callback handler. */
 void noop_handler(); /* Delayop alarm, does nothing. */
@@ -287,14 +273,6 @@ struct aio_info {
  int fd;
  int strategy;
  volatile int done;
-#ifdef CRAY
- struct iosw iosw;
-#endif
-#ifdef sgi
- aiocb_t aiocb;
- int aio_ret; /* from aio_return */
- int aio_errno; /* from aio_error */
-#endif
  int sig;
  int signalled;
  struct sigaction osa;
@@ -322,9 +300,6 @@ struct smap checkmap[] = {
 struct smap delaymap[] = {
  { "select", DELAY_SELECT },
  { "sleep", DELAY_SLEEP },
-#ifdef sgi
- { "sginap", DELAY_SGINAP },
-#endif
  { "alarm", DELAY_ALARM },
  { NULL, 0 },
 };
@@ -352,10 +327,6 @@ char **argv;
  struct sigaction sa;
  sigset_t block_mask, old_mask;
  umask(0); /* force new file modes to known values */
-#if _CRAYMPP
- Npes = sysconf(_SC_CRAY_NPES); /* must do this before parse_cmdline */
- Vpe = sysconf(_SC_CRAY_VPE);
-#endif
 
  TagName[0] = '\0';
  parse_cmdline(argc, argv, OPTS);
@@ -577,9 +548,7 @@ doio()
  char *cp;
  struct io_req   ioreq;
  struct sigaction sa, def_action, ignore_action, exit_action;
-#ifndef CRAY
  struct sigaction sigbus_action;
-#endif
 
  Memsize = Sdssize = 0;
 
@@ -653,19 +622,6 @@ doio()
  def_action.sa_flags = 0;
  sigemptyset(&def_action.sa_mask);
 
-#ifdef sgi
- exit_action.sa_sigaction = cleanup_handler;
- exit_action.sa_flags = SA_SIGINFO;
- sigemptyset(&exit_action.sa_mask);
-
- sa.sa_sigaction = die_handler;
- sa.sa_flags = SA_SIGINFO;
- sigemptyset(&sa.sa_mask);
-
- sigbus_action.sa_sigaction = sigbus_handler;
- sigbus_action.sa_flags = SA_SIGINFO;
- sigemptyset(&sigbus_action.sa_mask);
-#else
  exit_action.sa_handler = cleanup_handler;
  exit_action.sa_flags = 0;
  sigemptyset(&exit_action.sa_mask);
@@ -674,12 +630,9 @@ doio()
  sa.sa_flags = 0;
  sigemptyset(&sa.sa_mask);
 
-#ifndef CRAY
  sigbus_action.sa_handler = sigbus_handler;
  sigbus_action.sa_flags = 0;
  sigemptyset(&sigbus_action.sa_mask);
-#endif
-#endif
 
  for (i = 1; i <= NSIG; i++) {
  switch(i) {
@@ -688,12 +641,10 @@ doio()
  sigaction(i, &exit_action, NULL);
  break;
 
-#ifndef CRAY
  /* This depends on active_mmap_rw */
  case SIGBUS:
  sigaction(i, &sigbus_action, NULL);
  break;
-#endif
 
     /* Signals to Ignore... */
  case SIGSTOP:
@@ -790,15 +741,6 @@ doio()
  alloc_mem(-1);
 #endif
  }
-
-#ifdef _CRAY1
- if (Sdssize) {
- ssbreak(-1 * btoc(Sdssize));
- Sdsptr = 0;
- Sdssize = 0;
- }
-#endif /* _CRAY1 */
-
  alloc_fd(NULL, 0);
  }
 
@@ -835,31 +777,16 @@ doio()
  case LEWRITEA:
  rval = do_rw(&ioreq);
  break;
-
-#ifdef CRAY
- case SSREAD:
- case SSWRITE:
- rval = do_ssdio(&ioreq);
- break;
-
- case LISTIO:
- rval = do_listio(&ioreq);
- break;
-#endif
-
 #ifndef NO_XFS
  case RESVSP:
  case UNRESVSP:
  rval = do_xfsctl(&ioreq);
  break;
 #endif
-
-#ifndef CRAY
  case FSYNC2:
  case FDATASYNC:
  rval = do_sync(&ioreq);
  break;
-#endif
  default:
  doio_fprintf(stderr,
      "Don't know how to handle io request type %d\n",
@@ -917,12 +844,6 @@ doio_delay()
  sleep(delaytime);
  break;
 
-#ifdef sgi
- case DELAY_SGINAP:
- sginap(delaytime);
- break;
-#endif
-
  case DELAY_ALARM:
  sa_al.sa_flags = 0;
  sa_al.sa_handler = noop_handler;
@@ -1019,35 +940,9 @@ format_oflags(int oflags)
 
  if(oflags & O_SYNC)
  strcat(flags,"O_SYNC,");
-#ifdef CRAY
- if(oflags & O_RAW)
- strcat(flags,"O_RAW,");
- if(oflags & O_WELLFORMED)
- strcat(flags,"O_WELLFORMED,");
-#ifdef O_SSD
- if(oflags & O_SSD)
- strcat(flags,"O_SSD,");
-#endif
- if(oflags & O_LDRAW)
- strcat(flags,"O_LDRAW,");
- if(oflags & O_PARALLEL)
- strcat(flags,"O_PARALLEL,");
- if(oflags & O_BIG)
- strcat(flags,"O_BIG,");
- if(oflags & O_PLACE)
- strcat(flags,"O_PLACE,");
- if(oflags & O_ASYNC)
- strcat(flags,"O_ASYNC,");
-#endif
 
  if(oflags & O_DIRECT)
  strcat(flags,"O_DIRECT,");
-#ifdef sgi
- if(oflags & O_DSYNC)
- strcat(flags,"O_DSYNC,");
- if(oflags & O_RSYNC)
- strcat(flags,"O_RSYNC,");
-#endif
 
  return(strdup(flags));
 }
@@ -1083,11 +978,7 @@ format_rw(
  void *buffer,
  int signo,
  char *pattern,
-#ifdef CRAY
- struct iosw *iosw
-#else
  void *iosw
-#endif
  )
 {
  static char *errbuf=NULL;
@@ -1155,44 +1046,6 @@ format_rw(
  return errbuf;
 }
 
-#ifdef CRAY
-char *
-format_sds(
- struct io_req *ioreq,
- void *buffer,
- int sds,
- char *pattern
- )
-{
- int i;
- static char *errbuf=NULL;
- char *cp;
-
- struct ssread_req *ssreadp = &ioreq->r_data.ssread;
- struct sswrite_req *sswritep = &ioreq->r_data.sswrite;
-
- if(errbuf == NULL)
- errbuf = (char *)malloc(32768);
-
- cp = errbuf;
- cp += sprintf(cp, "Request number %d\n", Reqno);
-
-
- switch (ioreq->r_type) {
- case SSREAD:
- cp += sprintf(cp, "syscall:  ssread(%#o, %#o, %d)\n",
-      buffer, sds, ssreadp->r_nbytes);
- break;
-
- case SSWRITE:
- cp += sprintf(cp, "syscall:  sswrite(%#o, %#o, %d) - pattern was %s\n",
-      buffer, sds, sswritep->r_nbytes, pattern);
- break;
- }
- return errbuf;
-}
-#endif /* CRAY */
-
 /*
  * Perform the various sorts of disk reads
  */
@@ -1203,10 +1056,6 @@ struct io_req *req;
 {
  int         fd, offset, nbytes, oflags, rval;
  char         *addr, *file;
-#ifdef CRAY
- struct aio_info *aiop;
- int aio_id, aio_strat, signo;
-#endif
 #ifndef NO_XFS
  struct fd_cache *fdc;
 #endif
@@ -1241,28 +1090,6 @@ struct io_req *req;
 #define wtob(x) (x * sizeof(UINT64_T))
 #endif
 
-#ifdef CRAY
- if (oflags & O_SSD) {
- if (alloc_sds(nbytes) == -1)
- return -1;
-
- addr = (char *)Sdsptr;
- } else {
- if ((rval = alloc_mem(nbytes + wtob(1) * 2 + MPP_BUMP * sizeof(UINT64_T))) < 0) {
- return rval;
- }
-
- addr = Memptr;
-
- /*
- * if io is not raw, bump the offset by a random amount
- * to generate non-word-aligned io.
- */
- if (! (req->r_data.read.r_uflags & F_WORD_ALIGNED)) {
- addr += random_range(0, wtob(1) - 1, 1, NULL);
- }
- }
-#else
 #ifndef NO_XFS
  /* get memory alignment for using DIRECT I/O */
  fdc = alloc_fdcache(file, oflags);
@@ -1290,8 +1117,7 @@ struct io_req *req;
  }
 
  addr = Memptr;
-#endif /* !CRAY && sgi */
-#endif /* CRAY */
+#endif /* !NO_XFS */
 
 
  switch (req->r_type) {
@@ -1320,66 +1146,6 @@ struct io_req *req;
  return -1;
  }
  break;
-
-#ifdef CRAY
- case READA:
- /*
- * Async read
- */
-
-        /* move to the desired file position. */
- if (lseek(fd, offset, SEEK_SET) == -1) {
- doio_fprintf(stderr,
-     "lseek(%d, %d, SEEK_SET) failed:  %s (%d)\n",
-     fd, offset, SYSERR, errno);
- return -1;
- }
-
- aio_strat = req->r_data.read.r_aio_strat;
- signo = (aio_strat == A_SIGNAL) ? SIGUSR1 : 0;
-
- aio_id = aio_register(fd, aio_strat, signo);
- aiop = aio_slot(aio_id);
-
- if (reada(fd, addr, nbytes, &aiop->iosw, signo) == -1) {
- doio_fprintf(stderr, "reada() failed: %s (%d)\n%s\n",
-     SYSERR, errno,
-     format_rw(req, fd, addr, signo, NULL, &aiop->iosw));
- aio_unregister(aio_id);
- doio_upanic(U_RVAL);
- rval = -1;
- } else {
- /*
- * Wait for io to complete
- */
-
- aio_wait(aio_id);
-
- /*
- * make sure the io completed without error
- */
-
- if (aiop->iosw.sw_count != nbytes) {
- doio_fprintf(stderr,
-     "Bad iosw from reada()\nExpected (%d,%d,%d), got (%d,%d,%d)\n%s\n",
-     1, 0, nbytes,
-     aiop->iosw.sw_flag,
-     aiop->iosw.sw_error,
-     aiop->iosw.sw_count,
-     format_rw(req, fd, addr, signo, NULL, &aiop->iosw));
- aio_unregister(aio_id);
- doio_upanic(U_IOSW);
- rval = -1;
- } else {
- aio_unregister(aio_id);
- rval = 0;
- }
- }
-
- if (rval == -1)
- return rval;
- break;
-#endif /* CRAY */
  }
 
  return 0; /* if we get here, everything went ok */
@@ -1401,10 +1167,6 @@ struct io_req *req;
  long         offset, woffset = 0;
  char         *addr, pattern, *file, *msg;
  struct wlog_rec wrec;
-#ifdef CRAY
- int aio_strat, aio_id;
- struct aio_info *aiop;
-#endif
 #ifndef NO_XFS
  struct fd_cache *fdc;
 #endif
@@ -1444,54 +1206,6 @@ struct io_req *req;
  * Allocate SDS space for backdoor write if desired
  */
 
-#ifdef CRAY
- if (oflags & O_SSD) {
-#ifndef _CRAYMPP
- if ((rval = alloc_mem(nbytes + wtob(1))) < 0) {
- return rval;
- }
-
- (*Data_Fill)(Memptr, nbytes, Pattern, Pattern_Length, 0);
- /*pattern_fill(Memptr, nbytes, Pattern, Pattern_Length, 0);*/
-
- if (alloc_sds(nbytes) == -1)
- return -1;
-
- if (sswrite((long)Memptr, Sdsptr, btoc(nbytes)) == -1) {
- doio_fprintf(stderr, "sswrite(%d, %d, %d) failed:  %s (%d)\n",
-     (long)Memptr, Sdsptr, btoc(nbytes),
-     SYSERR, errno);
- fflush(stderr);
- return -1;
- }
-
- addr = (char *)Sdsptr;
-#else
- doio_fprintf(stderr, "Invalid O_SSD flag was generated for MPP system\n");
- fflush(stderr);
- return -1;
-#endif /* !CRAYMPP */
- } else {
- if ((rval = alloc_mem(nbytes + wtob(1)) < 0)) {
- return rval;
- }
-
- addr = Memptr;
-
- /*
- * if io is not raw, bump the offset by a random amount
- * to generate non-word-aligned io.
- */
-
- if (! (req->r_data.write.r_uflags & F_WORD_ALIGNED)) {
- addr += random_range(0, wtob(1) - 1, 1, NULL);
- }
-
- (*Data_Fill)(Memptr, nbytes, Pattern, Pattern_Length, 0);
- if( addr != Memptr )
- memmove( addr, Memptr, nbytes);
- }
-#else /* CRAY */
 #ifndef NO_XFS
  /* get memory alignment for using DIRECT I/O */
  fdc = alloc_fdcache(file, oflags);
@@ -1528,7 +1242,6 @@ struct io_req *req;
  if( addr != Memptr )
  memmove( addr, Memptr, nbytes);
 #endif /* sgi */
-#endif /* CRAY */
 
  rval = -1;
  got_lock = 0;
@@ -1625,68 +1338,6 @@ struct io_req *req;
  }
 
  break;
-
-#ifdef CRAY
- case WRITEA:
- /*
- * async write
- */
- if (lseek(fd, offset, SEEK_SET) == -1) {
- doio_fprintf(stderr,
-     "lseek(%d, %d, SEEK_SET) failed:  %s (%d)\n",
-     fd, offset, SYSERR, errno);
- return -1;
- }
-
- aio_strat = req->r_data.write.r_aio_strat;
- signo = (aio_strat == A_SIGNAL) ? SIGUSR1 : 0;
-
- aio_id = aio_register(fd, aio_strat, signo);
- aiop = aio_slot(aio_id);
-
- /*
- * init iosw and do the async write
- */
-
- if (writea(fd, addr, nbytes, &aiop->iosw, signo) == -1) {
- doio_fprintf(stderr,
-     "writea() failed: %s (%d)\n%s\n",
-     SYSERR, errno,
-     format_rw(req, fd, addr, -1, Pattern, NULL));
- doio_upanic(U_RVAL);
- aio_unregister(aio_id);
- rval = -1;
- } else {
-
- /*
- * Wait for io to complete
- */
-
- aio_wait(aio_id);
-
- /*
- * check that iosw is ok
- */
-
- if (aiop->iosw.sw_count != nbytes) {
- doio_fprintf(stderr,
-     "Bad iosw from writea()\nExpected (%d,%d,%d), got (%d,%d,%d)\n%s\n",
-     1, 0, nbytes,
-     aiop->iosw.sw_flag,
-     aiop->iosw.sw_error,
-     aiop->iosw.sw_count,
-     format_rw(req, fd, addr, -1, Pattern, &aiop->iosw));
- aio_unregister(aio_id);
- doio_upanic(U_IOSW);
- rval = -1;
- } else {
- aio_unregister(aio_id);
- rval = 0;
- }
- }
- break;
-
-#endif /* CRAY */
  }
 
  /*
@@ -1701,11 +1352,7 @@ struct io_req *req;
  if (msg != NULL) {
    doio_fprintf(stderr, "%s%s\n",
      msg,
-#ifdef CRAY
-     format_rw(req, fd, addr, -1, Pattern, &aiop->iosw)
-#else
      format_rw(req, fd, addr, -1, Pattern, NULL)
-#endif
  );
  doio_upanic(U_CORRUPTION);
  exit(E_COMPARE);
@@ -1773,515 +1420,97 @@ int nbytes;
  return 0;
 }
 
-/*
- * Perform a listio request.
+int
+do_listio(req)
+struct io_req *req;
+{
+ return -1;
+}
+
+/* ---------------------------------------------------------------------------
+ *
+ * A new paradigm of doing the r/w system call where there is a "stub"
+ * function that builds the info for the system call, then does the system
+ * call; this is called by code that is common to all system calls and does
+ * the syscall return checking, async I/O wait, iosw check, etc.
+ *
+ * Flags:
+ * WRITE, ASYNC, SSD/SDS,
+ * FILE_LOCK, WRITE_LOG, VERIFY_DATA,
  */
 
-#ifdef CRAY
+struct status {
+ int rval; /* syscall return */
+ int err; /* errno */
+ int *aioid; /* list of async I/O structures */
+};
+
+struct syscall_info {
+ char *sy_name;
+ int sy_type;
+ struct status *(*sy_syscall)();
+ int (*sy_buffer)();
+ char *(*sy_format)();
+ int sy_flags;
+ int sy_bits;
+};
+
+#define SY_WRITE 00001
+#define SY_ASYNC 00010
+#define SY_IOSW 00020
+#define SY_SDS 00100
+
 char *
-format_listio(
- struct io_req *ioreq,
- int lcmd,
- struct listreq *list,
- int nent,
- int fd,
- char *pattern
- )
+fmt_ioreq(struct io_req *ioreq, struct syscall_info *sy, int fd)
 {
- static char *errbuf=NULL;
- struct listio_req *liop = &ioreq->r_data.listio;
- struct listreq *listreq;
- char *cp, *cmd, *opcode, *aio_strat;
- int i;
-
- switch (lcmd) {
- case LC_START: cmd = "LC_START"; break;
- case LC_WAIT: cmd = "LC_WAIT"; break;
- default: cmd = "???"; break;
- }
+ static char *errbuf=NULL;
+ char *cp;
+ struct rw_req *io;
+ struct smap *aname;
 
  if(errbuf == NULL)
  errbuf = (char *)malloc(32768);
 
+ io = &ioreq->r_data.io;
+
+ /*
+ * Look up async I/O completion strategy
+ */
+ for(aname=aionames;
+    aname->value != -1 && aname->value != io->r_aio_strat;
+    aname++)
+ ;
+
  cp = errbuf;
  cp += sprintf(cp, "Request number %d\n", Reqno);
 
- cp += sprintf(cp, "syscall:  listio(%s, %#o, %d)\n\n",
-      cmd, list, nent);
+ cp += sprintf(cp, "          fd %d is file %s - open flags are %#o %s\n",
+      fd, io->r_file, io->r_oflags, format_oflags(io->r_oflags));
 
- aio_strat = format_strat(liop->r_aio_strat);
+ if(sy->sy_flags & SY_WRITE) {
+ cp += sprintf(cp, "          write done at file offset %d - pattern is %c (%#o)\n",
+      io->r_offset,
+      (io->r_pattern == '\0') ? '?' : io->r_pattern,
+      io->r_pattern);
+ } else {
+ cp += sprintf(cp, "          read done at file offset %d\n",
+      io->r_offset);
+ }
 
- for (i = 0; i < nent; i++) {
- cp += sprintf(cp, "struct lioreq for request element %d\n", i);
- cp += sprintf(cp, "----------------------------------------\n");
+ if(sy->sy_flags & SY_ASYNC) {
+ cp += sprintf(cp, "          async io completion strategy is %s\n",
+      aname->string);
+ }
 
- listreq = list + i;
+ cp += sprintf(cp, "          number of requests is %d, strides per request is %d\n",
+      io->r_nent, io->r_nstrides);
 
- switch (listreq->li_opcode) {
- case LO_READ: opcode = "LO_READ"; break;
- case LO_WRITE: opcode = "LO_WRITE"; break;
- default: opcode = "???"; break;
- }
-
- cp += sprintf(cp, "          li_opcode =    %s\n", opcode);
- cp += sprintf(cp, "          li_drvr =      %#o\n", listreq->li_drvr);
- cp += sprintf(cp, "          li_flags =     %#o\n", listreq->li_flags);
- cp += sprintf(cp, "          li_offset =    %d\n", listreq->li_offset);
- cp += sprintf(cp, "          li_fildes =    %d\n", listreq->li_fildes);
- cp += sprintf(cp, "          li_buf =       %#o\n", listreq->li_buf);
- cp += sprintf(cp, "          li_nbyte =     %d\n", listreq->li_nbyte);
- 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);
- cp += sprintf(cp, "          li_signo =     %d\n", listreq->li_signo);
- cp += sprintf(cp, "          li_nstride =   %d\n", listreq->li_nstride);
- cp += sprintf(cp, "          li_filstride = %d\n", listreq->li_filstride);
- cp += sprintf(cp, "          li_memstride = %d\n", listreq->li_memstride);
- cp += sprintf(cp, "          io completion strategy is %s\n", aio_strat);
- }
- return errbuf;
-}
-#endif /* CRAY */
-
-int
-do_listio(req)
-struct io_req *req;
-{
-#ifdef CRAY
- struct listio_req *lio;
- int         fd, oflags, signo, nb, i;
- int         logged_write, rval, got_lock;
- int aio_strat, aio_id;
- int min_byte, max_byte;
- int mem_needed;
- int       foffset, fstride, mstride, nstrides;
- char *moffset;
- long         offset, woffset;
- char         *addr, *msg;
- sigset_t block_mask, omask;
- struct wlog_rec wrec;
- struct aio_info *aiop;
- struct listreq lio_req;
-
- lio = &req->r_data.listio;
-
- /*
- * If bytes per stride is less than the stride size, drop the request
- * since it will cause overlapping strides, and we cannot predict
- * the order they will complete in.
- */
-
- if (lio->r_filestride && abs(lio->r_filestride) < lio->r_nbytes) {
- doio_fprintf(stderr, "do_listio():  Bogus listio request - abs(filestride) [%d] < nbytes [%d]\n",
-     abs(lio->r_filestride), lio->r_nbytes);
- return -1;
- }
-
- /*
- * Allocate core memory.  Initialize the data to be written.  Make
- * sure we get enough, based on the memstride.
- */
-
- mem_needed =
- stride_bounds(0, lio->r_memstride, lio->r_nstrides,
-      lio->r_nbytes, NULL, NULL);
-
- if ((rval = alloc_mem(mem_needed + wtob(1))) < 0) {
- return rval;
- }
-
- /*
- * Set the memory address pointer.  If the io is not raw, adjust
- * addr by a random amount, so that non-raw io is not necessarily
- * word aligned.
- */
-
- addr = Memptr;
-
- if (! (lio->r_uflags & F_WORD_ALIGNED)) {
- addr += random_range(0, wtob(1) - 1, 1, NULL);
- }
-
- if (lio->r_opcode == LO_WRITE) {
- Pattern[0] = lio->r_pattern;
- (*Data_Fill)(Memptr, mem_needed, Pattern, Pattern_Length, 0);
- if( addr != Memptr )
- memmove( addr, Memptr, mem_needed);
- }
-
- /*
- * Get a descriptor to do the io on.  No need to do an lseek, as this
- * is encoded in the listio request.
- */
-
- if ((fd = alloc_fd(lio->r_file, lio->r_oflags)) == -1) {
- return -1;
- }
-
- rval = -1;
- got_lock = 0;
- logged_write = 0;
-
- /*
- * If the opcode is LO_WRITE, lock all regions of the file that
- * are touched by this listio request.  Currently, we use
- * stride_bounds() to figure out the min and max bytes affected, and
- * lock the entire region, regardless of the file stride.
- */
-
- if (lio->r_opcode == LO_WRITE && k_opt) {
- stride_bounds(lio->r_offset,
-      lio->r_filestride, lio->r_nstrides,
-      lio->r_nbytes, &min_byte, &max_byte);
-
- if (lock_file_region(lio->r_file, fd, F_WRLCK,
-     min_byte, (max_byte-min_byte+1)) < 0) {
- doio_fprintf(stderr, "stride_bounds(%d, %d, %d, %d, ..., ...) set min_byte to %d, max_byte to %d\n",
-     lio->r_offset, lio->r_filestride,
-     lio->r_nstrides, lio->r_nbytes, min_byte,
-     max_byte);
- return -1;
- } else {
- got_lock = 1;
- }
- }
-
- /*
- * async write
- */
-
- aio_strat = lio->r_aio_strat;
- signo = (aio_strat == A_SIGNAL) ? SIGUSR1 : 0;
-
- aio_id = aio_register(fd, aio_strat, signo);
- aiop = aio_slot(aio_id);
-
- /*
- * Form the listio request, and make the call.
- */
-
- lio_req.li_opcode = lio->r_opcode;
- lio_req.li_drvr = 0;
- lio_req.li_flags = LF_LSEEK;
- lio_req.li_offset = lio->r_offset;
- lio_req.li_fildes = fd;
-
- if (lio->r_memstride >= 0 || lio->r_nstrides <= 1) {
- lio_req.li_buf = addr;
- } else {
- lio_req.li_buf = addr + mem_needed - lio->r_nbytes;
- }
-
- lio_req.li_nbyte = lio->r_nbytes;
- lio_req.li_status = &aiop->iosw;
- lio_req.li_signo = signo;
- lio_req.li_nstride = lio->r_nstrides;
- lio_req.li_filstride = lio->r_filestride;
- lio_req.li_memstride = lio->r_memstride;
-
- /*
- * If signo != 0, block signo while we're in the system call, so that
- * we don't get interrupted syscall failures.
- */
-
- if (signo) {
- sigemptyset(&block_mask);
- sigaddset(&block_mask, signo);
- sigprocmask(SIG_BLOCK, &block_mask, &omask);
- }
-
- if (listio(lio->r_cmd, &lio_req, 1) < 0) {
- doio_fprintf(stderr,
-     "listio() failed: %s (%d)\n%s\n",
-     SYSERR, errno,
-     format_listio(req, lio->r_cmd, &lio_req, 1, fd, Pattern));
- aio_unregister(aio_id);
- doio_upanic(U_RVAL);
- goto lio_done;
- }
-
- if (signo) {
- sigprocmask(SIG_SETMASK, &omask, NULL);
- }
-
- /*
- * Wait for io to complete
- */
-
- aio_wait(aio_id);
-
- nstrides = lio->r_nstrides ? lio->r_nstrides : 1;
- if (aiop->iosw.sw_count != lio->r_nbytes * nstrides) {
- doio_fprintf(stderr,
-     "Bad iosw from listio()\nExpected (%d,%d,%d), got (%d,%d,%d)\n%s\n",
-     1, 0, lio->r_nbytes * lio->r_nstrides,
-     aiop->iosw.sw_flag,
-     aiop->iosw.sw_error, aiop->iosw.sw_count,
-     format_listio(req, lio->r_cmd, &lio_req, 1, fd, Pattern));
- aio_unregister(aio_id);
- doio_upanic(U_IOSW);
- goto lio_done;
- }
-
- aio_unregister(aio_id);
-
- /*
- * Verify that the data was written correctly - check_file() returns
- * a non-null pointer which contains an error message if there are
- * problems.
- *
- * For listio, we basically have to make 1 call to check_file for each
- * stride.
- */
-
- if (v_opt && lio_req.li_opcode == LO_WRITE) {
- fstride = lio->r_filestride ? lio->r_filestride : lio->r_nbytes;
- mstride = lio->r_memstride ? lio->r_memstride : lio->r_nbytes;
- foffset = lio->r_offset;
-
- if (mstride> 0 || lio->r_nstrides <= 1) {
- moffset = addr;
- } else {
- moffset = addr + mem_needed - lio->r_nbytes;
- }
-
- for (i = 0; i < lio_req.li_nstride; i++) {
- msg = check_file(lio->r_file,
- foffset, lio->r_nbytes,
- Pattern, Pattern_Length,
- moffset - addr,
- lio->r_oflags & O_PARALLEL);
-
- if (msg != NULL) {
- doio_fprintf(stderr, "%s\n%s\n",
-     msg,
-     format_listio(req, lio->r_cmd, &lio_req, 1, fd, Pattern));
- doio_upanic(U_CORRUPTION);
-     exit(E_COMPARE);
- }
-
- moffset += mstride;
- foffset += fstride;
- }
-
- }
-
- rval = 0;
-
- lio_done:
-
- /*
- * General cleanup ...
- *
- */
-
- /*
- * Release file locks if necessary
- */
-
- if (got_lock) {
- if (lock_file_region(lio->r_file, fd, F_UNLCK,
-     min_byte, (max_byte-min_byte+1)) < 0) {
- return -1;
- }
- }
-
- return rval;
-#else
- return -1;
-#endif
-}
-
-/*
- * perform ssread/sswrite operations
- */
-
-#ifdef _CRAY1
-
-int
-do_ssdio(req)
-struct io_req *req;
-{
- int    nbytes, nb;
- char    errbuf[BSIZE];
-
- nbytes = req->r_data.ssread.r_nbytes;
-
- /*
- * Grab core and sds space
- */
-
- if ((nb = alloc_mem(nbytes)) < 0)
- return nb;
-
- if (alloc_sds(nbytes) == -1)
- return -1;
-
- if (req->r_type == SSWRITE) {
-
- /*
- * Init data and ship it to the ssd
- */
-
- Pattern[0] = req->r_data.sswrite.r_pattern;
- /*pattern_fill(Memptr, nbytes, Pattern, Pattern_Length, 0);*/
- (*Data_Fill)(Memptr, nbytes, Pattern, Pattern_Length, 0);
-
- if (sswrite((long)Memptr, (long)Sdsptr, btoc(nbytes)) == -1) {
- doio_fprintf(stderr, "sswrite() failed:  %s (%d)\n%s\n",
-     SYSERR, errno,
-     format_sds(req, Memptr, Sdsptr, Pattern));
- doio_upanic(U_RVAL);
- return -1;
- }
- } else {
- /*
- * read from sds
- */
-
- if (ssread((long)Memptr, (long)Sdsptr, btoc(nbytes)) == -1) {
- doio_fprintf(stderr, "ssread() failed: %s (%d)\n%s\n",
-     SYSERR, errno,
-     format_sds(req, Memptr, Sdsptr, Pattern));
-
- doio_upanic(U_RVAL);
- return -1;
- }
- }
-
- /*
- * Verify data if SSWRITE and v_opt
- */
-
- if (v_opt && req->r_type == SSWRITE) {
- ssread((long)Memptr, (long)Sdsptr, btoc(nbytes));
-
- if (pattern_check(Memptr, nbytes, Pattern, Pattern_Length, 0) == -1) {
- doio_fprintf(stderr,
-     "sds DATA COMPARE ERROR - ABORTING\n%s\n",
-     format_sds(req, Memptr, Sdsptr, Pattern));
-
- doio_upanic(U_CORRUPTION);
- exit(E_COMPARE);
- }
- }
-}
-
-#else
-
-#ifdef CRAY
-
-int
-do_ssdio(req)
-struct io_req *req;
-{
- doio_fprintf(stderr,
-     "Internal Error - do_ssdio() called on a non-cray1 system\n");
- alloc_mem(-1);
- exit(E_INTERNAL);
-}
-
-#endif
-
-#endif /* _CRAY1 */
-
-
-/* ---------------------------------------------------------------------------
- *
- * A new paradigm of doing the r/w system call where there is a "stub"
- * function that builds the info for the system call, then does the system
- * call; this is called by code that is common to all system calls and does
- * the syscall return checking, async I/O wait, iosw check, etc.
- *
- * Flags:
- * WRITE, ASYNC, SSD/SDS,
- * FILE_LOCK, WRITE_LOG, VERIFY_DATA,
- */
-
-struct status {
- int rval; /* syscall return */
- int err; /* errno */
- int *aioid; /* list of async I/O structures */
-};
-
-struct syscall_info {
- char *sy_name;
- int sy_type;
- struct status *(*sy_syscall)();
- int (*sy_buffer)();
- char *(*sy_format)();
- int sy_flags;
- int sy_bits;
-};
-
-#define SY_WRITE 00001
-#define SY_ASYNC 00010
-#define SY_IOSW 00020
-#define SY_SDS 00100
-
-char *
-fmt_ioreq(struct io_req *ioreq, struct syscall_info *sy, int fd)
-{
- static char *errbuf=NULL;
- char *cp;
- struct rw_req *io;
- struct smap *aname;
-#ifdef CRAY
- struct stat sbuf;
-#endif
-
- if(errbuf == NULL)
- errbuf = (char *)malloc(32768);
-
- io = &ioreq->r_data.io;
-
- /*
- * Look up async I/O completion strategy
- */
- for(aname=aionames;
-    aname->value != -1 && aname->value != io->r_aio_strat;
-    aname++)
- ;
-
- cp = errbuf;
- cp += sprintf(cp, "Request number %d\n", Reqno);
-
- cp += sprintf(cp, "          fd %d is file %s - open flags are %#o %s\n",
-      fd, io->r_file, io->r_oflags, format_oflags(io->r_oflags));
-
- if(sy->sy_flags & SY_WRITE) {
- cp += sprintf(cp, "          write done at file offset %d - pattern is %c (%#o)\n",
-      io->r_offset,
-      (io->r_pattern == '\0') ? '?' : io->r_pattern,
-      io->r_pattern);
- } else {
- cp += sprintf(cp, "          read done at file offset %d\n",
-      io->r_offset);
- }
-
- if(sy->sy_flags & SY_ASYNC) {
- cp += sprintf(cp, "          async io completion strategy is %s\n",
-      aname->string);
- }
-
- cp += sprintf(cp, "          number of requests is %d, strides per request is %d\n",
-      io->r_nent, io->r_nstrides);
-
- cp += sprintf(cp, "          i/o byte count = %d\n",
-      io->r_nbytes);
+ cp += sprintf(cp, "          i/o byte count = %d\n",
+      io->r_nbytes);
 
  cp += sprintf(cp, "          memory alignment is %s\n",
       (io->r_uflags & F_WORD_ALIGNED) ? "aligned" : "unaligned");
 
-#ifdef CRAY
- if(io->r_oflags & O_RAW) {
- cp += sprintf(cp, "          RAW I/O: offset %% 4096 = %d length %% 4096 = %d\n",
-      io->r_offset % 4096, io->r_nbytes % 4096);
- fstat(fd, &sbuf);
- cp += sprintf(cp, "          optimal file xfer size: small: %d large: %d\n",
-      sbuf.st_blksize, sbuf.st_oblksize);
- cp += sprintf(cp, "          cblks %d cbits %#o\n",
-      sbuf.st_cblks, sbuf.st_cbits);
- }
-#endif
 #ifndef NO_XFS
  if(io->r_oflags & O_DIRECT) {
  struct dioattr finfo;
@@ -2307,136 +1536,6 @@ fmt_ioreq(struct io_req *ioreq, struct s
  return(errbuf);
 }
 
-/*
- * Issue listio requests
- */
-#ifdef CRAY
-struct status *
-sy_listio(req, sysc, fd, addr)
-struct io_req *req;
-struct syscall_info *sysc;
-int fd;
-char *addr;
-{
- int offset, nbytes, nstrides, nents, aio_strat;
- int aio_id, signo, o, i, lc;
- char     *a;
- struct listreq *lio_req, *l;
- struct aio_info *aiop;
- struct status *status;
-
- /*
- * Initialize common fields - assumes r_oflags, r_file, r_offset, and
- * r_nbytes are at the same offset in the read_req and reada_req
- * structures.
- */
- offset  = req->r_data.io.r_offset;
- nbytes  = req->r_data.io.r_nbytes;
- nstrides  = req->r_data.io.r_nstrides;
- nents     = req->r_data.io.r_nent;
- aio_strat = req->r_data.io.r_aio_strat;
-
- lc = (sysc->sy_flags & SY_ASYNC) ? LC_START : LC_WAIT;
-
- status = (struct status *)malloc(sizeof(struct status));
- if( status == NULL ){
- doio_fprintf(stderr, "malloc failed, %s/%d\n",
- __FILE__, __LINE__);
- return NULL;
- }
- status->aioid = (int *)malloc( (nents+1) * sizeof(int) );
- if( status->aioid == NULL ){
- doio_fprintf(stderr, "malloc failed, %s/%d\n",
- __FILE__, __LINE__);
- return NULL;
- }
-
- signo = (aio_strat == A_SIGNAL) ? SIGUSR1 : 0;
-
- lio_req = (struct listreq *)malloc(nents * sizeof(struct listreq));
- if( lio_req == NULL ){
- doio_fprintf(stderr, "malloc failed, %s/%d\n",
- __FILE__, __LINE__);
- return NULL;
- }
- for(l=lio_req,a=addr,o=offset,i=0;
-    i < nents;
-    l++, a+=nbytes, o+=nbytes, i++) {
-
- aio_id = aio_register(fd, aio_strat, signo);
- aiop = aio_slot(aio_id);
- status->aioid[i] = aio_id;
-
- l->li_opcode = (sysc->sy_flags & SY_WRITE) ? LO_WRITE : LO_READ;
- l->li_offset = o;
- l->li_fildes = fd;
- l->li_buf = a;
- l->li_nbyte = nbytes;
- l->li_status = &aiop->iosw;
- l->li_signo = signo;
- l->li_nstride = nstrides;
- l->li_filstride = 0;
- l->li_memstride = 0;
- l->li_drvr = 0;
- l->li_flags = LF_LSEEK;
- }
-
- status->aioid[nents] = -1; /* end sentinel */
-
- if( (status->rval = listio(lc, lio_req, nents)) == -1) {
- status->err = errno;
- }
-
- free(lio_req);
- return(status);
-}
-
-/*
- * Calculate the size of a request in bytes and min/max boundaries
- *
- * This assumes filestride & memstride = 0.
- */
-int
-listio_mem(struct io_req *req, int offset, int fmstride,
-   int *min, int *max)
-{
- int i, size;
-
- size = stride_bounds(offset, fmstride,
-     req->r_data.io.r_nstrides*req->r_data.io.r_nent,
-     req->r_data.io.r_nbytes, min, max);
- return(size);
-}
-
-char *
-fmt_listio(struct io_req *req, struct syscall_info *sy, int fd, char *addr)
-{
- static char *errbuf = NULL;
- char *cp;
- char *c, *opcode;
- int i;
-
- if(errbuf == NULL){
- errbuf = (char *)malloc(32768);
- if( errbuf == NULL ){
- doio_fprintf(stderr, "malloc failed, %s/%d\n",
- __FILE__, __LINE__);
- return NULL;
- }
- }
-
- c = (sy->sy_flags & SY_ASYNC) ? "lc_wait" : "lc_start";
-
- cp = errbuf;
- cp += sprintf(cp, "syscall:  listio(%s, (?), %d)\n",
-      c, req->r_data.io.r_nent);
-
- cp += sprintf(cp, "          data buffer at %#o\n", addr);
-
- return(errbuf);
-}
-#endif /* CRAY */
-
 struct status *
 sy_pread(req, sysc, fd, addr)
 struct io_req *req;
@@ -2510,7 +1609,6 @@ fmt_pread(struct io_req *req, struct sys
  return(errbuf);
 }
 
-#ifndef CRAY
 struct status *
 sy_readv(req, sysc, fd, addr)
 struct io_req *req;
@@ -2584,116 +1682,6 @@ fmt_readv(struct io_req *req, struct sys
       sy->sy_name, fd);
  return(errbuf);
 }
-#endif /* !CRAY */
-
-#ifdef sgi
-struct status *
-sy_aread(req, sysc, fd, addr)
-struct io_req *req;
-struct syscall_info *sysc;
-int fd;
-char *addr;
-{
- struct status *sy_arw();
- return sy_arw(req, sysc, fd, addr, 0);
-}
-
-struct status *
-sy_awrite(req, sysc, fd, addr)
-struct io_req *req;
-struct syscall_info *sysc;
-int fd;
-char *addr;
-{
- struct status *sy_arw();
- return sy_arw(req, sysc, fd, addr, 1);
-}
-
-/*
-  #define sy_aread(A, B, C, D) sy_arw(A, B, C, D, 0)
-  #define sy_awrite(A, B, C, D) sy_arw(A, B, C, D, 1)
- */
-
-struct status *
-sy_arw(req, sysc, fd, addr, rw)
-struct io_req *req;
-struct syscall_info *sysc;
-int fd;
-char *addr;
-int rw;
-{
- /* POSIX 1003.1b-1993 Async read */
- struct status *status;
- int         rc;
- int aio_id, aio_strat, signo;
- struct aio_info *aiop;
-
- status = (struct status *)malloc(sizeof(struct status));
- if( status == NULL ){
- doio_fprintf(stderr, "malloc failed, %s/%d\n",
- __FILE__, __LINE__);
- return NULL;
- }
- aio_strat = req->r_data.io.r_aio_strat;
- signo = (aio_strat == A_SIGNAL) ? SIGUSR1 : 0;
-
- aio_id = aio_register(fd, aio_strat, signo);
- aiop = aio_slot(aio_id);
-
- memset( (void *)&aiop->aiocb, 0, sizeof(aiocb_t));
-
- aiop->aiocb.aio_fildes = fd;
- aiop->aiocb.aio_nbytes = req->r_data.io.r_nbytes;
- aiop->aiocb.aio_offset = req->r_data.io.r_offset;
- aiop->aiocb.aio_buf = addr;
- aiop->aiocb.aio_reqprio = 0; /* must be 0 */
- aiop->aiocb.aio_lio_opcode = 0;
-
- if(aio_strat == A_SIGNAL) { /* siginfo(2) stuff */
- aiop->aiocb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
- aiop->aiocb.aio_sigevent.sigev_signo = signo;
- } else if(aio_strat == A_CALLBACK) {
- aiop->aiocb.aio_sigevent.sigev_signo = 0;
- aiop->aiocb.aio_sigevent.sigev_notify = SIGEV_CALLBACK;
- aiop->aiocb.aio_sigevent.sigev_func = cb_handler;
- aiop->aiocb.aio_sigevent.sigev_value.sival_int = aio_id;
- } else {
- aiop->aiocb.aio_sigevent.sigev_notify = SIGEV_NONE;
- aiop->aiocb.aio_sigevent.sigev_signo = 0;
- }
-
- if(rw)
- rc = aio_write(&aiop->aiocb);
- else
- rc = aio_read(&aiop->aiocb);
-
- status->aioid = (int *)malloc( 2 * sizeof(int) );
- if( status->aioid == NULL ){
- doio_fprintf(stderr, "malloc failed, %s/%d\n",
- __FILE__, __LINE__);
- return NULL;
- }
- status->aioid[0] = aio_id;
- status->aioid[1] = -1;
- status->rval = rc;
- status->err = errno;
- return(status);
-}
-
-char *
-fmt_aread(struct io_req *req, struct syscall_info *sy, int fd, char *addr)
-{
- static char errbuf[32768];
- char *cp;
-
- cp = errbuf;
- cp += sprintf(cp, "syscall:  %s(&aiop->aiocb)\n",
-      sy->sy_name);
- return(errbuf);
-}
-#endif /* sgi */
-
-#ifndef CRAY
 
 struct status *
 sy_mmread(req, sysc, fd, addr)
@@ -2809,72 +1797,10 @@ fmt_mmrw(struct io_req *req, struct sysc
       (unsigned long) memaddr, req->r_data.io.r_nbytes,
       (unsigned long) addr);
       
- return(errbuf);
-}
-#endif /* !CRAY */
-
-struct syscall_info syscalls[] = {
-#ifdef CRAY
- { "listio-read-sync", LREAD,
-  sy_listio, NULL, fmt_listio,
-  SY_IOSW
- },
- { "listio-read-strides-sync", LSREAD,
-  sy_listio, listio_mem, fmt_listio,
-  SY_IOSW
- },
- { "listio-read-reqs-sync", LEREAD,
-  sy_listio, listio_mem, fmt_listio,
-  SY_IOSW
- },
- { "listio-read-async", LREADA,
-  sy_listio, NULL, fmt_listio,
-  SY_IOSW | SY_ASYNC
- },
- { "listio-read-strides-async", LSREADA,
-  sy_listio, listio_mem, fmt_listio,
-  SY_IOSW | SY_ASYNC
- },
- { "listio-read-reqs-async", LEREADA,
-  sy_listio, listio_mem, fmt_listio,
-  SY_IOSW | SY_ASYNC
- },
- { "listio-write-sync", LWRITE,
-  sy_listio, listio_mem, fmt_listio,
-  SY_IOSW | SY_WRITE
- },
- { "listio-write-strides-sync", LSWRITE,
-  sy_listio, listio_mem, fmt_listio,
-  SY_IOSW | SY_WRITE
- },
- { "listio-write-reqs-sync", LEWRITE,
-  sy_listio, listio_mem, fmt_listio,
-  SY_IOSW | SY_WRITE
- },
- { "listio-write-async", LWRITEA,
-  sy_listio, listio_mem, fmt_listio,
-  SY_IOSW | SY_WRITE | SY_ASYNC
- },
- { "listio-write-strides-async", LSWRITEA,
-  sy_listio, listio_mem, fmt_listio,
-  SY_IOSW | SY_WRITE | SY_ASYNC
- },
- { "listio-write-reqs-async", LEWRITEA,
-  sy_listio, listio_mem, fmt_listio,
-  SY_IOSW | SY_WRITE | SY_ASYNC
- },
-#endif
+ return(errbuf);
+}
 
-#ifdef sgi
- { "aread", AREAD,
-  sy_aread, NULL, fmt_aread,
-  SY_IOSW | SY_ASYNC
- },
- { "awrite", AWRITE,
-  sy_awrite, NULL, fmt_aread,
-  SY_IOSW | SY_WRITE | SY_ASYNC
- },
-#endif
+struct syscall_info syscalls[] = {
  { "pread", PREAD,
   sy_pread, NULL, fmt_pread,
   0
@@ -2884,7 +1810,6 @@ struct syscall_info syscalls[] = {
   SY_WRITE
  },
 
-#ifndef CRAY
  { "readv", READV,
   sy_readv, NULL, fmt_readv,
   0
@@ -2901,7 +1826,6 @@ struct syscall_info syscalls[] = {
   sy_mmwrite, NULL, fmt_mmrw,
   SY_WRITE
  },
-#endif
 
  { NULL, 0,
   0, 0, 0,
@@ -2922,13 +1846,6 @@ do_rw(req)
  struct status *s;
  struct wlog_rec wrec;
  struct syscall_info *sy;
-#ifdef sgi
- struct aio_info *aiop;
-#endif
-#ifdef CRAY
- /* REFERENCED */
- struct iosw *iosw;
-#endif
 #ifndef NO_XFS
  struct fd_cache *fdc;
 #endif
@@ -2990,11 +1907,6 @@ do_rw(req)
  mem_needed = nbytes;
  }
 
-#ifdef CRAY
- if ((rval = alloc_mem(mem_needed + wtob(1) * 2 + MPP_BUMP * sizeof(UINT64_T))) < 0) {
- return rval;
- }
-#else
 #ifndef NO_XFS
  /* get memory alignment for using DIRECT I/O */
  fdc = alloc_fdcache(file, oflags);
@@ -3007,7 +1919,6 @@ do_rw(req)
  return rval;
  }
 #endif
-#endif /* CRAY */
 
  Pattern[0] = pattern;
 
@@ -3016,35 +1927,9 @@ do_rw(req)
  */
 
  if (oflags & O_SSD) {
-#ifdef CRAY
-#ifndef _CRAYMPP
- if (alloc_sds(nbytes) == -1)
- return -1;
-
- if( sy->sy_flags & SY_WRITE ) {
- /*pattern_fill(Memptr, mem_needed, Pattern, Pattern_Length, 0);*/
- (*Data_Fill)(Memptr, nbytes, Pattern, Pattern_Length, 0);
-
- if (sswrite((long)Memptr, Sdsptr, btoc(mem_needed)) == -1) {
- doio_fprintf(stderr, "sswrite(%d, %d, %d) failed:  %s (%d)\n",
-     (long)Memptr, Sdsptr,
-     btoc(mem_needed), SYSERR, errno);
- fflush(stderr);
- return -1;
- }
- }
-
- addr = (char *)Sdsptr;
-#else
- doio_fprintf(stderr, "Invalid O_SSD flag was generated for MPP system\n");
- fflush(stderr);
- return -1;
-#endif /* _CRAYMPP */
-#else /* CRAY */
  doio_fprintf(stderr, "Invalid O_SSD flag was generated for non-Cray system\n");
  fflush(stderr);
  return -1;
-#endif /* CRAY */
  } else {
  addr = Memptr;
 
@@ -3057,9 +1942,6 @@ do_rw(req)
  */
 
  if (! (req->r_data.io.r_uflags & F_WORD_ALIGNED)) {
-#ifdef _CRAYMPP
- addr += random_range(0, MPP_BUMP, 1, NULL) * sizeof(int);
-#endif
  addr += random_range(0, wtob(1) - 1, 1, NULL);
  }
 
@@ -3186,80 +2068,7 @@ do_rw(req)
  * structure.
  */
 
- if( sy->sy_flags & SY_IOSW ) {
-#ifdef CRAY
- for( i=0; i < nents; i++ ) {
- if(s->aioid == NULL)
- break; /* >>> error condition? */
- aiop = aio_slot(s->aioid[i]);
- iosw = &aiop->iosw;
- if(iosw->sw_error != 0) {
- doio_fprintf(stderr,
-     "%s() iosw error set: %s\n%s\n%s\n",
-     sy->sy_name,
-     strerror(iosw->sw_error),
-     fmt_ioreq(req, sy, fd),
-     (*sy->sy_format)(req, sy, fd, addr));
- doio_upanic(U_IOSW);
- rval = -1;
- } else if(iosw->sw_count != nbytes*nstrides) {
- doio_fprintf(stderr,
-     "Bad iosw from %s() #%d\nExpected (%d,%d,%d), got (%d,%d,%d)\n%s\n%s\n",
-     sy->sy_name, i,
-     1, 0, nbytes*nstrides,
-     iosw->sw_flag,
-     iosw->sw_error,
-     iosw->sw_count,
-     fmt_ioreq(req, sy, fd),
-     (*sy->sy_format)(req, sy, fd, addr));
- doio_upanic(U_IOSW);
- rval = -1;
- }
-
- aio_unregister(s->aioid[i]);
- }
-#endif /* CRAY */
-#ifdef sgi
- for( i=0; s->aioid[i] != -1; i++ ) {
- if(s->aioid == NULL) {
- doio_fprintf(stderr,
-     "aioid == NULL!\n");
- break;
- }
- aiop = aio_slot(s->aioid[i]);
-
- /*
- * make sure the io completed without error
- */
- if (aiop->aio_errno != 0) {
- doio_fprintf(stderr,
-     "%s() aio error set: %s (%d)\n%s\n%s\n",
-     sy->sy_name,
-     strerror(aiop->aio_errno),
-     aiop->aio_errno,
-     fmt_ioreq(req, sy, fd),
-     (*sy->sy_format)(req, sy, fd, addr));
- doio_upanic(U_IOSW);
- rval = -1;
- } else if (aiop->aio_ret != nbytes) {
- doio_fprintf(stderr,
-     "Bad aio return from %s() #%d\nExpected (%d,%d), got (%d,%d)\n%s\n%s\n",
-     sy->sy_name, i,
-     0, nbytes,
-     aiop->aio_errno,
-     aiop->aio_ret,
-     fmt_ioreq(req, sy, fd),
-     (*sy->sy_format)(req, sy, fd, addr));
- aio_unregister(s->aioid[i]);
- doio_upanic(U_IOSW);
- return -1;
- } else {
- aio_unregister(s->aioid[i]);
- rval = 0;
- }
- }
-#endif /* sgi */
- } else {
+ if( !(sy->sy_flags & SY_IOSW) ) {
 
  if(s->rval != mem_needed) {
  doio_fprintf(stderr,
@@ -3428,7 +2237,6 @@ do_xfsctl(req)
 /*
  *  fsync(2) and fdatasync(2)
  */
-#ifndef CRAY
 int
 do_sync(req)
  struct io_req *req;
@@ -3465,8 +2273,6 @@ do_sync(req)
  }
  return (rval == -1) ? -1 : 0;
 }
-#endif
-
 
 int
 doio_pat_fill(char *addr, int mem_needed, char *Pattern, int Pattern_Length,
@@ -3583,11 +2389,6 @@ int fsa;
  flags = Validation_Flags | O_RDONLY;
  } else {
  flags = O_RDONLY;
- if (fsa) {
-#ifdef CRAY
- flags |= O_PARALLEL | O_RAW | O_WELLFORMED;
-#endif
- }
  }
 
  if ((fd = alloc_fd(file, flags)) == -1) {
@@ -3690,7 +2491,7 @@ doio_fprintf(FILE *stream, char *format,
  * Simple function for allocating core memory.  Uses Memsize and Memptr to
  * keep track of the current amount allocated.
  */
-#ifndef CRAY
+
 int
 alloc_mem(nbytes)
 int nbytes;
@@ -3703,9 +2504,6 @@ int nbytes;
  char filename[255];
 #ifdef linux
  struct shmid_ds shm_ds;
-#endif
-
-#ifdef linux
  bzero( &shm_ds, sizeof(struct shmid_ds) );
 #endif
 
@@ -3718,36 +2516,17 @@ int nbytes;
 
  switch(Memalloc[me].memtype) {
  case MEM_DATA:
-#ifdef sgi
- if(Memalloc[me].flags & MEMF_MPIN)
- munpin(Memalloc[me].space,
-       Memalloc[me].size);
-#endif
  free(Memalloc[me].space);
  Memalloc[me].space = NULL;
  Memptr = NULL;
  Memsize = 0;
  break;
  case MEM_SHMEM:
-#ifdef sgi
- if(Memalloc[me].flags & MEMF_MPIN)
- munpin(Memalloc[me].space,
-       Memalloc[me].size);
-#endif
  shmdt(Memalloc[me].space);
  Memalloc[me].space = NULL;
-#ifdef sgi
- shmctl(Memalloc[me].fd, IPC_RMID);
-#else
  shmctl(Memalloc[me].fd, IPC_RMID, &shm_ds);
-#endif
  break;
  case MEM_MMAP:
-#ifdef sgi
- if(Memalloc[me].flags & MEMF_MPIN)
- munpin(Memalloc[me].space,
-       Memalloc[me].size);
-#endif
  munmap(Memalloc[me].space,
        Memalloc[me].size);
  close(Memalloc[me].fd);
@@ -3778,10 +2557,6 @@ int nbytes;
  case MEM_DATA:
  if( nbytes > M->size ) {
  if( M->space != NULL ){
-#ifdef sgi
- if( M->flags & MEMF_MPIN )
- munpin( M->space, M->size );
-#endif
  free(M->space);
  }
  M->space = NULL;
@@ -3794,14 +2569,6 @@ int nbytes;
      nbytes, SYSERR, errno);
  return -1;
  }
-#ifdef sgi
- if(M->flags & MEMF_MPIN) {
- if( mpin(cp, nbytes) == -1 ) {
- doio_fprintf(stderr, "mpin(0x%lx, %d) failed:  %s (%d)\n",
-     cp, nbytes, SYSERR, errno);
- }
- }
-#endif
  M->space = (void *)cp;
  M->size = nbytes;
  }
@@ -3810,10 +2577,6 @@ int nbytes;
  case MEM_MMAP:
  if( nbytes > M->size ) {
  if( M->space != NULL ) {
-#ifdef sgi
- if( M->flags & MEMF_MPIN )
- munpin(M->space, M->size);
-#endif
  munmap(M->space, M->size);
  close(M->fd);
  if( M->flags & MEMF_FILE )
@@ -3846,14 +2609,6 @@ int nbytes;
  /* bias flags on MEMF_PRIVATE etc */
  if(M->flags & MEMF_PRIVATE)
  flags |= MAP_PRIVATE;
-#ifdef sgi
- if(M->flags & MEMF_LOCAL)
- flags |= MAP_LOCAL;
- if(M->flags & MEMF_AUTORESRV)
- flags |= MAP_AUTORESRV;
- if(M->flags & MEMF_AUTOGROW)
- flags |= MAP_AUTOGROW;
-#endif
  if(M->flags & MEMF_SHARED)
  flags |= MAP_SHARED;
 
@@ -3870,11 +2625,6 @@ int nbytes;
      M->name);
  doio_fprintf(stderr, "\t%s%s%s%s%s",
      (flags & MAP_PRIVATE) ? "private " : "",
-#ifdef sgi
-     (flags & MAP_LOCAL) ? "local " : "",
-     (flags & MAP_AUTORESRV) ? "autoresrv " : "",
-     (flags & MAP_AUTOGROW) ? "autogrow " : "",
-#endif
      (flags & MAP_SHARED) ? "shared" : "");
  return(-1);
  }
@@ -3884,16 +2634,7 @@ int nbytes;
  case MEM_SHMEM:
  if( nbytes > M->size ) {
  if( M->space != NULL ) {
-#ifdef sgi
- if( M->flags & MEMF_MPIN )
- munpin(M->space, M->size);
-#endif
- shmdt( M->space );
-#ifdef sgi
- shmctl( M->fd, IPC_RMID );
-#else
  shmctl( M->fd, IPC_RMID, &shm_ds );
-#endif
  }
  M->space = NULL;
  M->size = 0;
@@ -3929,14 +2670,6 @@ int nbytes;
      shmid, SYSERR, errno);
  return(-1);
  }
-#ifdef sgi
- if(M->flags & MEMF_MPIN) {
- if( mpin(M->space, M->size) == -1 ) {
- doio_fprintf(stderr, "mpin(0x%lx, %d) failed:  %s (%d)\n",
-     M->space, M->size, SYSERR, errno);
-    }
- }
-#endif
  }
  break;
 
@@ -3952,123 +2685,6 @@ int nbytes;
  mturn++;
  return 0;
 }
-#endif /* !CRAY */
-
-#ifdef CRAY
-int
-alloc_mem(nbytes)
-int nbytes;
-{
- char    *cp;
- int ip;
- static char *malloc_space;
-
- /*
- * The "unicos" version of this did some stuff with sbrk;
- * this caused problems with async I/O on irix, and now appears
- * to be causing problems with FSA I/O on unicos/mk.
- */
-#ifdef NOTDEF
- if (nbytes > Memsize) {
- if ((cp = (char *)sbrk(nbytes - Memsize)) == (char *)-1) {
- doio_fprintf(stderr, "sbrk(%d) failed:  %s (%d)\n",
-     nbytes - Memsize, SYSERR, errno);
- return -1;
- }
-
- if (Memsize == 0)
- Memptr = cp;
- Memsize += nbytes - Memsize;
- }
-#else
-
- /* nbytes = -1 means "free all allocated memory" */
- if( nbytes == -1 ) {
- free( malloc_space );
- Memptr = NULL;
- Memsize = 0;
- return 0;
- }
-
- if( nbytes > Memsize ) {
-    if( Memsize != 0 )
- free( malloc_space );
-
-    if( (cp = malloc_space = malloc( nbytes )) == NULL ) {
- doio_fprintf(stderr, "malloc(%d) failed:  %s (%d)\n",
-     nbytes, SYSERR, errno);
- return -1;
-    }
-
-#ifdef _CRAYT3E
-    /* T3E requires memory to be aligned on 0x40 word boundaries */
-    ip = (int)cp;
-    if( ip & 0x3F != 0 ) {
- doio_fprintf(stderr, "malloc(%d) = 0x%x(0x%x) not aligned by 0x%x\n",
-     nbytes, cp, ip, ip & 0x3f);
-
- free(cp);
- if( (cp = malloc_space = malloc( nbytes + 0x40 )) == NULL ) {
-    doio_fprintf(stderr, "malloc(%d) failed:  %s (%d)\n",
- nbytes, SYSERR, errno);
-    return -1;
- }
- ip = (int)cp;
- cp += (0x40 - (ip & 0x3F));
-    }
-#endif /* _CRAYT3E */
-    Memptr = cp;
-    Memsize = nbytes;
- }
-#endif /* NOTDEF */
- return 0;
-}
-#endif /* CRAY */
-
-/*
- * Simple function for allocating sds space.  Uses Sdssize and Sdsptr to
- * keep track of location and size of currently allocated chunk.
- */
-
-#ifdef _CRAY1
-
-int
-alloc_sds(nbytes)
-int nbytes;
-{
- int nblks;
-
- if (nbytes > Sdssize) {
- if ((nblks = ssbreak(btoc(nbytes - Sdssize))) == -1) {
- doio_fprintf(stderr, "ssbreak(%d) failed:  %s (%d)\n",
-     btoc(nbytes - Sdssize), SYSERR, errno);
- return -1;
- }
-
- Sdssize = ctob(nblks);
- Sdsptr = 0;
- }
-
- return 0;
-}
-
-#else
-
-#ifdef CRAY
-
-int
-alloc_sds(nbytes)
-int nbytes;
-{
- doio_fprintf(stderr,
-     "Internal Error - alloc_sds() called on a CRAY2 system\n");
- alloc_mem(-1);
- exit(E_INTERNAL);
-}
-
-#endif
-
-#endif /* _CRAY1 */
 
 /*
  * Function to maintain a file descriptor cache, so that doio does not have
@@ -4119,11 +2735,9 @@ int oflags;
  if (cp->c_fd != -1) {
  close(cp->c_fd);
  }
-#ifndef CRAY
  if (cp->c_memaddr != NULL) {
  munmap(cp->c_memaddr, cp->c_memlen);
  }
-#endif
  }
 
  free(cache);
@@ -4146,11 +2760,7 @@ int oflags;
  if (cp->c_fd != -1 &&
     cp->c_oflags == oflags &&
     strcmp(cp->c_file, file) == 0) {
-#ifdef CRAY
- cp->c_rtc = _rtc();
-#else
  cp->c_rtc = Reqno;
-#endif
  return cp;
  }
 
@@ -4234,11 +2844,7 @@ int oflags;
  free_slot->c_fd = fd;
  free_slot->c_oflags = oflags;
  strcpy(free_slot->c_file, file);
-#ifdef CRAY
- free_slot->c_rtc = _rtc();
-#else
  free_slot->c_rtc = Reqno;
-#endif
 
 #ifndef NO_XFS
  if (oflags & O_DIRECT) {
@@ -4257,10 +2863,8 @@ int oflags;
  free_slot->c_miniosz = finfo.d_miniosz;
  free_slot->c_maxiosz = finfo.d_maxiosz;
 #endif
-#ifndef CRAY
  free_slot->c_memaddr = NULL;
  free_slot->c_memlen = 0;
-#endif
 
  return free_slot;
 }
@@ -4272,104 +2876,6 @@ int oflags;
  *
  */
 
-#ifdef sgi
-/*
- * "caller-id" for signals
- */
-void
-signal_info(int sig, siginfo_t *info, void *v)
-{
- int haveit = 0;
-
- if(info != NULL) {
- switch(info->si_code) {
- case SI_USER:
- doio_fprintf(stderr,
-     "signal_info: si_signo %d si_errno %d si_code SI_USER pid %d uid %d\n",
-     info->si_signo, info->si_errno,
-     info->si_pid, info->si_uid);
- haveit = 1;
- break;
-
- case SI_QUEUE:
- doio_fprintf(stderr, "signal_info  si_signo %d si_code = SI_QUEUE\n",
-     info->si_signo);
- haveit = 1;
- break;
- }
-
- if( ! haveit ){
- if( (info->si_signo == SIGSEGV) ||
-   (info->si_signo == SIGBUS) ){
- doio_fprintf(stderr, "signal_info  si_signo %d si_errno %d si_code = %d  si_addr=%p  active_mmap_rw=%d havesigint=%d\n",
-     info->si_signo, info->si_errno,
-     info->si_code, info->si_addr,
-     active_mmap_rw,
-     havesigint);
- haveit = 1;
-   }
- }
-
- if( !haveit ){
- doio_fprintf(stderr, "signal_info: si_signo %d si_errno %d unknown code %d\n",
-     info->si_signo, info->si_errno,
-     info->si_code);
- }
- } else {
- doio_fprintf(stderr, "signal_info: sig %d\n", sig);
- }
-}
-#endif
-
-#ifdef sgi
-void
-cleanup_handler(int sig, siginfo_t *info, void *v)
-{
- havesigint=1; /* in case there's a followup signal */
- /*signal_info(sig, info, v);*/ /* be quiet on "normal" kill */
- alloc_mem(-1);
- exit(0);
-}
-
-
-void
-die_handler(int sig, siginfo_t *info, void *v)
-{
- doio_fprintf(stderr, "terminating on signal %d\n", sig);
- signal_info(sig, info, v);
- alloc_mem(-1);
- exit(1);
-}
-
-void
-sigbus_handler(int sig, siginfo_t *info, void *v)
-{
- /* While we are doing a memcpy to/from an mmapped region we can
-   get a SIGBUS for a variety of reasons--and not all of them
-   should be considered failures.
-
-   Under normal conditions if we get a SIGINT it means we've been
-   told to shutdown.  However, if we're currently doing the above-
-   mentioned memcopy then the kernel will follow that SIGINT with
-   a SIGBUS.  We can guess that we're in this situation by seeing
-   that the si_errno field in the siginfo structure has EINTR as
-   an errno.  (We might make the guess stronger by looking at the
-   si_addr field to see that it's not faulting off the end of the
-   mmapped region, but it seems that in such a case havesigint
-   would not have been set so maybe that doesn't make the guess
-   stronger.)
- */
-
-
- if( active_mmap_rw && havesigint && (info->si_errno == EINTR) ){
- cleanup_handler( sig, info, v );
- }
- else{
- die_handler( sig, info, v );
- }
-}
-#else
-
 void
 cleanup_handler()
 {
@@ -4387,7 +2893,6 @@ int sig;
  exit(1);
 }
 
-#ifndef CRAY
 void
 sigbus_handler(sig)
 int sig;
@@ -4402,9 +2907,6 @@ int sig;
  else
  die_handler(sig);
 }
-#endif /* !CRAY */
-#endif /* sgi */
-
 
 void
 noop_handler(sig)
@@ -4483,34 +2985,6 @@ dump_aio()
  fprintf(stderr, "%d active async i/os\n", count);
 }
 
-
-#ifdef sgi
-/*
- * Signal handler called as a callback, not as a signal.
- * 'val' is the value from sigev_value and is assumed to be the
- * Aio_Info[] index.
- */
-void
-cb_handler(val)
-sigval_t val;
-{
- struct aio_info *aiop;
-
-/*printf("cb_handler requesting slot %d\n", val.sival_int);*/
- aiop = aio_slot( val.sival_int );
-/*printf("cb_handler, aiop=%p\n", aiop);*/
-
-/*printf("%d in cb_handler\n", getpid() );*/
- if (aiop->strategy == A_CALLBACK) {
- aiop->signalled++;
-
- if (aio_done(aiop)) {
- aiop->done++;
- }
- }
-}
-#endif
-
 struct aio_info *
 aio_slot(aio_id)
 int aio_id;
@@ -4563,9 +3037,6 @@ int sig;
  aiop->fd = fd;
  aiop->strategy = strategy;
  aiop->done = 0;
-#ifdef CRAY
- bzero((char *)&aiop->iosw, sizeof(aiop->iosw));
-#endif
 
  if (strategy == A_SIGNAL) {
  aiop->sig = sig;
@@ -4610,111 +3081,6 @@ int aio_id;
 #endif
  sigset_t sigset;
  struct aio_info *aiop;
-#ifdef CRAY
- struct iosw *ioswlist[1];
-#endif
-#ifdef sgi
- const aiocb_t *aioary[1];
-#endif
- int r, cnt;
-
-
- aiop = aio_slot(aio_id);
-/*printf("%d aiop B =%p\n", getpid(), aiop);*/
-
- switch (aiop->strategy) {
- case A_POLL:
- while (! aio_done(aiop))
- ;
- break;
-
- case A_SIGNAL:
- sigemptyset(&sigset);
- sighold( aiop->sig );
-
- while ( !aiop->signalled || !aiop->done ) {
- sigsuspend(&sigset);
- sighold( aiop->sig );
- }
- break;
-
-#ifdef CRAY
- case A_RECALL:
- ioswlist[0] = &aiop->iosw;
- if (recall(aiop->fd, 1, ioswlist) < 0) {
- doio_fprintf(stderr, "recall() failed:  %s (%d)\n",
-     SYSERR, errno);
- exit(E_SETUP);
- }
- break;
-
-#ifdef RECALL_SIZEOF
-
- case A_RECALLA:
- RECALL_INIT(mask);
- RECALL_SET(mask, aiop->fd);
- if (recalla(mask) < 0) {
- doio_fprintf(stderr, "recalla() failed:  %s (%d)\n",
-     SYSERR, errno);
- exit(E_SETUP);
- }
-
- RECALL_CLR(mask, aiop->fd);
- break;
-#endif
-
- case A_RECALLS:
- ioswlist[0] = &aiop->iosw;
- if (recalls(1, ioswlist) < 0) {
- doio_fprintf(stderr, "recalls failed:  %s (%d)\n",
- SYSERR, errno);
- exit(E_SETUP);
- }
- break;
-#endif /* CRAY */
-
-#ifdef sgi
- case A_CALLBACK:
- aioary[0] = &aiop->aiocb;
- cnt=0;
- do {
- r = aio_suspend(aioary, 1, NULL);
- if( r == -1 ){
- doio_fprintf(stderr, "aio_suspend failed: %s (%d)\n",
-     SYSERR, errno );
- exit(E_SETUP);
- }
- cnt++;
- } while(aiop->done == 0);
-
-#if 0
- /*
- * after having this set for a while, I've decided that
- * it's too noisy
- */
- if(cnt > 1)
- doio_fprintf(stderr, "aio_wait: callback wait took %d tries\n", cnt);
-#endif
-
- /*
- * Note: cb_handler already calls aio_done
- */
- break;
-
-
- case A_SUSPEND:
- aioary[0] = &aiop->aiocb;
- r = aio_suspend(aioary, 1, NULL);
- if( r == -1 ){
- doio_fprintf(stderr, "aio_suspend failed: %s (%d)\n",
-     SYSERR, errno );
- exit(E_SETUP);
- }
-
- aio_done(aiop);
- break;
-#endif
- }
 
 /*printf("aio_wait: errno %d return %d\n", aiop->aio_errno, aiop->aio_ret);*/
 
@@ -4747,29 +3113,7 @@ time_t t;
 int
 aio_done(struct aio_info *ainfo)
 {
-#ifdef CRAY
- return ainfo->iosw.sw_flag;
-#endif
-
-#ifdef sgi
- if( (ainfo->aio_errno = aio_error(&ainfo->aiocb)) == -1 ){
- doio_fprintf(stderr, "aio_done: aio_error failed: %s (%d)\n",
-     SYSERR, errno );
- exit(E_SETUP);
- }
- /*printf("%d aio_done aio_errno=%d\n", getpid(), ainfo->aio_errno);*/
- if( ainfo->aio_errno != EINPROGRESS ){
- if( (ainfo->aio_ret = aio_return(&ainfo->aiocb)) == -1 ){
- doio_fprintf(stderr, "aio_done: aio_return failed: %s (%d)\n",
-     SYSERR, errno );
- exit(E_SETUP);
- }
- }
-
- return (ainfo->aio_errno != EINPROGRESS);
-#else
         return -1;   /* invalid */
-#endif
 }
 
 /*
@@ -4789,18 +3133,6 @@ int mask;
  if (U_opt == 0 || (mask & Upanic_Conditions) == 0) {
  return;
  }
-
-#ifdef CRAY
- if (upanic(PA_SET) < 0) {
- doio_fprintf(stderr, "WARNING - Could not set the panic flag - upanic(PA_SET) failed:  %s (%d)\n",
-     SYSERR, errno);
- }
-
- upanic(PA_PANIC);
-#endif
-#ifdef sgi
- syssgi(1005); /* syssgi test panic - DEBUG kernels only */
-#endif
  doio_fprintf(stderr, "WARNING - upanic() failed\n");
 }
 
@@ -4905,16 +3237,11 @@ char *opts;
  break;
 
  case 'M': /* memory allocation types */
-#ifndef CRAY
  nmemargs = string_to_tokens(optarg, memargs, 32, ",");
  for(ma=0; ma < nmemargs; ma++) {
  parse_memalloc(memargs[ma]);
  }
  /*dump_memalloc();*/
-#else
- fprintf(stderr, "%s%s: Error: -M isn't supported on this platform\n", Prog, TagName);
- exit(1);
-#endif
  M_opt++;
  break;
 
@@ -4964,14 +3291,6 @@ char *opts;
  Validation_Flags = O_SYNC;
  } else if (strcasecmp(optarg, "buffered") == 0) {
  Validation_Flags = 0;
-#ifdef CRAY
- } else if (strcasecmp(optarg, "parallel") == 0) {
- Validation_Flags = O_PARALLEL;
- } else if (strcasecmp(optarg, "ldraw") == 0) {
- Validation_Flags = O_LDRAW;
- } else if (strcasecmp(optarg, "raw") == 0) {
- Validation_Flags = O_RAW;
-#endif
  } else if (strcasecmp(optarg, "direct") == 0) {
  Validation_Flags = O_DIRECT;
  } else {
@@ -5097,7 +3416,6 @@ char *opts;
  * NBLKS
  * nblks worth of directories - 1 int pids
  */
-#ifndef CRAY
 void
 parse_memalloc(char *arg)
 {
@@ -5223,8 +3541,6 @@ dump_memalloc()
  }
 }
 
-#endif /* !CRAY */
-
 /*
  * -d <op>:<time> - doio inter-operation delay
  * currently this permits ONE type of delay between operations.
@@ -5312,9 +3628,6 @@ FILE *stream;
  fprintf(stream, "\t                     Operations are:\n");
  fprintf(stream, "\t                         select:time (1 second=1000000)\n");
  fprintf(stream, "\t                         sleep:time (1 second=1)\n");
-#ifdef sgi
- fprintf(stream, "\t                         sginap:time (1 second=CLK_TCK=100)\n");
-#endif
  fprintf(stream, "\t                         alarm:time (1 second=1)\n");
  fprintf(stream, "\t-e                   Re-exec children before entering the main\n");
  fprintf(stream, "\t                     loop.  This is useful for spreading\n");
@@ -5323,35 +3636,19 @@ FILE *stream;
  fprintf(stream, "\t-v                   Verify writes - this is done by doing a buffered\n");
  fprintf(stream, "\t                     read() of the data if file io was done, or\n");
  fprintf(stream, "\t                     an ssread()of the data if sds io was done\n");
-#ifndef CRAY
  fprintf(stream, "\t-M                   Data buffer allocation method\n");
  fprintf(stream, "\t                     alloc-type[,type]\n");
-#ifdef sgi
- fprintf(stream, "\t    data:flags\n");
- fprintf(stream, "\t        p - mpin buffer\n");
- fprintf(stream, "\t    shmem:shmid:size:flags\n");
- fprintf(stream, "\t        p - mpin buffer\n");
-#else
  fprintf(stream, "\t    data\n");
  fprintf(stream, "\t    shmem:shmid:size\n");
-#endif /* sgi */
  fprintf(stream, "\t    mmap:flags:filename\n");
  fprintf(stream, "\t        p - private\n");
-#ifdef sgi
- fprintf(stream, "\t        s - shared\n");
- fprintf(stream, "\t        l - local\n");
- fprintf(stream, "\t        a - autoresrv\n");
- fprintf(stream, "\t        G - autogrow\n");
-#else
  fprintf(stream, "\t        s - shared (shared file must exist\n"),
  fprintf(stream, "\t            and have needed length)\n");
-#endif
  fprintf(stream, "\t        f - fixed address (not used)\n");
  fprintf(stream, "\t        a - specify address (not used)\n");
  fprintf(stream, "\t        U - Unlink file when done\n");
  fprintf(stream, "\t        The default flag is private\n");
  fprintf(stream, "\n");
-#endif /* !CRAY */
  fprintf(stream, "\t-m message_interval  Generate a message every 'message_interval'\n");
  fprintf(stream, "\t                     requests.  An interval of 0 suppresses\n");
  fprintf(stream, "\t                     messages.  The default is 0.\n");
@@ -5368,11 +3665,6 @@ FILE *stream;
  fprintf(stream, "\t                     'buffered' - validate using bufferd read\n");
  fprintf(stream, "\t                     'sync'     - validate using O_SYNC read\n");
  fprintf(stream, "\t                     'direct    - validate using O_DIRECT read'\n");
-#ifdef CRAY
- fprintf(stream, "\t                     'ldraw'    - validate using O_LDRAW read\n");
- fprintf(stream, "\t                     'parallel' - validate using O_PARALLEL read\n");
- fprintf(stream, "\t                     'raw'      - validate using O_RAW read\n");
-#endif
  fprintf(stream, "\t                     By default, 'parallel'\n");
  fprintf(stream, "\t                     is used if the write was done with O_PARALLEL\n");
  fprintf(stream, "\t                     or 'buffered' for all other writes.\n");
Index: b/ltp/doio.h
===================================================================
--- a/ltp/doio.h
+++ b/ltp/doio.h
@@ -56,13 +56,7 @@
 #define UNRESVSP 123 /* xfsctl(XFS_IOC_UNRESVSP) */
 #define FSYNC2 125 /* fsync(2) */
 #define FDATASYNC 126 /* fdatasync(2) */
-
-#ifdef CRAY
-/* used: <<doio>> 1.? <<DOIO>> 1.5 <-DOIO-> 1.7*/
-#define DOIO_MAGIC  '<[DOIO]>'
-#else
 #define DOIO_MAGIC  07116601
-#endif
 
 /*
  * Define various user flags (r_uflag field) that io requests can have
Index: b/ltp/growfiles.c
===================================================================
--- a/ltp/growfiles.c
+++ b/ltp/growfiles.c
@@ -168,11 +168,7 @@ int mult_size=1; /* when random iosz, i
 /* the *_lseek variables are only used when radon lseek option (-R) is used */
 int min_lseek=0; /* also set in option parsing */
 int max_lseek=-1; /* -1 means size of file */
-#ifdef CRAY
-int Pattern=PATTERN_OFFSET; /* This pattern is 64 bit word based */
-#else
 int Pattern=PATTERN_ASCII;
-#endif
 int Seed=-1; /* random number seed, < 0 == uninitialized  */
 int Nseeds=0; /* Number of seed specified by the user */
 int *Seeds; /* malloc'ed arrary of ints holding user spec seeds */
@@ -229,32 +225,6 @@ struct fileinfo_t {
  * to use.
  */
 int Open_flags[] = {
-#ifdef CRAY
- O_RDWR|O_CREAT,
- O_RDWR|O_CREAT|O_RAW,
- O_RDWR|O_CREAT|O_BIG,
- O_RDWR|O_CREAT|O_APPEND,
- O_RDWR|O_CREAT|O_NDELAY,
- O_RDWR|O_CREAT|O_PLACE,
- O_RDWR|O_CREAT|O_SYNC,
- O_RDWR|O_CREAT|O_RAW|O_SYNC,
- O_RDWR|O_CREAT|O_NDELAY|O_SYNC,
- O_RDWR|O_CREAT|O_NDELAY|O_SYNC|O_BIG,
- O_RDWR|O_CREAT|O_RAW,
- O_RDWR|O_CREAT|O_RAW|O_APPEND,
- O_RDWR|O_CREAT|O_RAW|O_BIG,
- O_RDWR|O_CREAT|O_RAW|O_APPEND|O_BIG,
-/***
- * O_WELLFORMED makes -o random require well formed i/o
- ***/
-#if ALLOW_O_WELLFORMED
-#if O_PARALLEL
- O_RDWR|O_CREAT|O_PARALLEL|O_WELLFORMED|O_RAW,
- O_RDWR|O_CREAT|O_PARALLEL|O_WELLFORMED|O_RAW|O_TRUNC,
-#endif /* O_PARALLEL */
-#endif
-
-#else /* CRAY */
  O_RDWR|O_CREAT,
  O_RDWR|O_CREAT|O_APPEND,
  O_RDWR|O_CREAT|O_NDELAY,
@@ -262,7 +232,6 @@ int Open_flags[] = {
  O_RDWR|O_CREAT|O_SYNC|O_NDELAY,
  O_RDWR|O_CREAT|O_APPEND|O_NDELAY,
 
-#endif /* CRAY */
 };
 
 #define REXEC_INIT 0 /* don't do re-exec of childern */
@@ -270,11 +239,7 @@ int Open_flags[] = {
 #define REXEC_DONE 2 /* We've already been re-exec'ed */
 
 #ifndef BSIZE
-#ifdef CRAY
-#define BSIZE 1024
-#else
 #define BSIZE 512
-#endif  /* CRAY */
 #endif  /* BSIZE */
 
 #define USECS_PER_SEC 1000000  /* microseconds per second */
@@ -428,9 +393,6 @@ extern int Forker_npids; /* num of forke
 
  case 'd':
  auto_dir=optarg;
-#ifdef CRAY
- unsetenv("TMPDIR"); /* force the use of auto_dir */
-#endif
  if ( stat(auto_dir, &statbuf) == -1 ) {
     if ( mkdir(auto_dir, 0777) == -1 ) {
  if ( errno != EEXIST ) {
@@ -612,18 +574,9 @@ extern int Forker_npids; /* num of forke
  break;
 
  case 'P':
-#ifdef CRAY
- if (strcmp(optarg, "PANIC") != 0 ) {
- fprintf(stderr, "%s%s: --P arg must be PANIC\n", Progname, TagName);
- exit(1);
- }
- Upanic_on_error++;
- printf("%s: Will call upanic after writes\n");
-#else
  printf("%s%s: --P is illegal option on non-cray system\n",
  Progname, TagName);
  exit(1);
-#endif
  break;
 
  case 'q': /* file content or pattern */
@@ -904,11 +857,6 @@ no whole file checking will be performed
     background(Progname); /* give user their prompt back */
  }
 
-#if CRAY
- if ( Sync_with_others )
-   setpgrp();
-#endif
-
  if ( Debug > 3 ) {
 #if NEWIO
     lio_set_debug(Debug-3);
@@ -1227,18 +1175,9 @@ no whole file checking will be performed
  /*
  * If delaying between iterations, get amount time to
  * delaysecs in clocks or usecs.
- * If on the CRAY, delaytime is in clocks since
- * _rtc() will be used, which does not have the overhead
-         * of gettimeofday(2).
  */
  if ( delaysecs ) {
-#if CRAY
-   int hz;
-   hz=sysconf(_SC_CLK_TCK);
-   delaytime=(int)((float)hz * delaysecs);
-#else
    delaytime=(int)((float)USECS_PER_SEC * delaysecs);
-#endif
         }
 
  /*
@@ -1398,13 +1337,6 @@ no whole file checking will be performed
         if ( delaytime ) {
 
     int ct, end;
-#ifdef CRAY
-    ct=_rtc();
-    end=ct+delaytime;
-            while ( ct < end ) {
-        ct = _rtc();
-    }
-#else
     struct timeval curtime;
     gettimeofday(&curtime, NULL);
     ct=curtime.tv_sec*USECS_PER_SEC + curtime.tv_usec;
@@ -1414,7 +1346,6 @@ no whole file checking will be performed
         gettimeofday(&curtime, NULL);
         ct=curtime.tv_sec*USECS_PER_SEC + curtime.tv_usec;
     }
-#endif
         }
     }
 #ifndef NO_XFS
@@ -1472,10 +1403,6 @@ set_sig()
                 case SIGKILL:
                 case SIGSTOP:
                 case SIGCONT:
-#ifdef CRAY
-                case SIGINFO:
-                case SIGRECOVERY:
-#endif /* CRAY */
 #ifdef SIGCKPT
         case SIGCKPT:
 #endif /* SIGCKPT */
@@ -1486,12 +1413,7 @@ set_sig()
                     break;
 
                 default:
-#ifdef sgi
-    sigset( sig, sig_handler );
-#else
-/* linux and cray */
                     signal(sig, sig_handler);
-#endif
                 break;
             }
         } /* endfor */
@@ -1512,9 +1434,7 @@ int sig;
     if ( sig == SIGUSR2 ) {
  fprintf(stdout, "%s%s: %d %s/%d: received SIGUSR2 (%d) - stopping.\n",
     Progname, TagName, Pid, __FILE__, __LINE__, sig);
-#ifndef sgi
         signal(sig, sig_handler); /* allow us to get this signal more than once */
-#endif
         
     } else if( sig == SIGINT ){
  /* The user has told us to cleanup, don't pretend it's an error. */
@@ -1552,13 +1472,6 @@ notify_others()
 
     if ( Sync_with_others && send_signals == 0 ) {
 
-#if CRAY
- send_signals=1; /* only send signals once */
- if ( Debug > 1 )
-    printf("%s%s: %d DEBUG2 %s/%d: Sending SIGUSR2 to pgrp\n",
-  Progname, TagName, Pid, __FILE__, __LINE__);
- killm(C_PGRP, getpgrp(), SIGUSR2);
-#else
  send_signals=1; /* only send signals once */
 
         for (ind=0; ind< Forker_npids; ind++) {
@@ -1568,7 +1481,6 @@ notify_others()
         Progname, TagName, Pid, __FILE__, __LINE__, Forker_pids[ind]);
         kill(Forker_pids[ind], SIGUSR2);
         }
-#endif
     }
 
 }
@@ -1583,12 +1495,6 @@ handle_error()
 {
     Errors++;
 
-#ifdef CRAY
-    if ( Errors & Upanic_on_error ) {
-        upanic(PA_PANIC);
-    }
-#endif
-
     if ( Maxerrs && Errors >= Maxerrs ) {
  printf("%s%s: %d %s/%d: %d Hit max errors value of %d\n",
     Progname, TagName, Pid, __FILE__, __LINE__, Iter_cnt, Maxerrs);
@@ -2030,25 +1936,6 @@ unsigned char *buf;
  Progname, TagName, __FILE__, __LINE__, errno, strerror(errno) );
  return -1;
  }
-#if NEWIO
-#ifdef sgi
- /* If this is POSIX I/O and it is via aio_{read,write}
- * or lio_listio then after completion of the I/O the
- * value of the file offset for the file is
- * unspecified--which means we cannot trust what
- * tell() told us.  Fudge it here.
- */
- if( (io_type & LIO_IO_ASYNC_TYPES) || (io_type & LIO_RANDOM) ){
- if( tmp != Woffset + grow_incr ){
- if( Debug > 5 ){
- printf("%s: %d DEBUG6 %s/%d: posix fudge, forcing tmp (%d) to match Woffset+grow_incr (%d)\n",
-       Progname, Pid, __FILE__, __LINE__, tmp, Woffset+grow_incr);
- }
- tmp = Woffset + grow_incr;
- }
- }
-#endif
-#endif
  }
 
  lkfile(fd, LOCK_UN, LKLVL0);
@@ -2140,9 +2027,6 @@ int just_trunc; /* lseek has already be
     int cur_offset;
     int new_offset;
     int ret;
-#ifdef CRAY
-    int offset;
-#endif
 
  shrink_cnt++;
 
@@ -2184,19 +2068,6 @@ int just_trunc; /* lseek has already be
             else {
                 new_offset=random_range(min_lseek, max_lseek, 1, NULL);
             }
-
-#ifdef CRAY
-            if ((offset=lseek(fd, new_offset, SEEK_SET)) == -1 ) {
-                fprintf(stderr, "%s%s: %d %s/%d: lseek(%d, %d, SEEK_SET) l3 failed: %s\n",
-                    Progname, TagName, Pid, __FILE__, __LINE__, fd, new_offset, strerror(errno));
-        lkfile(fd, LOCK_UN, LKLVL0);
-                return -1;
-            }
-            else if ( Debug > 3 )
-                printf("%s: %d DEBUG4 %s/%d: lseeked to random offset %d\n",
-                    Progname, Pid, __FILE__, __LINE__, offset);
-    
-#endif
         }
 
  else { /* remove trunc_incr from file */
@@ -2205,41 +2076,19 @@ int just_trunc; /* lseek has already be
 
     if ( new_offset < 0 )
  new_offset=0;
-
-#ifdef CRAY
-    if (  lseek(fd, new_offset, SEEK_SET) == -1 ) {
- fprintf(stderr, "%s%s: %d %s/%d: lseek(fd, %d, SEEK_SET) l4 failed: %s\n",
- Progname, TagName, Pid, __FILE__, __LINE__, new_offset, strerror(errno));
-        lkfile(fd, LOCK_UN, LKLVL0);
- return -1;
-    }
-            else if ( Debug > 3 )
-                printf("%s: %d DEBUG4 %s/%d: lseeked to offset %d, %d bytes from end\n",
-                    Progname, Pid, __FILE__, __LINE__, new_offset, trunc_incr);
-#endif
  }
 
-
-#ifdef CRAY
- ret=trunc(fd);
-#else
  ret=ftruncate(fd, new_offset );
  if( (ret == 0) && (Debug > 3) ){
                 printf("%s: %d DEBUG4 %s/%d: ftruncated to offset %d, %d bytes from end\n",
                     Progname, Pid, __FILE__, __LINE__, new_offset, trunc_incr);
  }
-#endif
 
  lkfile(fd, LOCK_UN, LKLVL0);
 
  if ( ret == -1 ) {
-#ifdef CRAY
- fprintf(stderr, "%s%s: %d %s/%d: trunc failed: %s\n",
- Progname, TagName, Pid, __FILE__, __LINE__, strerror(errno));
-#else
  fprintf(stderr, "%s%s: %d %s/%d: ftruncate failed: %s\n",
  Progname, TagName, Pid, __FILE__, __LINE__, strerror(errno));
-#endif
  return -1;
  }
 
@@ -2756,17 +2605,6 @@ int fd;
 int size;
 {
 
-#ifdef CRAY
-    long avl;
-
-        if ( ialloc(fd, size, IA_CONT, &avl) == -1 ) {
-                fprintf(stderr, "%s%s %s/%d: Unable to pre-alloc space: ialloc failed: %d  %s\n",
- Progname, TagName,
-                        __FILE__, __LINE__, errno, strerror(errno));
-                return -1;
-        }
-#endif
-
 #ifndef NO_XFS
 #ifdef XFS_IOC_RESVSP
     struct xfs_flock64 f;
Index: b/ltp/iogen.c
===================================================================
--- a/ltp/iogen.c
+++ b/ltp/iogen.c
@@ -146,21 +146,6 @@ struct strmap Aio_Strat_Map[] = {
 #else
  { "none", 0 },
 #endif /* !linux */
-#ifdef CRAY
-#if _UMK || RELEASE_LEVEL >= 8000
- { "recall", A_RECALL },
-#endif
-
-#ifdef RECALL_SIZEOF
- { "recalla",    A_RECALLA },
-#endif
- { "recalls",    A_RECALLS },
-#endif /* CRAY */
-
-#ifdef sgi
- { "suspend", A_SUSPEND },
- { "callback", A_CALLBACK },
-#endif
  { NULL, -1 }
 };
 
@@ -195,80 +180,20 @@ struct strmap Omode_Map[] = {
 struct strmap Syscall_Map[] = {
  { "read", READ, 0 },
  { "write", WRITE, SY_WRITE },
-#ifdef CRAY
- { "reada", READA, SY_ASYNC },
- { "writea", WRITEA, SY_WRITE|SY_ASYNC },
-#ifndef _CRAYMPP
- { "ssread", SSREAD, SY_SDS },
- { "sswrite", SSWRITE, SY_WRITE|SY_SDS },
-#endif
- { "listio", LISTIO, SY_ASYNC },
-
- /* listio as 4 system calls */
- { "lread", LREAD, 0 },
- { "lreada", LREADA, SY_ASYNC },
- { "lwrite", LWRITE, SY_WRITE },
- { "lwritea", LWRITEA, SY_WRITE|SY_ASYNC },
-
- /* listio with nstrides > 1 */
- { "lsread", LSREAD, 0 },
- { "lsreada", LSREADA, SY_ASYNC },
- { "lswrite", LSWRITE, SY_WRITE },
- { "lswritea", LSWRITEA, SY_WRITE|SY_ASYNC },
-
- /* listio with nents > 1 */
- { "leread", LEREAD, 0|SY_NENT },
- { "lereada", LEREADA, SY_ASYNC|SY_NENT },
- { "lewrite", LEWRITE, SY_WRITE|SY_NENT },
- { "lewritea", LEWRITEA, SY_WRITE|SY_ASYNC|SY_NENT },
-
- /* listio with nents > 1 & nstrides > 1 */
-
- /* all listio system calls under one name */
- { "listio+", LREAD, 0 },
- { "listio+", LREADA, SY_ASYNC },
- { "listio+", LWRITE, SY_WRITE },
- { "listio+", LWRITEA, SY_WRITE|SY_ASYNC },
- { "listio+", LSREAD, 0 },
- { "listio+", LSREADA, SY_ASYNC },
- { "listio+", LSWRITE, SY_WRITE },
- { "listio+", LSWRITEA, SY_WRITE|SY_ASYNC },
- { "listio+", LEREAD, 0|SY_NENT },
- { "listio+", LEREADA, SY_ASYNC|SY_NENT },
- { "listio+", LEWRITE, SY_WRITE|SY_NENT },
- { "listio+", LEWRITEA, SY_WRITE|SY_ASYNC|SY_NENT },
-#endif
-
  { "pread", PREAD   },
  { "pwrite", PWRITE, SY_WRITE },
-#ifdef sgi
- { "aread", AREAD, SY_ASYNC },
- { "awrite", AWRITE, SY_WRITE|SY_ASYNC },
-#if 0
- /* not written yet */
- { "llread", LLREAD, 0 },
- { "llaread", LLAREAD, SY_ASYNC },
- { "llwrite", LLWRITE, 0 },
- { "llawrite", LLAWRITE, SY_ASYNC },
- { "ffsync", DFFSYNC, SY_WRITE },
-#endif
-#endif /* SGI */
 #ifndef NO_XFS
  { "resvsp", RESVSP, SY_WRITE },
  { "unresvsp", UNRESVSP, SY_WRITE },
  { "reserve", RESVSP, SY_WRITE },
  { "unreserve", UNRESVSP, SY_WRITE },
 #endif
-
-#ifndef CRAY
  { "readv", READV },
  { "writev", WRITEV, SY_WRITE },
  { "mmread", MMAPR },
  { "mmwrite", MMAPW, SY_WRITE },
  { "fsync2", FSYNC2, SY_WRITE },
  { "fdatasync", FDATASYNC, SY_WRITE },
-#endif
-
  { NULL, -1      }
 };
 
@@ -280,36 +205,7 @@ struct strmap Syscall_Map[] = {
 struct strmap Flag_Map[] = {
  { "buffered", 0, 0 },
  { "sync", O_SYNC, 0 },
-#ifdef CRAY
- { "raw", O_RAW, FLG_RAW },
- { "raw+wf", O_RAW | O_WELLFORMED, FLG_RAW },
- { "raw+wf+ldraw", O_RAW | O_WELLFORMED | O_LDRAW, FLG_RAW },
- { "raw+wf+ldraw+sync", O_RAW | O_WELLFORMED | O_LDRAW | O_SYNC, FLG_RAW },
-#ifdef O_SSD
- { "ssd", O_SSD, FLG_RAW },
-#endif
-#ifdef O_LDRAW
- { "ldraw", O_LDRAW, 0 },
-#endif
-#ifdef O_PARALLEL
- { "parallel", O_PARALLEL | O_RAW | O_WELLFORMED,
-  FLG_RAW },
- { "parallel+sync", O_PARALLEL | O_RAW | O_WELLFORMED | O_SYNC,
-  FLG_RAW },
- { "parallel+ldraw", O_PARALLEL | O_RAW | O_WELLFORMED | O_LDRAW,
-  FLG_RAW },
- { "parallel+ldraw+sync",
-  O_PARALLEL | O_RAW | O_WELLFORMED | O_LDRAW | O_SYNC,
-  FLG_RAW },
-#endif
-#endif /* CRAY */
-
  { "direct", O_DIRECT, FLG_RAW },
-#ifdef sgi
- { "dsync", O_DSYNC }, /* affects writes */
- { "rsync", O_RSYNC }, /* affects reads */
- { "rsync+dsync", O_RSYNC|O_DSYNC },
-#endif
  { NULL,    -1     }
 };
 
@@ -353,13 +249,7 @@ char **argv;
     struct io_req   req;
     
     umask(0);
-
-#ifdef CRAY
-    Sds_Avail = sysconf(_SC_CRAY_SDS);
-#else
     Sds_Avail = 0;
-#endif
-
     TagName[0] = '\0';
     parse_cmdline(argc, argv, OPTS);
 
@@ -557,9 +447,6 @@ struct io_req   *req;
     char         pattern, *errp;
     struct strmap *flags, *sc, *aio_strat;
     struct file_info *fptr;
-#ifdef CRAY
-    int                 opcode, cmd;
-#endif
 
     /*
      * Choose system call, flags, and file
@@ -568,32 +455,11 @@ struct io_req   *req;
     sc = Syscall_List[random_range(0, Nsyscalls-1, 1, NULL)];
     req->r_type = sc->m_value;
 
-#ifdef CRAY
-    if (sc->m_value == LISTIO ) {
-    opcode = random_range(0, 1, 1, NULL) ? LO_READ : LO_WRITE;
-    cmd = random_range(0, 1, 1, NULL) ? LC_START : LC_WAIT;
-    }
-#endif
-
     if( sc->m_flags & SY_WRITE )
     pattern = Byte_Patterns[random_range(0, sizeof(Byte_Patterns) - 1, 1, NULL)];
     else
     pattern = 0;
 
-#if CRAY
-    /*
-     * If sds io, simply choose a length (possibly pattern) and return
-     */
-
-    if (sc->m_flags & SY_SDS ) {
-    req->r_data.ssread.r_nbytes = random_range(Mintrans, Maxtrans, BSIZE, NULL);
-    if (sc->m_flags & SY_WRITE)
-    req->r_data.sswrite.r_pattern = pattern;
-
-    return 0;
-    }
-#endif
-
     /*
      * otherwise, we're doing file io.  Choose starting offset, length,
      * open flags, and possibly a pattern (for write/writea).
@@ -856,25 +722,6 @@ struct io_req   *req;
  break;
 
     case LISTIO:
-#ifdef CRAY
- strcpy(req->r_data.listio.r_file, fptr->f_path);
- req->r_data.listio.r_offset = offset;
- req->r_data.listio.r_cmd = cmd;
- req->r_data.listio.r_aio_strat = (aio_strat==NULL) ? 0 : aio_strat->m_value;
- req->r_data.listio.r_filestride = 0;
- req->r_data.listio.r_memstride = 0;
- req->r_data.listio.r_opcode = opcode;
- req->r_data.listio.r_nstrides = 1;
- req->r_data.listio.r_nbytes = length;
- req->r_data.listio.r_uflags = (flags->m_flags & FLG_RAW) ? F_WORD_ALIGNED : 0;
-
- if (opcode == LO_WRITE) {
- req->r_data.listio.r_pattern = pattern;
- req->r_data.listio.r_oflags = O_WRONLY | flags->m_value;
- } else {
- req->r_data.listio.r_oflags = O_RDONLY | flags->m_value;
- }
-#endif
  break;
     }
 
@@ -897,9 +744,6 @@ get_file_info(rec)
 struct file_info    *rec;
 {
     struct stat sbuf;
-#ifdef CRAY
-    struct lk_device_info dinfo;
-#endif
 #ifndef NO_XFS
     int fd;
     struct dioattr finfo;
@@ -916,13 +760,6 @@ struct file_info    *rec;
  return -1;
     }
 
-#if _CRAY2
-    if ((! S_ISREG(sbuf.st_mode)) || strncmp(rec->f_path, "/dev/", 5) == 0) {
- fprintf(stderr, "iogen%s:  device level io not supported on cray2\n", TagName);
- return -1;
-    }
-#endif
-
     rec->f_type = sbuf.st_mode & S_IFMT;
 
     /*
@@ -947,17 +784,6 @@ struct file_info    *rec;
  }
 
  rec->f_riou = BSIZE;
-#ifdef CRAY
- if (lk_rawdev(rec->f_path, dinfo.path, sizeof(dinfo.path), 0) == -1)
-    return -1;
-
- if (lk_devinfo(&dinfo, 0) == -1) {
-    /* can't get raw I/O unit -- use stat to fudge it */
-    rec->f_riou = sbuf.st_blksize;
- } else {
-    rec->f_riou = ctob(dinfo.iou);
- }
-#endif
 #ifndef NO_XFS
  if( (fd = open(rec->f_path, O_RDWR|O_DIRECT, 0)) != -1 ) {
 #ifdef XFS_IOC_DIOINFO
@@ -980,34 +806,10 @@ bozo!
     rec->f_riou = BBSIZE;
  }
 #endif
-
     } else {
 
-#ifdef CRAY
- /*
- * Otherwise, file is a device.  Use lk_devinfo() to get its logical
- * sector size.  This is the iou and riou
- */
-
- strcpy(dinfo.path, rec->f_path);
-
- if (lk_devinfo(&dinfo, 0) == -1) {
-    fprintf(stderr, "iogen%s: %s:  %s\n", TagName, Lk_err_func, Lk_err_mesg);
-    return -1;
- }
-
- rec->f_iou = ctob(dinfo.iou);
- rec->f_riou = ctob(dinfo.iou);
- rec->f_length = ctob(dinfo.length);
-#else
-#ifdef sgi
- rec->f_riou = BBSIZE;
- rec->f_length = BBSIZE;
-#else
  rec->f_riou = BSIZE;
  rec->f_length = BSIZE;
-#endif /* sgi */
-#endif /* CRAY */
     }
 
     return 0;
@@ -1393,32 +1195,12 @@ char *opts;
     struct file_info *fptr;
     int nopenargs;
     char *openargs[5]; /* Flags, cbits, cblks */
-#ifdef CRAY
-    char *errmsg;
-    char *ranges;
-    struct strmap *type;
-#endif
-
     while ((o = getopt(argc, argv, opts)) != EOF) {
         switch ((char)o) {
 
  case 'a':
-#ifndef CRAY
     fprintf(stderr, "iogen%s:  Unrecognized option -a on this platform\n", TagName);
     exit(2);
-#else
-    cp = strtok(optarg, ",");
-    while (cp != NULL) {
- if ((type = str_lookup(Aio_Strat_Map, cp)) == NULL) {
-    fprintf(stderr, "iogen%s:  Unrecognized aio completion strategy:  %s\n", TagName, cp);
-    exit(2);
- }
-
- Aio_Strat_List[Naio_Strat_Types++] = type;
- cp = strtok(NULL, ",");
-    }
-    a_opt++;
-#endif
     break;
 
  case 'f':
@@ -1480,23 +1262,8 @@ char *opts;
     break;
 
  case 'L':
-#ifndef CRAY
     fprintf(stderr, "iogen%s:  Unrecognized option -L on this platform\n", TagName);
     exit(2);
-#else
-    if( parse_ranges(optarg, 1, 255, 1, NULL, &ranges,
-     &errmsg ) == -1 ) {
-    fprintf(stderr, "iogen%s: error parsing listio range '%s': %s\n",
-    TagName, optarg, errmsg);
-    exit(1);
-    }
-
-    Minstrides = range_min(ranges, 0);
-    Maxstrides = range_max(ranges, 0);
-
-    free(ranges);
-    L_opt++;
-#endif
     break;
 
  case 'm':
@@ -1519,19 +1286,6 @@ char *opts;
  case 'O':
 
     nopenargs = string_to_tokens(optarg, openargs, 4, ":/");
-
-#ifdef CRAY
-    if(nopenargs)
- sscanf(openargs[1],"%i", &Ocbits);
-    if(nopenargs > 1)
- sscanf(openargs[2],"%i", &Ocblks);
-
-    Oflags = parse_open_flags(openargs[0], &errmsg);
-    if(Oflags == -1) {
- fprintf(stderr, "iogen%s: -O %s error: %s\n", TagName, optarg, errmsg);
- exit(1);
-    }
-#endif
 #ifndef NO_XFS
     if(!strcmp(openargs[0], "realtime")) {
  /*
@@ -1685,28 +1439,12 @@ char *opts;
  Nsyscalls = 0;
  Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "read");
  Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "write");
-#ifdef CRAY
- Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "reada");
- Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "writea");
- Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "lread");
- Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "lreada");
- Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "lwrite");
- Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "lwritea");
-#endif
-
  Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "pread");
  Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "pwrite");
-#ifdef sgi
- /*Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "aread");*/
- /*Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "awrite");*/
-#endif
-
-#ifndef CRAY
  Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "readv");
  Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "writev");
  Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "mmread");
  Syscall_List[Nsyscalls++] = str_lookup(Syscall_Map, "mmwrite");
-#endif
 
         Fileio = 1;
     }
@@ -1724,18 +1462,6 @@ char *opts;
     Nflags = 0;
     Flag_List[Nflags++] = str_lookup(Flag_Map, "buffered");
     Flag_List[Nflags++] = str_lookup(Flag_Map, "sync");
-#ifdef CRAY
-    Flag_List[Nflags++] = str_lookup(Flag_Map, "raw+wf");
-        Flag_List[Nflags++] = str_lookup(Flag_Map, "ldraw");
-#endif
-
-#ifdef sgi
-    /* Warning: cannot mix direct i/o with others! */
-    Flag_List[Nflags++] = str_lookup(Flag_Map, "dsync");
-    Flag_List[Nflags++] = str_lookup(Flag_Map, "rsync");
-    /* Flag_List[Nflags++] = str_lookup(Flag_Map, "rsync+sync");*/
-    /* Flag_List[Nflags++] = str_lookup(Flag_Map, "rsync+dsync");*/
-#endif
     }
 
     if (Fileio) {
@@ -1897,26 +1623,12 @@ FILE *stream;
     fprintf(stream, "\n");
 #ifndef linux
     fprintf(stream, "\t-a aio_type,...  Async io completion types to choose.  Supported types\n");
-#ifdef CRAY
-#if _UMK || RELEASE_LEVEL >= 8000
-    fprintf(stream, "\t                 are:  poll, signal, recall, recalla, and recalls.\n");
-#else
-    fprintf(stream, "\t                 are:  poll, signal, recalla, and recalls.\n");
-#endif
-#else
     fprintf(stream, "\t                 are:  poll, signal, suspend, and callback.\n");
-#endif
     fprintf(stream, "\t                 Default is all of the above.\n");
 #else /* !linux */
     fprintf(stream, "\t-a               (Not used on Linux).\n");
 #endif /* !linux */
     fprintf(stream, "\t-f flag,...      Flags to use for file IO.  Supported flags are\n");
-#ifdef CRAY
-    fprintf(stream, "\t                 raw, ssd, buffered, ldraw, sync,\n");
-    fprintf(stream, "\t                 raw+wf, raw+wf+ldraw, raw+wf+ldraw+sync,\n");
-    fprintf(stream, "\t                 and parallel (unicos/mk on MPP only).\n");
-    fprintf(stream, "\t                 Default is 'raw,ldraw,sync,buffered'.\n");
-#else
 #ifndef NO_XFS
     fprintf(stream, "\t                 buffered, direct, sync.\n");
     fprintf(stream, "\t                 Default is 'buffered,sync'.\n");
@@ -1924,17 +1636,12 @@ FILE *stream;
     fprintf(stream, "\t                 buffered, sync.\n");
     fprintf(stream, "\t                 Default is 'buffered,sync'.\n");
 #endif /* sgi */
-#endif /* CRAY */
     fprintf(stream, "\t-h               This help.\n");
     fprintf(stream, "\t-i iterations[s] # of requests to generate.  0 means causes iogen\n");
     fprintf(stream, "\t                 to run until it's killed.  If iterations is suffixed\n");
     fprintf(stream, "\t                 with 's', then iterations is the number of seconds\n");
     fprintf(stream, "\t                 that iogen should run for.  Default is '0'.\n");
-#ifndef CRAY
     fprintf(stream, "\t-L min:max       listio nstrides / nrequests range\n");
-#else
-    fprintf(stream, "\t-L               (Not used on this platform).\n");
-#endif /* !CRAY */
     fprintf(stream, "\t-m offset-mode   The mode by which iogen chooses the offset for\n");
     fprintf(stream, "\t                 consectutive transfers within a given file.\n");
     fprintf(stream, "\t                 Allowed values are 'random', 'sequential',\n");
@@ -1943,9 +1650,6 @@ FILE *stream;
     fprintf(stream, "\t-N tagname       Tag name, for Monster.\n");
     fprintf(stream, "\t-o               Form overlapping consecutive requests.\n");
     fprintf(stream, "\t-O               Open flags for creating files\n");
-#ifdef CRAY
-    fprintf(stream, "\t                 {O_PLACE,O_BIG,etc}[:CBITS[:CBLKS]]\n");
-#endif
 #ifndef NO_XFS
     fprintf(stream, "\t                 realtime:extsize - put file on real-time volume\n");
     fprintf(stream, "\t                 allocate - allocate space with F_ALLOCSP\n");
@@ -1959,17 +1663,6 @@ FILE *stream;
     fprintf(stream, "\t-q               Quiet mode.  Normally iogen spits out info\n");
     fprintf(stream, "\t                 about test files, options, etc. before starting.\n");
     fprintf(stream, "\t-s syscall,...   Syscalls to do.  Supported syscalls are\n");
-#ifdef sgi
-    fprintf(stream, "\t                 read, write, pread, pwrite, readv, writev\n");
-    fprintf(stream, "\t                 aread, awrite, resvsp, unresvsp, ffsync,\n");
-    fprintf(stream, "\t                 mmread, mmwrite, fsync2, fdatasync,\n");
-    fprintf(stream, "\t                 Default is 'read,write,pread,pwrite,readv,writev,mmread,mmwrite'.\n");
-#endif
-#ifdef CRAY
-    fprintf(stream, "\t                 read, write, reada, writea, listio,\n");
-    fprintf(stream, "\t                 ssread (PVP only), and sswrite (PVP only).\n");
-    fprintf(stream, "\t                 Default is 'read,write,reada,writea,listio'.\n");
-#endif
 #ifdef linux
     fprintf(stream, "\t                 read, write, pread, pwrite, readv, writev,\n");
     fprintf(stream, "\t                 mmread, mmwrite, fsync2, fdatasync,\n");
Index: b/src/dirperf.c
===================================================================
--- a/src/dirperf.c
+++ b/src/dirperf.c
@@ -28,9 +28,7 @@
 #include <string.h>
 #include <unistd.h>
 
-#ifndef __sgi__
 typedef unsigned int uint_t;
-#endif
 
 /*
  * Loop over directory sizes:
Index: b/src/dmiperf.c
===================================================================
--- a/src/dmiperf.c
+++ b/src/dmiperf.c
@@ -28,15 +28,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#ifdef  sgi
-#include <sys/attributes.h>
-#else
 #include <attr/attributes.h>
-#endif
 
-#ifndef sgi
 typedef unsigned int uint_t;
-#endif
 
 /*
  * Loop over directory sizes:
Index: b/src/global.h
===================================================================
--- a/src/global.h
+++ b/src/global.h
@@ -21,11 +21,6 @@
 
 #include <config.h>
 
-#ifdef sgi
-#include <../../irix/include/xfs/platform_defs.h>
-#include <../../xfsprogs/include/irix.h>
-#endif
-
 #ifdef HAVE_XFS_XFS_H
 #include <xfs/xfs.h>
 #endif
Index: b/src/multi_open_unlink.c
===================================================================
--- a/src/multi_open_unlink.c
+++ b/src/multi_open_unlink.c
@@ -24,11 +24,7 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
-#ifdef  sgi
-#include <sys/attributes.h>
-#else
 #include <attr/attributes.h>
-#endif
 
 #define MAX_EA_NAME 30
 
Index: b/src/randholes.c
===================================================================
--- a/src/randholes.c
+++ b/src/randholes.c
@@ -54,13 +54,8 @@ static int test;
  * F_FSGETXATTR (Irix).
  *
  */
-#ifdef __sgi__ /* Irix */
-#  define xfscntl(filename, fd, cmd, arg) \
- fcntl((fd), F_ ## cmd, (arg))
-#else /* ! __sgi__ */
 #  define xfscntl(filename, fd, cmd, arg) \
  xfsctl((filename), (fd), XFS_IOC_ ## cmd, (arg))
-#endif /* ! __sgi__ */
 
 static void
 usage(char *progname)

_______________________________________________
xfs mailing list
[hidden email]
http://oss.sgi.com/mailman/listinfo/xfs
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[PATCH 2/3] xfstests: remove unused conditional NO_XFS

Rich Johnston
In reply to this post by Rich Johnston
This patch removes the unused conditional NO_XFS which was added with
commit 332ee29d1ab7a8690ca8f6d06b0d116e3a4a4f0f:
  "xfstests updates - rework build to be like other xfs packages ..."

Signed-off-by: Rich Johnston <[hidden email]>

---
 ltp/doio.c      |   70 --------------------------------------------------------
 ltp/growfiles.c |   20 ----------------
 ltp/iogen.c     |   30 ------------------------
 3 files changed, 120 deletions(-)

Index: b/ltp/doio.c
===================================================================
--- a/ltp/doio.c
+++ b/ltp/doio.c
@@ -37,10 +37,8 @@
 #include <sys/time.h> /* for delays */
 #include <ctype.h>
 
-#ifndef NO_XFS
 struct io_req;
 int do_xfsctl(struct io_req *);
-#endif
 
 #include "doio.h"
 #include "pattern.h"
@@ -172,11 +170,9 @@ struct fd_cache {
  int c_oflags;
  int c_fd;
  long    c_rtc;
-#ifndef NO_XFS
  int c_memalign; /* from xfsctl(XFS_IOC_DIOINFO) */
  int c_miniosz;
  int c_maxiosz;
-#endif
  void *c_memaddr; /* mmapped address */
  int c_memlen; /* length of above region */
 };
@@ -777,12 +773,10 @@ doio()
  case LEWRITEA:
  rval = do_rw(&ioreq);
  break;
-#ifndef NO_XFS
  case RESVSP:
  case UNRESVSP:
  rval = do_xfsctl(&ioreq);
  break;
-#endif
  case FSYNC2:
  case FDATASYNC:
  rval = do_sync(&ioreq);
@@ -1056,9 +1050,7 @@ struct io_req *req;
 {
  int         fd, offset, nbytes, oflags, rval;
  char         *addr, *file;
-#ifndef NO_XFS
  struct fd_cache *fdc;
-#endif
 
  /*
  * Initialize common fields - assumes r_oflags, r_file, r_offset, and
@@ -1090,7 +1082,6 @@ struct io_req *req;
 #define wtob(x) (x * sizeof(UINT64_T))
 #endif
 
-#ifndef NO_XFS
  /* get memory alignment for using DIRECT I/O */
  fdc = alloc_fdcache(file, oflags);
 
@@ -1111,14 +1102,6 @@ struct io_req *req;
  } else {
  addr += random_range(0, wtob(1) - 1, 1, NULL);
  }
-#else
- if ((rval = alloc_mem(nbytes + wtob(1) * 2)) < 0) {
- return rval;
- }
-
- addr = Memptr;
-#endif /* !NO_XFS */
-
 
  switch (req->r_type) {
  case READ:
@@ -1167,9 +1150,7 @@ struct io_req *req;
  long         offset, woffset = 0;
  char         *addr, pattern, *file, *msg;
  struct wlog_rec wrec;
-#ifndef NO_XFS
  struct fd_cache *fdc;
-#endif
 
  /*
  * Misc variable setup
@@ -1206,7 +1187,6 @@ struct io_req *req;
  * Allocate SDS space for backdoor write if desired
  */
 
-#ifndef NO_XFS
  /* get memory alignment for using DIRECT I/O */
  fdc = alloc_fdcache(file, oflags);
 
@@ -1231,18 +1211,6 @@ struct io_req *req;
  if( addr != Memptr )
  memmove( addr, Memptr, nbytes);
 
-#else /* sgi */
- if ((rval = alloc_mem(nbytes + wtob(1) * 2)) < 0) {
- return rval;
- }
-
- addr = Memptr;
-
- (*Data_Fill)(Memptr, nbytes, Pattern, Pattern_Length, 0);
- if( addr != Memptr )
- memmove( addr, Memptr, nbytes);
-#endif /* sgi */
-
  rval = -1;
  got_lock = 0;
  logged_write = 0;
@@ -1312,7 +1280,6 @@ struct io_req *req;
      "write() failed:  %s (%d)\n%s\n",
      SYSERR, errno,
      format_rw(req, fd, addr, -1, Pattern, NULL));
-#ifndef NO_XFS
  doio_fprintf(stderr,
      "write() failed:  %s\n\twrite(%d, %#o, %d)\n\toffset %d, nbytes%%miniou(%d)=%d, oflags=%#o memalign=%d, addr%%memalign=%d\n",
      strerror(errno),
@@ -1320,13 +1287,6 @@ struct io_req *req;
      offset,
      fdc->c_miniosz, nbytes%fdc->c_miniosz,
      oflags, fdc->c_memalign, (long)addr%fdc->c_memalign);
-#else
- doio_fprintf(stderr,
-     "write() failed:  %s\n\twrite(%d, %#o, %d)\n\toffset %d, nbytes%%1B=%d, oflags=%#o\n",
-     strerror(errno),
-     fd, addr, nbytes,
-     offset, nbytes%4096, oflags);
-#endif
  doio_upanic(U_RVAL);
  } else if (rval != nbytes) {
  doio_fprintf(stderr,
@@ -1511,7 +1471,6 @@ fmt_ioreq(struct io_req *ioreq, struct s
  cp += sprintf(cp, "          memory alignment is %s\n",
       (io->r_uflags & F_WORD_ALIGNED) ? "aligned" : "unaligned");
 
-#ifndef NO_XFS
  if(io->r_oflags & O_DIRECT) {
  struct dioattr finfo;
 
@@ -1531,8 +1490,6 @@ fmt_ioreq(struct io_req *ioreq, struct s
  cp += sprintf(cp, "          mem alignment 0x%x xfer size: small: %d large: %d\n",
       finfo.d_mem, finfo.d_miniosz, finfo.d_maxiosz);
  }
-#endif
-
  return(errbuf);
 }
 
@@ -1846,9 +1803,7 @@ do_rw(req)
  struct status *s;
  struct wlog_rec wrec;
  struct syscall_info *sy;
-#ifndef NO_XFS
  struct fd_cache *fdc;
-#endif
 
  /*
  * Initialize common fields - assumes r_oflags, r_file, r_offset, and
@@ -1907,18 +1862,12 @@ do_rw(req)
  mem_needed = nbytes;
  }
 
-#ifndef NO_XFS
  /* get memory alignment for using DIRECT I/O */
  fdc = alloc_fdcache(file, oflags);
 
  if ((rval = alloc_mem(mem_needed + wtob(1) * 2 + fdc->c_memalign)) < 0) {
  return rval;
  }
-#else
- if ((rval = alloc_mem(mem_needed + wtob(1) * 2)) < 0) {
- return rval;
- }
-#endif
 
  Pattern[0] = pattern;
 
@@ -1945,14 +1894,12 @@ do_rw(req)
  addr += random_range(0, wtob(1) - 1, 1, NULL);
  }
 
-#ifndef NO_XFS
  /*
  * Force memory alignment for Direct I/O
  */
  if( (oflags & O_DIRECT) && ((long)addr % fdc->c_memalign != 0) ) {
  addr += fdc->c_memalign - ((long)addr % fdc->c_memalign);
  }
-#endif
 
  /*
  * FILL must be done on a word-aligned buffer.
@@ -2141,7 +2088,6 @@ do_rw(req)
  *   - XFS_IOC_RESVSP
  *   - XFS_IOC_UNRESVSP
  */
-#ifndef NO_XFS
 int
 do_xfsctl(req)
  struct io_req *req;
@@ -2232,7 +2178,6 @@ do_xfsctl(req)
 
  return (rval == -1) ? -1 : 0;
 }
-#endif
 
 /*
  *  fsync(2) and fdatasync(2)
@@ -2379,9 +2324,7 @@ int fsa;
  static char errbuf[4096];
  int     fd, nb, flags;
  char *buf, *em, *ep;
-#ifndef NO_XFS
  struct fd_cache *fdc;
-#endif
 
  buf = Memptr;
 
@@ -2406,27 +2349,18 @@ int fsa;
  return errbuf;
  }
 
-#ifndef NO_XFS
  /* Guarantee a properly aligned address on Direct I/O */
  fdc = alloc_fdcache(file, flags);
  if( (flags & O_DIRECT) && ((long)buf % fdc->c_memalign != 0) ) {
  buf += fdc->c_memalign - ((long)buf % fdc->c_memalign);
  }
-#endif
 
  if ((nb = read(fd, buf, length)) == -1) {
-#ifndef NO_XFS
  sprintf(errbuf,
  "Could not read %d bytes from %s for verification:  %s (%d)\n\tread(%d, 0x%p, %d)\n\tbuf %% alignment(%d) = %ld\n",
  length, file, SYSERR, errno,
  fd, buf, length,
  fdc->c_memalign, (long)buf % fdc->c_memalign);
-#else
- sprintf(errbuf,
- "Could not read %d bytes from %s for verification:  %s (%d)\n",
- length, file, SYSERR, errno);
-
-#endif
  return errbuf;
  }
 
@@ -2722,9 +2656,7 @@ int oflags;
  struct fd_cache *free_slot, *oldest_slot, *cp;
  static int cache_size = 0;
  static struct fd_cache *cache = NULL;
-#ifndef NO_XFS
  struct dioattr finfo;
-#endif
 
  /*
  * If file is NULL, it means to free up the fd cache.
@@ -2846,7 +2778,6 @@ int oflags;
  strcpy(free_slot->c_file, file);
  free_slot->c_rtc = Reqno;
 
-#ifndef NO_XFS
  if (oflags & O_DIRECT) {
  if (xfsctl(file, fd, XFS_IOC_DIOINFO, &finfo) == -1) {
  finfo.d_mem = 1;
@@ -2862,7 +2793,6 @@ int oflags;
  free_slot->c_memalign = finfo.d_mem;
  free_slot->c_miniosz = finfo.d_miniosz;
  free_slot->c_maxiosz = finfo.d_maxiosz;
-#endif
  free_slot->c_memaddr = NULL;
  free_slot->c_memlen = 0;
 
Index: b/ltp/growfiles.c
===================================================================
--- a/ltp/growfiles.c
+++ b/ltp/growfiles.c
@@ -89,9 +89,7 @@ void prt_examples();
 int set_sig();
 void sig_handler();
 static void notify_others();
-#ifndef NO_XFS
 int pre_alloc();
-#endif
 
 
 #define NEWIO 1 /* Use the tlibio.c functions */
@@ -293,9 +291,7 @@ int tmp;
 char chr;
 int ret;
 int pre_alloc_space = 0;
-#ifndef NO_XFS
 int total_grow_value = 0; /* used in pre-allocations */
-#endif
 int backgrnd = 1; /* return control to user */
 struct stat statbuf;
 int time_iterval = -1;
@@ -564,13 +560,9 @@ extern int Forker_npids; /* num of forke
 
 
  case 'p' : /* pre allocate space */
-#ifdef NO_XFS
  printf("%s%s: --p is illegal option on this system\n",
  Progname, TagName);
  exit(1);
-#else
- pre_alloc_space++;
-#endif
  break;
 
  case 'P':
@@ -1147,7 +1139,6 @@ no whole file checking will be performed
  Progname, Pid, num_files);
  }
 
-#ifndef NO_XFS
  if ( pre_alloc_space ) {
  if ( iterations == 0 ) {
     fprintf(stderr, "%s%s: %d %s/%d: can NOT pre-alloc and grow forever\n",
@@ -1170,7 +1161,6 @@ no whole file checking will be performed
  total_grow_value=bytes_to_consume;
  }
  }
-#endif
 
  /*
  * If delaying between iterations, get amount time to
@@ -1254,7 +1244,6 @@ no whole file checking will be performed
 
  lkfile(fd, LOCK_EX, LKLVL1);   /* lock if lockfile is LKLVL1 */
 
-#ifndef NO_XFS
  /*
  * preallocation is only done once, if specified.
  */
@@ -1272,7 +1261,6 @@ no whole file checking will be performed
  Iter_cnt=0; /* reset outside loop to restart from one */
  continue;
  }
-#endif
 
  /*
  * grow file by desired amount.
@@ -1348,7 +1336,6 @@ no whole file checking will be performed
     }
         }
     }
-#ifndef NO_XFS
     /*
      * if Iter_cnt == 0, then we pre allocated space to all files
      * and we are starting outside loop over.  Set pre_alloc_space
@@ -1357,9 +1344,6 @@ no whole file checking will be performed
     if ( Iter_cnt == 0 ) {
  pre_alloc_space=0;
     }
-#endif
-
-
  }   /* end iteration for loop */
 
 
@@ -2594,7 +2578,6 @@ lkfile(int fd, int operation, int lkleve
    return 0;
 }
 
-#ifndef NO_XFS
 /***********************************************************************
  *
  ***********************************************************************/
@@ -2605,7 +2588,6 @@ int fd;
 int size;
 {
 
-#ifndef NO_XFS
 #ifdef XFS_IOC_RESVSP
     struct xfs_flock64 f;
 
@@ -2635,8 +2617,6 @@ int size;
  return -1;
  }
 #endif
-#endif
 
  return 0;
 }
-#endif
Index: b/ltp/iogen.c
===================================================================
--- a/ltp/iogen.c
+++ b/ltp/iogen.c
@@ -182,12 +182,10 @@ struct strmap Syscall_Map[] = {
  { "write", WRITE, SY_WRITE },
  { "pread", PREAD   },
  { "pwrite", PWRITE, SY_WRITE },
-#ifndef NO_XFS
  { "resvsp", RESVSP, SY_WRITE },
  { "unresvsp", UNRESVSP, SY_WRITE },
  { "reserve", RESVSP, SY_WRITE },
  { "unreserve", UNRESVSP, SY_WRITE },
-#endif
  { "readv", READV },
  { "writev", WRITEV, SY_WRITE },
  { "mmread", MMAPR },
@@ -744,10 +742,8 @@ get_file_info(rec)
 struct file_info    *rec;
 {
     struct stat sbuf;
-#ifndef NO_XFS
     int fd;
     struct dioattr finfo;
-#endif
 
     /*
      * Figure out if the files is regular, block or character special.  Any
@@ -784,7 +780,6 @@ struct file_info    *rec;
  }
 
  rec->f_riou = BSIZE;
-#ifndef NO_XFS
  if( (fd = open(rec->f_path, O_RDWR|O_DIRECT, 0)) != -1 ) {
 #ifdef XFS_IOC_DIOINFO
     if(xfsctl(rec->f_path, fd, XFS_IOC_DIOINFO, &finfo) != -1) {
@@ -805,7 +800,6 @@ bozo!
  } else {
     rec->f_riou = BBSIZE;
  }
-#endif
     } else {
 
  rec->f_riou = BSIZE;
@@ -829,13 +823,11 @@ int nbytes;
     int     fd, rval;
     char     c;
     struct stat sbuf;
-#ifndef NO_XFS
     int nb;
     struct flock64 f;
     struct fsxattr xattr;
     struct dioattr finfo;
     char *b, *buf;
-#endif
 
     errno = 0;
     rval = stat(path, &sbuf);
@@ -883,7 +875,6 @@ int nbytes;
  }
     } else {
 
-#ifndef NO_XFS
  /*
  *  The file must be designated as Real-Time before any data
  *  is allocated to it.
@@ -926,7 +917,6 @@ bozo!
  fprintf(stderr, "get: fsx_xflags = 0x%x\n",
  xattr.fsx_xflags);
     }
-#endif
  }
 
  /*
@@ -1008,7 +998,6 @@ bozo!
  * file size.
  */
 
-#ifndef NO_XFS
  if(Owrite == 2) {
     close(fd);
     if( (fd = open(path, O_CREAT|O_RDWR|O_DIRECT, 0)) != -1 ) {
@@ -1081,7 +1070,6 @@ bozo!
     }
     free(b);
  } else
-#endif
     if(Owrite) {
     /*fprintf(stderr,
     "create_file_Owrite: lseek(%d, %d {%d}, SEEK_SET)\n",
@@ -1286,7 +1274,6 @@ char *opts;
  case 'O':
 
     nopenargs = string_to_tokens(optarg, openargs, 4, ":/");
-#ifndef NO_XFS
     if(!strcmp(openargs[0], "realtime")) {
  /*
  * -O realtime:extsize
@@ -1323,14 +1310,6 @@ char *opts;
  TagName, openargs[0]);
  exit(1);
     }
-#else
-    Oflags = parse_open_flags(openargs[0], &errmsg);
-    if(Oflags == -1) {
- fprintf(stderr, "iogen%s: -O %s error: %s\n", TagName, optarg, errmsg);
- exit(1);
-    }
-#endif
-
     O_opt++;
     break;
 
@@ -1629,13 +1608,8 @@ FILE *stream;
     fprintf(stream, "\t-a               (Not used on Linux).\n");
 #endif /* !linux */
     fprintf(stream, "\t-f flag,...      Flags to use for file IO.  Supported flags are\n");
-#ifndef NO_XFS
     fprintf(stream, "\t                 buffered, direct, sync.\n");
     fprintf(stream, "\t                 Default is 'buffered,sync'.\n");
-#else
-    fprintf(stream, "\t                 buffered, sync.\n");
-    fprintf(stream, "\t                 Default is 'buffered,sync'.\n");
-#endif /* sgi */
     fprintf(stream, "\t-h               This help.\n");
     fprintf(stream, "\t-i iterations[s] # of requests to generate.  0 means causes iogen\n");
     fprintf(stream, "\t                 to run until it's killed.  If iterations is suffixed\n");
@@ -1650,15 +1624,11 @@ FILE *stream;
     fprintf(stream, "\t-N tagname       Tag name, for Monster.\n");
     fprintf(stream, "\t-o               Form overlapping consecutive requests.\n");
     fprintf(stream, "\t-O               Open flags for creating files\n");
-#ifndef NO_XFS
     fprintf(stream, "\t                 realtime:extsize - put file on real-time volume\n");
     fprintf(stream, "\t                 allocate - allocate space with F_ALLOCSP\n");
     fprintf(stream, "\t                 reserve - reserve space with F_RESVSP (default)\n");
     fprintf(stream, "\t                 noreserve - do not reserve with F_RESVSP\n");
     fprintf(stream, "\t                 direct - use O_DIRECT I/O to write to the file\n");
-#else
-    fprintf(stream, "\t                 {O_SYNC,etc}\n");
-#endif
     fprintf(stream, "\t-p               Output pipe.  Default is stdout.\n");
     fprintf(stream, "\t-q               Quiet mode.  Normally iogen spits out info\n");
     fprintf(stream, "\t                 about test files, options, etc. before starting.\n");

_______________________________________________
xfs mailing list
[hidden email]
http://oss.sgi.com/mailman/listinfo/xfs
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

[PATCH 3/3] xfstests: resolve compiler warnings

Rich Johnston
In reply to this post by Rich Johnston
This patch resolves the following compiler/configure warnings:

 configure: WARNING: unrecognized options: --enable-lib64
 warning: 'xxxx' may be used uninitialized in this function [-Wuninitialized]
 warning: variable 'xxx' set but not used [-Wunused-but-set-variable]
 warning: call to function 'foo' without a real prototype [-Wunprototyped-calls]

Signed-off-by: Rich Johnston <[hidden email]>

---
 Makefile                         |    3
 dmapi/src/suite1/cmd/link_test.c |  135 +++++++++++++++++++--------------------
 lib/tlibio.c                     |   18 +----
 ltp/doio.c                       |   91 ++++++++++++--------------
 ltp/growfiles.c                  |   44 +++++-------
 ltp/iogen.c                      |    4 -
 src/fiemap-tester.c              |    2
 src/ftrunc.c                     |    3
 src/trunc.c                      |    3
 9 files changed, 139 insertions(+), 164 deletions(-)

Index: b/Makefile
===================================================================
--- a/Makefile
+++ b/Makefile
@@ -76,8 +76,7 @@ configure: configure.ac
 
 include/builddefs include/config.h: configure
  ./configure \
-                --libexecdir=/usr/lib \
-                --enable-lib64=yes
+                --libexecdir=/usr/lib
 
 aclocal.m4::
  aclocal --acdir=`pwd`/m4 --output=$@
Index: b/dmapi/src/suite1/cmd/link_test.c
===================================================================
--- a/dmapi/src/suite1/cmd/link_test.c
+++ b/dmapi/src/suite1/cmd/link_test.c
@@ -72,90 +72,87 @@ main(
  char *cname = NULL, *sessinfop = NULL;
  char *path = NULL, *pathbufp = NULL, **versionstrpp = NULL;
  int flags = 0, fd = 0, setdtime = 0, reterror = 0;
- u_int urc;
- int rc;
- dm_ssize_t ssrc;
 
 /* Definitions per the prototypes in dmport.h, in the same order. */
 
- rc = dm_clear_inherit(sid, hanp, hlen, token, attrnamep);
- rc = dm_create_by_handle(sid, dirhanp, dirhlen, token,
+ dm_clear_inherit(sid, hanp, hlen, token, attrnamep);
+ dm_create_by_handle(sid, dirhanp, dirhlen, token,
  hanp, hlen, cname);
- rc = dm_create_session(oldsid, sessinfop, newsidp);
- rc = dm_create_userevent(sid, msglen, msgdatap, tokenp);
- rc = dm_destroy_session(sid);
- rc = dm_downgrade_right(sid, hanp, hlen, token);
- rc = dm_fd_to_handle(fd, hanpp, hlenp);
- rc = dm_find_eventmsg(sid, token, buflen, bufp, rlenp);
- rc = dm_get_allocinfo(sid, hanp, hlen,
+ dm_create_session(oldsid, sessinfop, newsidp);
+ dm_create_userevent(sid, msglen, msgdatap, tokenp);
+ dm_destroy_session(sid);
+ dm_downgrade_right(sid, hanp, hlen, token);
+ dm_fd_to_handle(fd, hanpp, hlenp);
+ dm_find_eventmsg(sid, token, buflen, bufp, rlenp);
+ dm_get_allocinfo(sid, hanp, hlen,
  token, offp, nelem, extentp, nelemp);
- rc = dm_get_bulkall(sid, hanp, hlen, token, mask, attrnamep,
+ dm_get_bulkall(sid, hanp, hlen, token, mask, attrnamep,
  locp, buflen, bufp, rlenp);
- rc = dm_get_bulkattr(sid, hanp, hlen, token, mask, locp, buflen,
+ dm_get_bulkattr(sid, hanp, hlen, token, mask, locp, buflen,
  bufp, rlenp);
- rc = dm_get_config(hanp, hlen, flagname, retvalp);
- rc = dm_get_config_events(hanp, hlen, nelem, eventsetp, nelemp);
- rc = dm_get_dirattrs(sid, hanp, hlen, token, mask, locp, buflen,
+ dm_get_config(hanp, hlen, flagname, retvalp);
+ dm_get_config_events(hanp, hlen, nelem, eventsetp, nelemp);
+ dm_get_dirattrs(sid, hanp, hlen, token, mask, locp, buflen,
  bufp, rlenp);
- rc = dm_get_dmattr(sid, hanp, hlen, token, attrnamep, buflen,
+ dm_get_dmattr(sid, hanp, hlen, token, attrnamep, buflen,
  bufp, rlenp);
- rc = dm_get_eventlist(sid, hanp, hlen, token, nelem, eventsetp, nelemp);
- rc = dm_get_events(sid, maxmsgs, flags, buflen, bufp, rlenp);
- rc = dm_get_fileattr(sid, hanp, hlen, token, mask, statp);
- rc = dm_get_mountinfo(sid, hanp, hlen, token, buflen, bufp, rlenp);
- rc = dm_get_region(sid, hanp, hlen, token, nelem, regbufp, nelemp);
- rc = dm_getall_disp(sid, buflen, bufp, rlenp);
- rc = dm_getall_dmattr(sid, hanp, hlen, token, buflen, bufp, rlenp);
- rc = dm_getall_inherit(sid, hanp, hlen,
+ dm_get_eventlist(sid, hanp, hlen, token, nelem, eventsetp, nelemp);
+ dm_get_events(sid, maxmsgs, flags, buflen, bufp, rlenp);
+ dm_get_fileattr(sid, hanp, hlen, token, mask, statp);
+ dm_get_mountinfo(sid, hanp, hlen, token, buflen, bufp, rlenp);
+ dm_get_region(sid, hanp, hlen, token, nelem, regbufp, nelemp);
+ dm_getall_disp(sid, buflen, bufp, rlenp);
+ dm_getall_dmattr(sid, hanp, hlen, token, buflen, bufp, rlenp);
+ dm_getall_inherit(sid, hanp, hlen,
  token, nelem, inheritbufp, nelemp);
- rc = dm_getall_sessions(nelem, sidbufp, nelemp);
- rc = dm_getall_tokens(sid, nelem, tokenbufp, nelemp);
- rc = dm_handle_cmp(hanp1, hlen1, hanp2, hlen2);
+ dm_getall_sessions(nelem, sidbufp, nelemp);
+ dm_getall_tokens(sid, nelem, tokenbufp, nelemp);
+ dm_handle_cmp(hanp1, hlen1, hanp2, hlen2);
  dm_handle_free(hanp, hlen);
- urc = dm_handle_hash(hanp, hlen);
- rc = dm_handle_is_valid(hanp, hlen);
- rc = dm_handle_to_fshandle(hanp, hlen, fshanpp, fshlenp);
- rc = dm_handle_to_fsid(hanp, hlen, fsidp);
- rc = dm_handle_to_igen(hanp, hlen, igenp);
- rc = dm_handle_to_ino(hanp, hlen, inop);
- rc = dm_handle_to_path(dirhanp, dirhlen, targhanp, targhlen,
+ dm_handle_hash(hanp, hlen);
+ dm_handle_is_valid(hanp, hlen);
+ dm_handle_to_fshandle(hanp, hlen, fshanpp, fshlenp);
+ dm_handle_to_fsid(hanp, hlen, fsidp);
+ dm_handle_to_igen(hanp, hlen, igenp);
+ dm_handle_to_ino(hanp, hlen, inop);
+ dm_handle_to_path(dirhanp, dirhlen, targhanp, targhlen,
  buflen, pathbufp, rlenp);
- rc = dm_init_attrloc(sid, hanp, hlen, token, locp);
- rc = dm_init_service(versionstrpp);
- rc = dm_make_handle(&fsid, &ino, &igen, hanpp, hlenp);
- rc = dm_make_fshandle(&fsid, hanpp, hlenp);
- rc = dm_mkdir_by_handle(sid, dirhanp, dirhlen, token,
+ dm_init_attrloc(sid, hanp, hlen, token, locp);
+ dm_init_service(versionstrpp);
+ dm_make_handle(&fsid, &ino, &igen, hanpp, hlenp);
+ dm_make_fshandle(&fsid, hanpp, hlenp);
+ dm_mkdir_by_handle(sid, dirhanp, dirhlen, token,
  hanp, hlen, cname);
- rc = dm_move_event(sid, token, targetsid, rtokenp);
- rc = dm_obj_ref_hold(sid, token, hanp, hlen);
- rc = dm_obj_ref_query(sid, token, hanp, hlen);
- rc = dm_obj_ref_rele(sid, token, hanp, hlen);
- rc = dm_path_to_fshandle(path, hanpp, hlenp);
- rc = dm_path_to_handle(path, hanpp, hlenp);
- rc = dm_pending(sid, token, delay);
- rc = dm_probe_hole(sid, hanp, hlen, token, off, len, roffp, dmrlenp);
- rc = dm_punch_hole(sid, hanp, hlen, token, off, len);
- rc = dm_query_right(sid, hanp, hlen, token, rightp);
- rc = dm_query_session(sid, buflen, bufp, rlenp);
- ssrc = dm_read_invis(sid, hanp, hlen, token, off, len, bufp);
- rc =  dm_release_right(sid, hanp, hlen, token);
- rc = dm_remove_dmattr(sid, hanp, hlen, token, setdtime, attrnamep);
- rc = dm_request_right(sid, hanp, hlen, token, uflags, right);
- rc = dm_respond_event(sid, token, response, reterror, buflen, respbufp);
- rc = dm_send_msg(sid, msgtype, buflen, bufp);
- rc = dm_set_disp(sid, hanp, hlen, token, eventsetp, maxevent);
- rc = dm_set_dmattr(sid, hanp, hlen,
+ dm_move_event(sid, token, targetsid, rtokenp);
+ dm_obj_ref_hold(sid, token, hanp, hlen);
+ dm_obj_ref_query(sid, token, hanp, hlen);
+ dm_obj_ref_rele(sid, token, hanp, hlen);
+ dm_path_to_fshandle(path, hanpp, hlenp);
+ dm_path_to_handle(path, hanpp, hlenp);
+ dm_pending(sid, token, delay);
+ dm_probe_hole(sid, hanp, hlen, token, off, len, roffp, dmrlenp);
+ dm_punch_hole(sid, hanp, hlen, token, off, len);
+ dm_query_right(sid, hanp, hlen, token, rightp);
+ dm_query_session(sid, buflen, bufp, rlenp);
+ dm_read_invis(sid, hanp, hlen, token, off, len, bufp);
+ dm_release_right(sid, hanp, hlen, token);
+ dm_remove_dmattr(sid, hanp, hlen, token, setdtime, attrnamep);
+ dm_request_right(sid, hanp, hlen, token, uflags, right);
+ dm_respond_event(sid, token, response, reterror, buflen, respbufp);
+ dm_send_msg(sid, msgtype, buflen, bufp);
+ dm_set_disp(sid, hanp, hlen, token, eventsetp, maxevent);
+ dm_set_dmattr(sid, hanp, hlen,
  token, attrnamep, setdtime, buflen, bufp);
- rc = dm_set_eventlist(sid, hanp, hlen, token, eventsetp, maxevent);
- rc = dm_set_fileattr(sid, hanp, hlen, token, mask, attrp);
- rc = dm_set_inherit(sid, hanp, hlen, token, attrnamep, mode);
- rc = dm_set_region(sid, hanp, hlen, token, nelem, regbufp, exactflagp);
- rc = dm_set_return_on_destroy(sid, hanp, hlen,
+ dm_set_eventlist(sid, hanp, hlen, token, eventsetp, maxevent);
+ dm_set_fileattr(sid, hanp, hlen, token, mask, attrp);
+ dm_set_inherit(sid, hanp, hlen, token, attrnamep, mode);
+ dm_set_region(sid, hanp, hlen, token, nelem, regbufp, exactflagp);
+ dm_set_return_on_destroy(sid, hanp, hlen,
  token,  attrnamep, enable);
- rc = dm_symlink_by_handle(sid, dirhanp, dirhlen, token,
+ dm_symlink_by_handle(sid, dirhanp, dirhlen, token,
  hanp, hlen, cname, path);
- rc = dm_sync_by_handle(sid, hanp, hlen, token);
- rc = dm_upgrade_right(sid, hanp, hlen, token);
- ssrc = dm_write_invis(sid, hanp, hlen, flags, token, off, len, bufp);
+ dm_sync_by_handle(sid, hanp, hlen, token);
+ dm_upgrade_right(sid, hanp, hlen, token);
+ dm_write_invis(sid, hanp, hlen, flags, token, off, len, bufp);
  exit(0);
 }
Index: b/lib/tlibio.c
===================================================================
--- a/lib/tlibio.c
+++ b/lib/tlibio.c
@@ -465,7 +465,6 @@ char **errmsg; /* char pointer that will
 long wrd; /* to allow future features, use zero for now */
 {
     int ret = 0; /* syscall return or used to get random method */
-    char *io_type; /* Holds string of type of io */
 #ifndef linux
     int omethod = method;
     int listio_cmd; /* Holds the listio/lio_listio cmd */
@@ -514,10 +513,8 @@ long wrd; /* to allow future features, u
     /*
      * Determine the system call that will be called and produce
      * the string of the system call and place it in Lio_SysCall.
-     * Also update the io_type char pointer to give brief description
-     * of system call.  Execute the system call and check for
-     * system call failure.  If sync i/o, return the number of
-     * bytes written/read.
+     * Execute the system call and check for system call failure.
+     * If sync i/o, return the number of bytes written/read.
      */
     
     if ( (method & LIO_IO_SYNC) || (method & LIO_IO_TYPES) == 0 ){
@@ -528,7 +525,6 @@ long wrd; /* to allow future features, u
 
  sprintf(Lio_SysCall,
     "write(%d, buf, %d)", fd, size);
- io_type="write";
 
         if ( Debug_level ) {
     printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
@@ -556,7 +552,6 @@ long wrd; /* to allow future features, u
     }
 
     else if ( method & LIO_IO_SYNCV ) {
- io_type="writev(2)";
 
  sprintf(Lio_SysCall,
  "writev(%d, &iov, 1) nbyte:%d", fd, size);
@@ -667,7 +662,6 @@ char **errmsg; /* char pointer that will
 long wrd; /* to allow future features, use zero for now */
 {
     int ret = 0; /* syscall return or used to get random method */
-    char *io_type; /* Holds string of type of io */
 #ifndef linux
     int listio_cmd; /* Holds the listio/lio_listio cmd */
     int omethod = method;
@@ -716,10 +710,8 @@ long wrd; /* to allow future features, u
     /*
      * Determine the system call that will be called and produce
      * the string of the system call and place it in Lio_SysCall.
-     * Also update the io_type char pointer to give brief description
-     * of system call.  Execute the system call and check for
-     * system call failure.  If sync i/o, return the number of
-     * bytes written/read.
+     * Execute the system call and check for system call failure.
+     * If sync i/o, return the number of bytes written/read.
      */
     
     if ( (method & LIO_IO_SYNC) || (method & LIO_IO_TYPES) == 0 ){
@@ -730,7 +722,6 @@ long wrd; /* to allow future features, u
 
  sprintf(Lio_SysCall,
     "read(%d, buf, %d)", fd, size);
- io_type="read";
 
         if ( Debug_level ) {
     printf("DEBUG %s/%d: %s\n", __FILE__, __LINE__, Lio_SysCall);
@@ -758,7 +749,6 @@ long wrd; /* to allow future features, u
     }
 
     else if ( method & LIO_IO_SYNCV ) {
- io_type="readv(2)";
 
  sprintf(Lio_SysCall,
  "readv(%d, &iov, 1) nbyte:%d", fd, size);
Index: b/ltp/doio.c
===================================================================
--- a/ltp/doio.c
+++ b/ltp/doio.c
@@ -210,15 +210,16 @@ void sigbus_handler(); /* Handle sigbus-
 
 void cb_handler(); /* Posix aio callback handler. */
 void noop_handler(); /* Delayop alarm, does nothing. */
-char *hms();
+char *hms(time_t  t);
 char *format_rw();
 char *format_sds();
 char *format_listio();
-char *check_file();
+char *check_file(char *file, int offset, int length, char *pattern,
+    int pattern_length, int patshift, int fsa);
 int doio_fprintf(FILE *stream, char *format, ...);
-void doio_upanic();
+void doio_upanic(int mask);
 void doio();
-void help();
+void help(FILE *stream);
 void doio_delay();
 int     alloc_fd( char *, int );
 int     alloc_mem( int );
@@ -1145,7 +1146,6 @@ struct io_req *req;
  static int pid = -1;
  int         fd, nbytes, oflags;
  /* REFERENCED */
- int signo;
  int         logged_write, rval, got_lock;
  long         offset, woffset = 0;
  char         *addr, pattern, *file, *msg;
@@ -1156,7 +1156,6 @@ struct io_req *req;
  * Misc variable setup
  */
 
- signo   = 0;
  nbytes = req->r_data.write.r_nbytes;
  offset = req->r_data.write.r_offset;
  pattern = req->r_data.write.r_pattern;
@@ -1567,28 +1566,6 @@ fmt_pread(struct io_req *req, struct sys
 }
 
 struct status *
-sy_readv(req, sysc, fd, addr)
-struct io_req *req;
-struct syscall_info *sysc;
-int fd;
-char *addr;
-{
- struct status *sy_rwv();
- return sy_rwv(req, sysc, fd, addr, 0);
-}
-
-struct status *
-sy_writev(req, sysc, fd, addr)
-struct io_req *req;
-struct syscall_info *sysc;
-int fd;
-char *addr;
-{
- struct status *sy_rwv();
- return sy_rwv(req, sysc, fd, addr, 1);
-}
-
-struct status *
 sy_rwv(req, sysc, fd, addr, rw)
 struct io_req *req;
 struct syscall_info *sysc;
@@ -1628,38 +1605,36 @@ int rw;
  return(status);
 }
 
-char *
-fmt_readv(struct io_req *req, struct syscall_info *sy, int fd, char *addr)
-{
- static char errbuf[32768];
- char *cp;
-
- cp = errbuf;
- cp += sprintf(cp, "syscall:  %s(%d, (iov on stack), 1)\n",
-      sy->sy_name, fd);
- return(errbuf);
-}
-
 struct status *
-sy_mmread(req, sysc, fd, addr)
-struct io_req *req;
+sy_readv(req, sysc, fd, addr)
+struct io_req *req;
 struct syscall_info *sysc;
 int fd;
 char *addr;
 {
- struct status *sy_mmrw();
- return sy_mmrw(req, sysc, fd, addr, 0);
+ return sy_rwv(req, sysc, fd, addr, 0);
 }
 
 struct status *
-sy_mmwrite(req, sysc, fd, addr)
-struct io_req *req;
+sy_writev(req, sysc, fd, addr)
+struct io_req *req;
 struct syscall_info *sysc;
 int fd;
 char *addr;
 {
- struct status *sy_mmrw();
- return sy_mmrw(req, sysc, fd, addr, 1);
+ return sy_rwv(req, sysc, fd, addr, 1);
+}
+
+char *
+fmt_readv(struct io_req *req, struct syscall_info *sy, int fd, char *addr)
+{
+ static char errbuf[32768];
+ char *cp;
+
+ cp = errbuf;
+ cp += sprintf(cp, "syscall:  %s(%d, (iov on stack), 1)\n",
+      sy->sy_name, fd);
+ return(errbuf);
 }
 
 struct status *
@@ -1728,6 +1703,26 @@ int rw;
  return(status);
 }
 
+struct status *
+sy_mmread(req, sysc, fd, addr)
+struct io_req *req;
+struct syscall_info *sysc;
+int fd;
+char *addr;
+{
+ return sy_mmrw(req, sysc, fd, addr, 0);
+}
+
+struct status *
+sy_mmwrite(req, sysc, fd, addr)
+struct io_req *req;
+struct syscall_info *sysc;
+int fd;
+char *addr;
+{
+ return sy_mmrw(req, sysc, fd, addr, 1);
+}
+
 char *
 fmt_mmrw(struct io_req *req, struct syscall_info *sy, int fd, char *addr)
 {
Index: b/ltp/growfiles.c
===================================================================
--- a/ltp/growfiles.c
+++ b/ltp/growfiles.c
@@ -62,34 +62,30 @@
 #include "dataascii.h"
 #include "random_range.h"
 #include "databin.h"
-
-
-extern char *openflags2symbols();
-
-extern int parse_open_flags();
-extern int background();
-extern int forker();
-extern int datapidgen();
-extern void databingen();
-extern int datapidchk();
-extern int databinchk();
-extern int file_lock();
-
-int file_size();
-int check_write();
-int shrinkfile();
-int check_file();
-int growfile();
+#include "open_flags.h"
+#include "forker.h"
+#include "file_lock.h"
+
+extern int datapidgen(int pid, unsigned char *buffer, int bsize, int offset);
+extern void databingen(int mode, unsigned char *buffer, int bsize, int offset);
+extern int datapidchk(int pid, char *buffer, int bsize, int offset, char **errmsg);
+extern int databinchk(int mode, char *buffer, int bsize, int offset, char **errmsg);
+
+int file_size(int fd);
+int check_write(int fd, int cf_inter, char *filename, int mode);
+int shrinkfile(int fd, char *filename, int trunc_incr, int trunc_inter, int just_trunc);
+int check_file(int fd, int cf_inter, char *filename, int no_file_check);
+int growfile(int fd, char *file, int grow_incr, unsigned char *buf);
 int cleanup();
 int handle_error();
-int lkfile();
+int lkfile(int fd, int operation, int lklevel);
 void usage();
 void help();
-void prt_examples();
+void prt_examples(FILE *stream);
 int set_sig();
 void sig_handler();
 static void notify_others();
-int pre_alloc();
+int pre_alloc(char *file, int fd, int size);
 
 
 #define NEWIO 1 /* Use the tlibio.c functions */
@@ -1223,7 +1219,7 @@ no whole file checking will be performed
  if ( Debug > 3 ) {
     printf("%s: %d DEBUG3 %s/%d: %d Open filename = %s, open flags = %#o %s\n",
  Progname, Pid, __FILE__, __LINE__, Iter_cnt, filename, ret,
-        openflags2symbols(ret, ",", NULL));
+        openflags2symbols(ret, ",", 0));
  } else if ( Debug > 2 ) {
     printf("%s: %d DEBUG3 %s/%d: %d filename = %s, open flags = %#o\n",
  Progname, Pid, __FILE__, __LINE__, Iter_cnt, filename, ret);
@@ -1269,7 +1265,7 @@ no whole file checking will be performed
  * if we are dealing with a FIFO file.
  */
 
- if (growfile(fd, filename, grow_incr, Buffer) != 0 ) {
+ if (growfile(fd, filename, grow_incr, (unsigned char *)Buffer) != 0 ) {
  handle_error();
  lkfile(fd, LOCK_UN, LKLVL1);   /* release lock */
  close(fd);
@@ -2263,7 +2259,7 @@ int mode;       /* write mode */
  if ( Debug > 0 )
     printf("%s%s: %d DEBUG1 %s/%d: **fd:%d, lk:%d, offset:%d, sz:%d open flags:%#o %s\n",
  Progname, TagName, Pid, __FILE__, __LINE__, fd, lockfile,
- Woffset, Grow_incr, Fileinfo.openflags, openflags2symbols(Fileinfo.openflags, ",", NULL));
+ Woffset, Grow_incr, Fileinfo.openflags, openflags2symbols(Fileinfo.openflags, ",", 0));
 
  fflush(stderr);
  return 1;
Index: b/ltp/iogen.c
===================================================================
--- a/ltp/iogen.c
+++ b/ltp/iogen.c
@@ -132,7 +132,7 @@ int Fileio = 0; /* flag indicating that
 int Naio_Strat_Types = 0; /* # async io completion types    */
 struct strmap *Aio_Strat_List[128]; /* Async io completion types    */
 
-void startup_info();
+void startup_info(FILE *stream, int seed);
 
 /*
  * Map async io completion modes (-a args) names to values.  Macros are
@@ -299,7 +299,7 @@ char **argv;
 void
 startup_info(FILE *stream, int seed)
 {
-    char *value_to_string(), *type;
+    char *value_to_string(struct strmap *map, int val), *type;
     int i;
 
     fprintf(stream, "\n");
Index: b/src/fiemap-tester.c
===================================================================
--- a/src/fiemap-tester.c
+++ b/src/fiemap-tester.c
@@ -423,7 +423,7 @@ compare_fiemap_and_map(int fd, char *map
 {
  struct fiemap *fiemap;
  char *fiebuf;
- int blocks_to_map, ret, cur_extent = 0, last_data;
+ int blocks_to_map, ret, cur_extent = 0, last_data = 0;
  __u64 map_start, map_length;
  int i, c;
 
Index: b/src/ftrunc.c
===================================================================
--- a/src/ftrunc.c
+++ b/src/ftrunc.c
@@ -30,7 +30,7 @@ int     argc;
 char    **argv;
 
 {
-char    ch, *filename="testfile";
+char *filename="testfile";
 int c;
 int fd, err;
 
@@ -40,7 +40,6 @@ if(argc != 3)
         }
 
 while((c=getopt(argc,argv,"f:"))!=EOF) {
-                ch = (char)c;
                 switch (c) {
                 case 'f':
                         filename = optarg;
Index: b/src/trunc.c
===================================================================
--- a/src/trunc.c
+++ b/src/trunc.c
@@ -47,7 +47,7 @@ char **argv;
  int fd, err, elapsed;
  char *buf, *goodbuf;
  time_t starttime;
-        char ch, *filename="testfile";
+        char *filename="testfile";
  int c;
 
 if(argc != 3)
@@ -56,7 +56,6 @@ if(argc != 3)
         }
 
 while((c=getopt(argc,argv,"f:"))!=EOF) {
- ch = (char)c;
  switch (c) {
  case 'f':
  filename = optarg;


_______________________________________________
xfs mailing list
[hidden email]
http://oss.sgi.com/mailman/listinfo/xfs
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: [PATCH 1/3] xfstests: remove unsupported conditionals

Mark Tinguely-3
In reply to this post by Rich Johnston
On 11/09/12 07:23, [hidden email] wrote:

> This patch removes the unsupported sgi and CRAY.
>
> Signed-off-by: Rich Johnston<[hidden email]>
>
> ---
>   dmapi/src/common/lib/dmport.h         |   16
>   dmapi/src/common/lib/util.c           |   16
>   dmapi/src/sample_hsm/wbee.c           |    2
>   dmapi/src/simple/dm_create_session.c  |    3
>   dmapi/src/simple/dm_destroy_session.c |    3
>   dmapi/src/simple/dm_find_eventmsg.c   |    3
>   dmapi/src/simple/dm_getall_sessions.c |    3
>   dmapi/src/simple/dm_getall_tokens.c   |    3
>   dmapi/src/simple/dm_query_session.c   |    3
>   dmapi/src/suite1/cmd/get_mountinfo.c  |    4
>   dmapi/src/suite1/cmd/make_rt_sparse.c |    7
>   dmapi/src/suite1/cmd/print_event.c    |    8
>   dmapi/src/suite1/cmd/print_fshandle.c |   21
>   dmapi/src/suite2/src/check_dmapi.c    |   25
>   dmapi/src/suite2/src/dm_test_daemon.c |   20
>   dmapi/src/suite2/src/mmap.c           |   12
>   dmapi/src/suite2/src/test_invis.c     |   43
>   include/test.h                        |   17
>   include/tlibio.h                      |   40
>   include/usctest.h                     |    2
>   include/write_log.h                   |    8
>   lib/datapid.c                         |  179 ---
>   lib/random_range.c                    |   34
>   lib/str_to_bytes.c                    |    6
>   lib/tlibio.c                          |  777 --------------
>   ltp/doio.c                            | 1866 +---------------------------------
>   ltp/doio.h                            |    6
>   ltp/growfiles.c                       |  162 --
>   ltp/iogen.c                           |  307 -----
>   src/dirperf.c                         |    2
>   src/dmiperf.c                         |    6
>   src/global.h                          |    5
>   src/multi_open_unlink.c               |    4
>   src/randholes.c                       |    5
>   34 files changed, 101 insertions(+), 3517 deletions(-)


Looks good.

Reviewed-by: Mark Tinguely <[hidden email]>

_______________________________________________
xfs mailing list
[hidden email]
http://oss.sgi.com/mailman/listinfo/xfs
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: [PATCH 2/3] xfstests: remove unused conditional NO_XFS

Mark Tinguely-3
In reply to this post by Rich Johnston
On 11/09/12 07:24, [hidden email] wrote:

> This patch removes the unused conditional NO_XFS which was added with
> commit 332ee29d1ab7a8690ca8f6d06b0d116e3a4a4f0f:
>    "xfstests updates - rework build to be like other xfs packages ..."
>
> Signed-off-by: Rich Johnston<[hidden email]>
>
> ---
>   ltp/doio.c      |   70 --------------------------------------------------------
>   ltp/growfiles.c |   20 ----------------
>   ltp/iogen.c     |   30 ------------------------
>   3 files changed, 120 deletions(-)

Looks good.

Reviewed-by: Mark Tinguely <[hidden email]>

_______________________________________________
xfs mailing list
[hidden email]
http://oss.sgi.com/mailman/listinfo/xfs
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: [PATCH 3/3] xfstests: resolve compiler warnings

Mark Tinguely-3
In reply to this post by Rich Johnston
On 11/09/12 07:24, [hidden email] wrote:

> This patch resolves the following compiler/configure warnings:
>
>   configure: WARNING: unrecognized options: --enable-lib64
>   warning: 'xxxx' may be used uninitialized in this function [-Wuninitialized]
>   warning: variable 'xxx' set but not used [-Wunused-but-set-variable]
>   warning: call to function 'foo' without a real prototype [-Wunprototyped-calls]
>
> Signed-off-by: Rich Johnston<[hidden email]>
>
> ---

Looks good.

Reviewed-by: Mark Tinguely <[hidden email]>

_______________________________________________
xfs mailing list
[hidden email]
http://oss.sgi.com/mailman/listinfo/xfs
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: [PATCH 1/3] xfstests: remove unsupported conditionals

Christoph Hellwig
In reply to this post by Rich Johnston
Looks good,

Reviewed-by: Christoph Hellwig <[hidden email]>

_______________________________________________
xfs mailing list
[hidden email]
http://oss.sgi.com/mailman/listinfo/xfs
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: [PATCH 2/3] xfstests: remove unused conditional NO_XFS

Christoph Hellwig
In reply to this post by Rich Johnston
Looks good,

Reviewed-by: Christoph Hellwig <[hidden email]>

_______________________________________________
xfs mailing list
[hidden email]
http://oss.sgi.com/mailman/listinfo/xfs
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: [PATCH 3/3] xfstests: resolve compiler warnings

Christoph Hellwig
In reply to this post by Rich Johnston
Looks good,

Reviewed-by: Christoph Hellwig <[hidden email]>

_______________________________________________
xfs mailing list
[hidden email]
http://oss.sgi.com/mailman/listinfo/xfs
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: [PATCH 0/3] xfstests: remove unused code and resolve warnings

Rich Johnston
In reply to this post by Rich Johnston
On 11/09/2012 07:23 AM, [hidden email] wrote:

> This patchset:
>     1. Removes the unsupported sgi and CRAY conditionals
>     2. Removes the unused conditional NO_XFS
>     3. Resolves compiler/configure warnings
>
> _______________________________________________
> xfs mailing list
> [hidden email]
> http://oss.sgi.com/mailman/listinfo/xfs
>

Christoph and Mark thanks for the review. This series has been committed
to git://oss.sgi.com/xfs/cmds/xfstests master branch, commit 062f9b,
a07ce0, and 2924ad.


--Rich

_______________________________________________
xfs mailing list
[hidden email]
http://oss.sgi.com/mailman/listinfo/xfs
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: [PATCH 0/3] xfstests: remove unused code and resolve warnings

Rich Johnston
In reply to this post by Rich Johnston
On 11/21/2012 11:48 AM, J. Ellis wrote:

> Hi--
>
> I don't know whether any of you are a list admin or not. I've successfully
> subscribed to the list, but all my emails to [hidden email] are being
> bounced as <access denied>. My email is [hidden email].
>
> Can you please forward this to an admin so I can submit my question to the
> list?
>
> Thanks.
>
> Best,
> J.
>
>
> on 11/21/12 9:58 AM, Rich Johnston at [hidden email] wrote:
>
>> On 11/09/2012 07:23 AM, [hidden email] wrote:
>>> This patchset:
>>>      1. Removes the unsupported sgi and CRAY conditionals
>>>      2. Removes the unused conditional NO_XFS
>>>      3. Resolves compiler/configure warnings
>>>
>>> _______________________________________________
>>> xfs mailing list
>>> [hidden email]
>>> http://oss.sgi.com/mailman/listinfo/xfs
>>>
>>
>> Christoph and Mark thanks for the review. This series has been committed
>> to git://oss.sgi.com/xfs/cmds/xfstests master branch, commit 062f9b,
>> a07ce0, and 2924ad.
>>
>>
>> --Rich
>>
>> _______________________________________________
>> xfs mailing list
>> [hidden email]
>> http://oss.sgi.com/mailman/listinfo/xfs
>
>
Hey J,

We have let the system administrator know, with it being so close to the
Thanksgiving holiday I am not sure how quickly this will be resolved.
Sorry for the inconvenience.

--Rich

_______________________________________________
xfs mailing list
[hidden email]
http://oss.sgi.com/mailman/listinfo/xfs
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: [PATCH 0/3] xfstests: remove unused code and resolve warnings

Rich Johnston
On 11/21/2012 01:23 PM, Rich Johnston wrote:

> On 11/21/2012 11:48 AM, J. Ellis wrote:
>> Hi--
>>
>> I don't know whether any of you are a list admin or not. I've
>> successfully
>> subscribed to the list, but all my emails to [hidden email] are being
>> bounced as <access denied>. My email is [hidden email].
>>
>> Can you please forward this to an admin so I can submit my question to
>> the
>> list?
>>
>> Thanks.
>>
>> Best,
>> J.
>>

Hey J,

The admin says you should be good to go please resubmit.

Thanks
--Rich

_______________________________________________
xfs mailing list
[hidden email]
http://oss.sgi.com/mailman/listinfo/xfs
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: [PATCH 0/3] xfstests: remove unused code and resolve warnings

Rich Johnston
On 11/21/2012 01:58 PM, Jeffrey Ellis wrote:

> Looks like not :(
>
> Final-Recipient: rfc822; [hidden email] <mailto:[hidden email]>
> Action: failed
> Status: 5.0.0
> Diagnostic-Code: X-Spam-&-Virus-Firewall; host oss.sgi.com
> <http://oss.sgi.com/>[192.48.182.195]
>     said: 550 5.7.1 <[hidden email] <mailto:[hidden email]>>... Access
> denied (in reply to MAIL FROM
>     command)
>
> I also got another reject that's too long to reprint here, but it looks
> like the systems thinks I'm a spammer. AFAIK, I'm not on any blacklists.
> I've never been rejected by a listserv before.
>
> Best,
> J.
>

K I will pass this along.

_______________________________________________
xfs mailing list
[hidden email]
http://oss.sgi.com/mailman/listinfo/xfs
Loading...