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