dd - phpMan

Command: man perldoc info search(apropos)  

File: coreutils.info,  Node: dd invocation,  Next: install invocation,  Prev: cp invocation,  Up: Basic operations

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.

     Read from FILE instead of standard input.

     Write to FILE instead of standard output.  Unless `conv=notrunc'
     is given, `dd' truncates FILE to zero bytes (or the size specified
     with `seek=').

     Set the input block size to BYTES.  This makes `dd' read BYTES per
     block.  The default is 512 bytes.

     Set the output block size to BYTES.  This makes `dd' write BYTES
     per block.  The default is 512 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, each input block is copied to the output as a single
     block, without aggregating short reads.

     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.

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

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

     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

     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.

          Do not print the transfer rate and volume statistics that
          normally make up the last status line.

          Do not print any informational messages to stderr.  Error
          messages are output as normal.

     Convert the file as specified by the CONVERSION argument(s).  (No
     spaces around any comma(s).)


          Convert EBCDIC to ASCII, using the conversion table specified
          by POSIX.  This provides a 1:1 translation for all 256 bytes.

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

          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

          For each line in the input, output `cbs' bytes, replacing the
          input newline with a space and padding with spaces as

          Remove any trailing spaces in each `cbs'-sized input block,
          and append a newline.

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

          Change uppercase letters to lowercase.

          Change lowercase letters to uppercase.

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

          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 corresponding to NUL blocks from the input, will be
          untouched.  With `oflag=append' the seeks performed will be

          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).

          Continue after read errors.

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

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

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

          Do not truncate the output file.

          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.

          Synchronize output data just before finishing.  This forces a
          physical write of output data.

          Synchronize output data and metadata just before finishing.
          This forces a physical write of output data and metadata.

     Access the input file using the flags specified by the FLAG
     argument(s).  (No spaces around any comma(s).)

     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

          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.

          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.

          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.  Note that this flag is turned off
          automatically when a partial block is written, which happens
          when reading from a pipe and not re-blocking.  You can
          prevent that by using `iflag=fullblock'.

          Fail unless the file is a directory.  Most operating systems
          do not allow I/O to a directory, so this flag has limited

          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.

          Use synchronized I/O for both data and metadata.

          Use non-blocking I/O.

          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.

          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

          Do not follow symbolic links.

          Fail if the file has multiple hard links.

          Use binary I/O.  This option has an effect only on nonstandard
          platforms that distinguish binary from text I/O.

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

          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'.

          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'.

     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 (BYTES and BLOCKS) 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::).

   Use different `dd' invocations to use different block sizes for
skipping and I/O.  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:


     # 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

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

Generated by $Id: phpMan.php,v 4.55 2007/09/05 04:42:51 chedong Exp $ Author: Che Dong
On Apache
Under GNU General Public License
2018-01-24 05:27 @ CrawledBy CCBot/2.0 (http://commoncrawl.org/faq/)
Valid XHTML 1.0!Valid CSS!