11.2 `dd': Convert and copy a file

==================================

`dd' copies a file (from standard input to standard output, by default)

with a changeable I/O block size, while optionally performing

conversions on it.  Synopses:

     dd [OPERAND]...

     dd OPTION

   The only options are `--help' and `--version'.  *Note Common

options::.  `dd' accepts the following operands, whose syntax was

inspired by the DD (data definition) statement of OS/360 JCL.

`if=FILE'

     Read from FILE instead of standard input.

`of=FILE'

     Write to FILE instead of standard output.  Unless `conv=notrunc'

     is given, `dd' truncates FILE to zero bytes (or the size specified

     with `seek=').

`ibs=BYTES'

     Set the input block size to BYTES.  This makes `dd' read BYTES per

     block.  The default is 512 bytes.

　　#一次读取bytes字节，即读入缓冲区的字节数。

`obs=BYTES'

     Set the output block size to BYTES.  This makes `dd' write BYTES

     per block.  The default is 512 bytes.

　　#一次写入bytes字节，即写入缓冲区的字节数。

`bs=BYTES'

     Set both input and output block sizes to BYTES.  This makes `dd'

     read and write BYTES per block, overriding any `ibs' and `obs'

     settings.  In addition, if no data-transforming `conv' option is

     specified, input is copied to the output as soon as it's read,

     even if it is smaller than the block size.

　　#同时设置读/写缓冲区的字节数（等于设置ibs和obs）。

`cbs=BYTES'

     Set the conversion block size to BYTES.  When converting

     variable-length records to fixed-length ones (`conv=block') or the

     reverse (`conv=unblock'), use BYTES as the fixed record length.

　　#一次转换bytes字节。

`skip=N'

     Skip N `ibs'-byte blocks in the input file before copying.  If

     `iflag=skip_bytes' is specified, N is interpreted as a byte count

     rather than a block count.

　　#跳过读入缓冲区开头的 ibs*blocks 块。

`seek=N'

     Skip N `obs'-byte blocks in the output file before copying.  if

     `oflag=seek_bytes' is specified, N is interpreted as a byte count

     rather than a block count.

　　#跳过一段以后才输出

`count=N'

     Copy N `ibs'-byte blocks from the input file, instead of

     everything until the end of the file.  if `iflag=count_bytes' is

     specified, N is interpreted as a byte count rather than a block

     count.  Note if the input may return short reads as could be the

     case when reading from a pipe for example, `iflag=fullblock' will

     ensure that `count=' corresponds to complete input blocks rather

     than the traditional POSIX specified behavior of counting input

     read operations.

　　#只拷贝输入的blocks块

#dd if=file1 of=file2 count=N bs=SIZE 最经典的组合

 

`status=WHICH'

     Transfer information is normally output to stderr upon receipt of

     the `INFO' signal or when `dd' exits.  Specifying WHICH will

     identify which information to suppress.

    `noxfer'

          Do not print the transfer rate and volume statistics that

          normally make up the last status line.

    `none'

          Do not print any informational messages to stderr.  Error

          messages are output as normal.

`conv=CONVERSION[,CONVERSION]...'

     Convert the file as specified by the CONVERSION argument(s).  (No

     spaces around any comma(s).)

     Conversions:

    `ascii'　　　　　　#把EBCDIC码转换为ASCIl码。

          Convert EBCDIC to ASCII, using the conversion table specified

          by POSIX.  This provides a 1:1 translation for all 256 bytes.

    `ebcdic'　　　　　　#把ASCIl码转换为EBCDIC码。

          Convert ASCII to EBCDIC.  This is the inverse of the `ascii'

          conversion.

    `ibm'　　　　　　#把ASCIl码转换为alternate EBCDIC码。

          Convert ASCII to alternate EBCDIC, using the alternate

          conversion table specified by POSIX.  This is not a 1:1

          translation, but reflects common historical practice for `~',

          `[', and `]'.

          The `ascii', `ebcdic', and `ibm' conversions are mutually

          exclusive.

    `block'　　　　　　#把变动位转换成固定字符。

          For each line in the input, output `cbs' bytes, replacing the

          input newline with a space and padding with spaces as

          necessary.

    `unblock'　　　　　　#把固定位转换成变动位。

          Remove any trailing spaces in each `cbs'-sized input block,

          and append a newline.

          The `block' and `unblock' conversions are mutually exclusive.

    `lcase'　　　　　　#把字母由大写转换为小写。

          Change uppercase letters to lowercase.

    `ucase'　　　　　　#把字母由小写转换为大写。

          Change lowercase letters to uppercase.

          The `lcase' and `ucase' conversions are mutually exclusive.

    `sparse'

          Try to seek rather than write NUL output blocks.  On a file

          system that supports sparse files, this will create sparse

          output when extending the output file.  Be careful when using

          this option in conjunction with `conv=notrunc' or

          `oflag=append'.  With `conv=notrunc', existing data in the

          output file corresponding to NUL blocks from the input, will

          be untouched.  With `oflag=append' the seeks performed will

          be ineffective.  Similarly, when the output is a device

          rather than a file, NUL input blocks are not copied, and

          therefore this option is most useful with virtual or pre

          zeroed devices.

    `swab'

          Swap every pair of input bytes.  GNU `dd', unlike others,

          works when an odd number of bytes are read--the last byte is

          simply copied (since there is nothing to swap it with).

　　　　#交换每一对输入字节。

    `sync'

          Pad every input block to size of `ibs' with trailing zero

          bytes.  When used with `block' or `unblock', pad with spaces

          instead of zero bytes.

　　　　#把每个输入记录的大小都调到ibs的大小（用NUL填充）。

　　

     The following "conversions" are really file flags and don't affect

     internal processing:

    `excl'

          Fail if the output file already exists; `dd' must create the

          output file itself.

    `nocreat'

          Do not create the output file; the output file must already

          exist.

          The `excl' and `nocreat' conversions are mutually exclusive.

    `notrunc'

          Do not truncate the output file.

    `noerror'

          Continue after read errors.

    `fdatasync'

          Synchronize output data just before finishing.  This forces a

          physical write of output data.

    `fsync'

          Synchronize output data and metadata just before finishing.

          This forces a physical write of output data and metadata.

`iflag=FLAG[,FLAG]...'

     Access the input file using the flags specified by the FLAG

     argument(s).  (No spaces around any comma(s).)

`oflag=FLAG[,FLAG]...'

     Access the output file using the flags specified by the FLAG

     argument(s).  (No spaces around any comma(s).)

     Here are the flags.  Not every flag is supported on every operating

     system.

    `append'

          Write in append mode, so that even if some other process is

          writing to this file, every `dd' write will append to the

          current contents of the file.  This flag makes sense only for

          output.  If you combine this flag with the `of=FILE' operand,

          you should also specify `conv=notrunc' unless you want the

          output file to be truncated before being appended to.

    `cio'

          Use concurrent I/O mode for data.  This mode performs direct

          I/O and drops the POSIX requirement to serialize all I/O to

          the same file.  A file cannot be opened in CIO mode and with

          a standard open at the same time.

    `direct'

          Use direct I/O for data, avoiding the buffer cache.  Note

          that the kernel may impose restrictions on read or write

          buffer sizes.  For example, with an ext4 destination file

          system and a linux-based kernel, using `oflag=direct' will

          cause writes to fail with `EINVAL' if the output buffer size

          is not a multiple of 512.

    `directory'

          Fail unless the file is a directory.  Most operating systems

          do not allow I/O to a directory, so this flag has limited

          utility.

    `dsync'

          Use synchronized I/O for data.  For the output file, this

          forces a physical write of output data on each write.  For

          the input file, this flag can matter when reading from a

          remote file that has been written to synchronously by some

          other process.  Metadata (e.g., last-access and last-modified

          time) is not necessarily synchronized.

    `sync'

          Use synchronized I/O for both data and metadata.

    `nocache'

          Discard the data cache for a file.  When count=0 all cache is

          discarded, otherwise the cache is dropped for the processed

          portion of the file.  Also when count=0 failure to discard

          the cache is diagnosed and reflected in the exit status.

          Here as some usage examples:

               # Advise to drop cache for whole file

               dd if=ifile iflag=nocache count=0

               # Ensure drop cache for the whole file

               dd of=ofile oflag=nocache conv=notrunc,fdatasync count=0

               # Drop cache for part of file

               dd if=ifile iflag=nocache skip=10 count=10 of=/dev/null

               # Stream data using just the read-ahead cache

               dd if=ifile of=ofile iflag=nocache oflag=nocache

    `nonblock'

          Use non-blocking I/O.

    `noatime'

          Do not update the file's access time.  Some older file

          systems silently ignore this flag, so it is a good idea to

          test it on your files before relying on it.

    `noctty'

          Do not assign the file to be a controlling terminal for `dd'.

          This has no effect when the file is not a terminal.  On many

          hosts (e.g., GNU/Linux hosts), this option has no effect at

          all.

    `nofollow'

          Do not follow symbolic links.

    `nolinks'

          Fail if the file has multiple hard links.

    `binary'

          Use binary I/O.  This option has an effect only on nonstandard

          platforms that distinguish binary from text I/O.

    `text'

          Use text I/O.  Like `binary', this option has no effect on

          standard platforms.

    `fullblock'

          Accumulate full blocks from input.  The `read' system call

          may return early if a full block is not available.  When that

          happens, continue calling `read' to fill the remainder of the

          block.  This flag can be used only with `iflag'.  This flag

          is useful with pipes for example as they may return short

          reads. In that case, this flag is needed to ensure that a

          `count=' argument is interpreted as a block count rather than

          a count of read operations.

    `count_bytes'

          Interpret the `count=' operand as a byte count, rather than a

          block count, which allows specifying a length that is not a

          multiple of the I/O block size.  This flag can be used only

          with `iflag'.

    `skip_bytes'

          Interpret the `skip=' operand as a byte count, rather than a

          block count, which allows specifying an offset that is not a

          multiple of the I/O block size.  This flag can be used only

          with `iflag'.

    `seek_bytes'

          Interpret the `seek=' operand as a byte count, rather than a

          block count, which allows specifying an offset that is not a

          multiple of the I/O block size.  This flag can be used only

          with `oflag'.

     These flags are not supported on all systems, and `dd' rejects

     attempts to use them when they are not supported.  When reading

     from standard input or writing to standard output, the `nofollow'

     and `noctty' flags should not be specified, and the other flags

     (e.g., `nonblock') can affect how other processes behave with the

     affected file descriptors, even after `dd' exits.

   The numeric-valued strings above (N and BYTES) can be followed by a

multiplier: `b'=512, `c'=1, `w'=2, `xM'=M, or any of the standard block

size suffixes like `k'=1024 (*note Block size::).

   Any block size you specify via `bs=', `ibs=', `obs=', `cbs=' should

not be too large--values larger than a few megabytes are generally

wasteful or (as in the gigabyte..exabyte case) downright

counterproductive or error-inducing.

   To process data that is at an offset or size that is not a multiple

of the I/O block size, you can use the `skip_bytes', `seek_bytes' and

`count_bytes' flags.  Alternatively the traditional method of separate

`dd' invocations can be used.  For example, the following shell

commands copy data in 512 KiB blocks between a disk and a tape, but do

not save or restore a 4 KiB label at the start of the disk:

     disk=/dev/rdsk/c0t1d0s2

     tape=/dev/rmt/0

     # Copy all but the label from disk to tape.

     (dd bs=4k skip=1 count=0 && dd bs=512k) <$disk >$tape

     # Copy from tape back to disk, but leave the disk label alone.

     (dd bs=4k seek=1 count=0 && dd bs=512k) <$tape >$disk

   Sending an `INFO' signal to a running `dd' process makes it print

I/O statistics to standard error and then resume copying.  In the

example below, `dd' is run in the background to copy 10 million blocks.

The `kill' command makes it output intermediate I/O statistics, and

when `dd' completes normally or is killed by the `SIGINT' signal, it

outputs the final statistics.

     $ dd if=/dev/zero of=/dev/null count=10MB & pid=$!

     $ kill -s INFO $pid; wait $pid

     3385223+0 records in

     3385223+0 records out

     1733234176 bytes (1.7 GB) copied, 6.42173 seconds, 270 MB/s

     10000000+0 records in

     10000000+0 records out

     5120000000 bytes (5.1 GB) copied, 18.913 seconds, 271 MB/s

   On systems lacking the `INFO' signal `dd' responds to the `USR1'

signal instead, unless the `POSIXLY_CORRECT' environment variable is

set.

   An exit status of zero indicates success, and a nonzero value

indicates failure.