(coreutils.info)dd invocation
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.
`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.
`obs=BYTES'
Set the output block size to BYTES. This makes `dd' write BYTES
per block. The default is 512 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, each input block is copied to the output as a single
block, without aggregating short reads.
`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.
`skip=BLOCKS'
Skip BLOCKS `ibs'-byte blocks in the input file before copying.
`seek=BLOCKS'
Skip BLOCKS `obs'-byte blocks in the output file before copying.
`count=BLOCKS'
Copy BLOCKS `ibs'-byte blocks from the input file, instead of
everything until the end of the file.
`status=noxfer'
Do not print the overall transfer rate and volume statistics that
normally make up the third status line when `dd' exits.
`conv=CONVERSION[,CONVERSION]...'
Convert the file as specified by the CONVERSION argument(s). (No
spaces around any comma(s).)
Conversions:
`ascii'
Convert EBCDIC to ASCII, using the conversion table specified
by POSIX. This provides a 1:1 translation for all 256 bytes.
`ebcdic'
Convert ASCII to EBCDIC. This is the inverse of the `ascii'
conversion.
`ibm'
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'
Replace trailing spaces in each `cbs'-sized input block with 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.
`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).
`noerror'
Continue after read errors.
`nocreat'
Do not create the output file; the output file must already
exist.
`excl'
Fail if the output file already exists; `dd' must create the
output file itself.
The `excl' and `nocreat' conversions are mutually exclusive.
`notrunc'
Do not truncate the output file.
`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.
`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.
`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.
`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'.
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:
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.
automatically generated by info2www version 1.2.2.9