Linux -- dd 命令

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.