Provided by: sg-utils_1.02-1_i386 bug

NAME

       copies data to and from sg and raw devices

SYNOPSIS

       sgp_dd [OPTION]...

DESCRIPTION

       Copy  data  to  and from Linux SCSI generic (sg), raw devices or normal
       files.  Similar syntax and semantics to dd(1) but does not perform  any
       conversions.  Uses POSIX threads to increase the amount of parallelism.
       This improves speed in some cases.

       bpt=BLOCKS
              each IO transaction will be made using this number of blocks (or
              less if near the end of count). Default is 128.

       bs=BYTES
              this  must  be  the block size of the physical device. Note that
              this differs from dd(1) which permits "bs"  to  be  an  integral
              multiple.  Default is 512 which is usually correct for disks but
              incorrect for cdroms (which normally have 2048 byte blocks).

       coe=0 | 1
              continue on error is 0 (off) by  default.  When  it  is  1  read
              errors  are  stepped  over  (with  a block (or blocks) of zeroes
              being output)

       count=BLOCKS
              copy this number of blocks. Default is minimum  number  that  sg
              devices return from READ CAPACITY (if that works) or 0

       deb=NUM
              outputs  debug  information. If NUM is 0 (default) then none and
              as NUM increases so does the amount of debug (max  debug  output
              when NUM is 9)

       ibs=BYTES
              if given must be the same as bs

       if=FILE
              read from FILE instead of stdin. A file name of - is taken to be
              stdin

       obs=BYTES
              if given must be the same as bs

       of=FILE
              write to FILE instead of stdout. A file name of - is taken to be
              stdout

       seek=BLOCKS
              skip BLOCKS bs-sized blocks at start of output

       skip=BLOCKS
              skip BLOCKS bs-sized blocks at start of input

       thr=NUM
              this is the number or worker threads (default 4) that attempt to
              copy in parallel. Minimum is 0 and maximum is 16

       time=0 | 1
              when  1,  times  transfer  and  does   throughput   calculation,
              outputting  the  results  (to  stderr)  at  completion.  When  0
              (default) doesn’t perform timing

       --version
              outputs version number information and exits

       A raw device must be bound to a block device  prior  to  using  sgp_dd.
       See  raw(8) for more information about binding raw devices. To be safe,
       the sg device mapping to SCSI block devices should be checked with "cat
       /proc/scsi/scsi" before use.

       The count is only deduced for sg devices (minimum > 0 if both input and
       output are sg devices) otherwise it defaults to 0. This is for  safety!
       Raw  device partition information can often be found with fdisk(8) [the
       "-ul" argument is useful in this respect].

       BYTES and BLOCKS  may  be  followed  by  the  following  multiplicative
       suffixes:  c  C  *1;  b  B  *512;  k  *1,024; K *1,000; m *1,048,576; M
       *1,000,000; g *1,073,741,824; and G *1,000,000,000

       All informative, warning and error output is sent  to  stderr  so  that
       dd´s output file can be stdout and remain unpolluted. If no options are
       given, then the usage message is output and nothing else happens.

       Why use sgp_dd? Because in some cases it is twice as fast as dd (mainly
       with sg devices, raw devices give some improvement).  Another reason is
       that big copies fill the block  device  caches  which  has  a  negative
       impact on other machine activity.

EXAMPLES

       Looks quite similar in usage to dd:

          sgp_dd if=/dev/sg0 of=t bs=512 count=1M

       This  will  copy  1  million 512 byte blocks from the device associated
       with /dev/sg0 (which should have 512 byte blocks) to a file  called  t.
       Assuming  /dev/sda  and  /dev/sg0 are the same device then the above is
       equivalent to:

          dd if=/dev/sda of=t bs=512 count=1000000

       although dd´s speed may improve if bs was larger and count was suitably
       reduced. Using a raw device to do something similar on a IDE disk:

          raw /dev/raw/raw1 /dev/hda
          sgp_dd if=/dev/raw/raw1 of=t bs=512 count=1M

       To copy a SCSI disk partition to an IDE disk partition:

          raw /dev/raw/raw2 /dev/hda3
          sgp_dd if=/dev/sg0 skip=10123456 of=/dev/raw/raw2 bs=512

       This  assumes  a valid partition is found on the SCSI disk at the given
       skip block address (past the 5 GB point of  that  disk)  and  that  the
       partition  goes  to  the  end  of  the  SCSI disk. An explicit count is
       probably a safer option.

       To do a fast copy from one  SCSI  disk  to  another  one  with  similar
       geometry (stepping over errors on the source disk):

          sgp_dd if=/dev/sg0 of=/dev/sg1 bs=512 coe=1

AUTHORS

       Written by Doug Gilbert and Peter Allworth.

REPORTING BUGS

       Report bugs to <dgilbert@interlog.com>.

COPYRIGHT

       Copyright © 2000 Douglas Gilbert
       This  software  is  distributed  under  the  GPL version 2. There is NO
       warranty; not even for MERCHANTABILITY  or  FITNESS  FOR  A  PARTICULAR
       PURPOSE.

SEE ALSO

       A  simpler, non-threaded version of this command called sg_dd is in the
       sg_utils package. The lmbench  package  contains  lmdd  which  is  also
       interesting.  raw(8), dd(1)