Description: updated code to work on modern Linux systems:
 - Removed GCC warnings
 - send SCSI commands using SG_IO
 - Debian FHS compliant.
Forwarded: no
Author: Eric Delaunay <delaunay@debian.org>

--- a/sraw/srawread.c
+++ n/sraw/srawread.c
@@ -79,19 +79,25 @@
  *
  */
 
-#define USE_READ_10
-#undef  SET_FUA  /* "force unit access" for READ(10): don't read from cache but from media */
-#define LESS_VERBOSE_OUTPUT
 #define USE_GETTIMEOFDAY /* please, always! gettimeofday(2) is much more accurate */
+#define USE_SG_IO
 
 
 #include <stdio.h>
+#include <string.h>
 #include <unistd.h>
+#include <errno.h>
+#include <inttypes.h>
 #include <sys/times.h>
 #include <linux/hdreg.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#ifdef USE_SG_IO
+# include <scsi/sg.h>
+#endif
 
-FILE *infile, *ptable;
-unsigned char buffer[2*64*1024];
+FILE *infile = NULL;
+unsigned char buffer[2*64*1024+8];
 
 
 int read_size=32768;
@@ -121,54 +127,99 @@
 int main( int argc, char *argv[] )
 {
   int b,bstart=0,bstep=1;
+  int c=1,verbose=0;
   int status, i;
   unsigned char *cmd;
-  int capacity, sectorsize;
+  unsigned int capacity, sectorsize;
   int this_count, block;
   int rate;
   double starttime, endtime;
-
-  if (argc==1) { 
-    printf("usage: srawread scsi-device [ bstart [ bstop ] ]\n");
-    exit(0);
+  int read_len = 10;			/* length of read command */
+  int fua = 0;				/* "force unit access" for READ(10): don't read from cache but from media */
+#ifdef USE_SG_IO
+  sg_io_hdr_t sgbuf;
+  int legacy_ioctl=0;
+#endif
+
+  while (argc>c && argv[c][0] == '-') {
+    for(i=1; i < strlen(argv[c]); i++)
+      switch (argv[c][i]) {
+	case 'v': verbose = 1; break;
+#ifdef USE_SG_IO
+	case 'i': legacy_ioctl = 1; break;
+#endif
+	case 'f': fua = 1; break;
+	case '6': read_len = 6; break;
+	default: goto error;
+      }
+    c++;
+  }
+  if (argc>c) {
+    infile = fopen( argv[c], "r" );
+    if (!infile) {
+      perror(argv[c]);
+      return 2;
+    }
   }
+  if (argc>c+1) bstart = atoi(argv[c+1]);
+  if (argc>c+2) bstep  = atoi(argv[c+2]);
 
-  infile = fopen( argv[1], "r" );
-  if(!infile) exit(0);
+  if (infile == NULL || argc==1 || argc>c+3) {
+error:
+    printf("usage: sraw [-v]%s scsi-device [ bstart [ bstep ] ]\n",
+#ifdef USE_SG_IO
+	    "[-i]"
+#else
+	    ""
+#endif
+	    );
+    return 1;
+  }
 
-  if (argc>2) bstart = atoi(argv[2]);
-  if (argc>3) bstep  = atoi(argv[2]);
+  memset(buffer, 0, sizeof(buffer));
 
-  for (i=0; i<10*1024; i++)
-  {
-    buffer[i] = 0;
-  }
-  
   *( (int *)  buffer )		= 0;	/* length of input data */
   *( ((int *) buffer) + 1 )	= read_size;	/* length of output buffer */
 
-  cmd = (char *) ( ((int *) buffer) + 2 );
+  cmd = (unsigned char *) ( ((int *) buffer) + 2 );
   
-  cmd[0] = 0x25;			/* INQUIRY */
-  cmd[1] = 0x00;			/* lun=0, evpd=0 */
-  cmd[2] = 0x00;			/* page code = 0 */
-  cmd[3] = 0x00;			/* (reserved) */
-  cmd[4] = 0x00;			/* allocation length */
-  cmd[5] = 0x00;			/* control */
-
+  cmd[0] = 0x25;			/* READ CAPICTY (10 bytes)*/
+  cmd[1] = 0x00;			/* b7-5: lun=0, b4-1: reserved, b0: reladdr=0 */
+  /* cmd[2..5] = 0x00;			   logical block address = 0 */
+  /* cmd[6..8] = 0x00;			   (reserved), cmd[8].b0=PMI(0) */
+  /* cmd[9] = 0x00;			   control */
+
+#ifdef USE_SG_IO
+  if (! legacy_ioctl) {
+    memset(&sgbuf, 0, sizeof(sgbuf));
+    sgbuf.interface_id = 'S';		/* SCSI Generic Interface */
+    sgbuf.dxfer_direction = SG_DXFER_FROM_DEV;
+    sgbuf.cmd_len = 10;
+    sgbuf.cmdp = cmd;
+    sgbuf.dxfer_len = 8;		/* send back 8 bytes of data (capacity, sectorsize) */
+    sgbuf.dxferp = cmd;
+    sgbuf.timeout = 2000;
+    status = ioctl( fileno(infile), SG_IO, &sgbuf );
+  }
+  else
+#endif
   status = ioctl( fileno(infile), 1 /* SCSI_IOCTL_SEND_COMMAND */, buffer );
-
+  if (status < 0) {
+    perror("ioctl");
+    return 3;
+  }
   capacity = (buffer[8] << 24) | (buffer[9] << 16)  | (buffer[10] << 8) | buffer[11];
   sectorsize = (buffer[12] << 24) | (buffer[13] << 16)  | (buffer[14] << 8) | buffer[15];
-  printf("Size %d  sectorsize %d\n", capacity * (sectorsize >> 9), sectorsize);
-
+  if (verbose)
+    printf("Size %llu bytes, sectorsize %u\n", ((uint64_t)capacity) * sectorsize, sectorsize);
 
   do{
+/*
 	  for (i=0; i<10*1024; i++)
 	  {
 		  buffer[i] = 0;
 	  }
-	  
+*/
 	  block = 0;
 	  this_count = read_size / sectorsize;
 	  starttime = time_so_far();
@@ -176,45 +227,62 @@
 		  *( (int *)  buffer )		= 0;	/* length of input data */
 		  *( ((int *) buffer) + 1 )	= read_size;	/* length of output buffer */
 		  
-		  cmd = (char *) ( ((int *) buffer) + 2 );
+		  cmd = (unsigned char *) ( ((int *) buffer) + 2 );
 		  
 		  b = bstart + bstep * block;
-#ifdef USE_READ_10
-		  cmd[0] = 0x28;			/* read_10 */
-		  cmd[1] = 0x00;
-#ifdef SET_FUA
-		  cmd[1] |= 0x08;
-#endif /* SET_FUA */
-		  cmd[2] = (b >> 24) & 0xff;
-		  cmd[3] = (b >> 16) & 0xff;
-		  cmd[4] = (b >>  8) & 0xff;
-		  cmd[5] =  b        & 0xff;
-		  cmd[6] = 0;
-		  cmd[7] = (this_count >> 8) & 0xff; /* transfer length */
-		  cmd[8] =  this_count       & 0xff;
-		  cmd[9] = 0x00; /* control */
-#else /* USE_READ_10 */
-		  cmd[0] = 0x08;			/* read_6 */
-		  cmd[1] = (b >> 16) & 0x1f;
-		  cmd[2] = (b >> 8) & 0xff;
-		  cmd[3] = b & 0xff;
-		  cmd[4] = this_count;
-		  cmd[5] = 0x00;
-#endif /* USE_READ_10 */
-		  
+		  if (read_len == 10) {
+		    cmd[0] = 0x28;			/* read_10 */
+		    cmd[1] = 0x00;
+		    if (fua)
+		      cmd[1] |= 0x08;
+		    cmd[2] = (b >> 24) & 0xff;
+		    cmd[3] = (b >> 16) & 0xff;
+		    cmd[4] = (b >>  8) & 0xff;
+		    cmd[5] =  b        & 0xff;
+		    cmd[6] = 0;
+		    cmd[7] = (this_count >> 8) & 0xff; /* transfer length */
+		    cmd[8] =  this_count       & 0xff;
+		    cmd[9] = 0x00; /* control */
+		  }
+		  else {
+		    cmd[0] = 0x08;			/* read_6 */
+		    cmd[1] = (b >> 16) & 0x1f;
+		    cmd[2] = (b >> 8) & 0xff;
+		    cmd[3] = b & 0xff;
+		    cmd[4] = this_count;
+		    cmd[5] = 0x00;
+		  }
+#ifdef USE_SG_IO
+		  if (! legacy_ioctl) {
+		    memset(&sgbuf, 0, sizeof(sgbuf));
+		    sgbuf.interface_id = 'S';		/* SCSI Generic Interface */
+		    sgbuf.dxfer_direction = SG_DXFER_FROM_DEV;
+		    sgbuf.cmd_len = read_len;
+		    sgbuf.cmdp = cmd;
+		    sgbuf.dxfer_len = read_size;
+		    sgbuf.dxferp = cmd;
+		    sgbuf.timeout = 2000;
+		    status = ioctl( fileno(infile), SG_IO, &sgbuf );
+		  }
+		  else
+#endif
 		  status = ioctl( fileno(infile), 3 /* SCSI_IOCTL_BENCHMARK_COMMAND */, buffer );
-		  if(status) fprintf(stderr,"%x ", status);
+		  if (status < 0) {
+		    if (verbose)
+		      printf("ioctl: %s\n", strerror(errno));
+		    else
+		      printf("(%d) ", status);
+		  }
 		  block += this_count;
 	  } while(block < (10000 / (sectorsize >> 9)));
 	  endtime = time_so_far() - starttime;
 	  rate = (block * sectorsize) / endtime;
-#ifdef LESS_VERBOSE_OUTPUT
-	  printf("%6d   %10.4f  %6d    %8d \n",
+	  if (!verbose)
+	    printf("%6d   %10.4f  %6d    %8d \n",
 		 read_size, endtime, block, rate);
-#else /* LESS_VERBOSE_OUTPUT */
-	  printf("Blocksize %d, time elapsed %1.4f seconds, %d blocks.  Throughput = %d bytes/sec\n",
+	  else
+	    printf("Blocksize %d, time elapsed %1.4f seconds, %d blocks.  Throughput = %d bytes/sec\n",
 		 read_size, endtime, block, rate);
-#endif /* LESS_VERBOSE_OUTPUT */
 
 	  read_size += 4096;
   } while(read_size <= 2*64*1024);
--- a/sraw/sraw.8
+++ b/sraw/sraw.8
@@ -0,0 +1,82 @@
+.\" -*- nroff -*-
+.TH SRAW 8 "Nov 1993"
+.SH NAME
+sraw \- benchmark raw scsi I/O performance under linux
+.SH SYNOPSIS
+.B sraw
+[
+.B -fiv6
+]
+.B scsi-device
+[
+.B bstart
+[
+.B bstep
+] ]
+.SH DESCRIPTION
+This program basically reads the specified scsi device and measures the
+throughput.  Note that the filesystem *AND* the buffer cache are
+bypassed by this code, this program was designed to benchmark the naked
+scsi drivers by themselves without the need to account for the overhead
+of any other portion of the kernel. It also could be used to benchmark
+disk read throughput.
+.P
+This program does a series of reads of the disk, of consecutive
+areas on the disk.  The device is first queried to determine the
+sector size for the device, and then the series of reads is begun.
+About 5.0 Mb is read from the device, and then the performance numbers
+are reported.  Note that since the buffer cache is completely bypassed,
+there is no need to be concerned about cache hits or anything.
+.P
+Output of
+.B sraw
+is a set of lines, 4 numbers per line:
+.I blocksize, elapsed time, nblocks
+and
+.I throughput
+(in bytes per second).
+.P
+.B scsi-device
+is either a block device (e.g. /dev/sda, /dev/scd0) or a generic SCSI
+device (e.g. /dev/sg0).
+.SH OPTIONS
+.TP
+.I -f
+set FUA (Force Unit Access) bit during read. Data is then read from
+media instead of internal drive cache.
+.TP
+.I -i
+use legacy ioctl instead of new SG I/O layer (will not work on 2.6
+kernel and block devices).
+.TP
+.I -v
+more verbose output.
+.TP
+.I -6
+use 6-bytes instead of 10-bytes read command. In this case, only the
+first GB of data could be read from media.
+.TP
+.I bstart
+starting block to check different zones on ZBR discs
+.TP
+.I bstep
+factor for sequential stepping, default 1.
+Use 0 for reading always the same blocks (from cache)
+.SH ERRORS
+.B sraw
+could issue input/output errors when reading too many blocks at the
+same time from a block device like /dev/sda. To get rid of them, use
+/dev/sgN instead.
+.SH AUTHOR
+.B sraw
+was first written by Eric Youngdale.
+Extensions (-v, -f, -6, SG IO, man page) were written by Eric Delaunay.
+.SH SEE ALSO
+.B sg_dd(8)
+from sg3-utils package.
+.SH AVAILABILITY
+.B sraw
+is available at
+.nf
+.B ftp://tsx-11.mit.edu/pub/linux/ALPHA/scsi/
+.fi