Next: , Previous: 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. See 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.
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, input is copied to the output as soon as it's read, even if it is smaller than the block size.
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=n
Skip nibs’-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.
seek=n
Skip nobs’-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 nibs’-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.
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 or warning 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
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
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.

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 (see 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.