Are there alternatives for `dd`?

Question

What tools other than dd should I use to read and write files with truncation, seeking and skipping? dd's command line options seem inconvenient and foreign and I don't like choosing between slow, but precise seeking mode (bs=1) and fast, but inflexible mode (bs=4k or whatever).

Are there more modern tools to read 555 bytes from one file (or pipe or socket or dev) from position 31337 and write them to the other file at position 128205 (using blocks 512+43), with or without truncation?

Answer 1

There is the tool ddrescue (watch out, there is also dd_rescue which is a different program with almost the same functionality). It uses the more familiar syntax with the single dash for short or double dash for long options. From the man page:

   -i, --input-position=<bytes>
          starting position in input file [0]

   -K, --skip-size=<bytes>
          initial size to skip on read error [64 KiB]

   -M, --retrim
          mark all failed blocks as non-trimmed

   -o, --output-position=<bytes>
          starting position in output file [ipos]

Answer 2

dcfldd is another dd alternative. It doesn't address the OP's question about input/output seek flexibility, but may be useful to others arriving here via google search.

It's based on gnu dd, with the following additional features:

• Hashing on-the-fly - dcfldd can hash the input data as it is being transferred, helping to ensure data integrity.
• Status output - dcfldd can update the user of its progress in terms of the amount of data transferred and how much longer operation will take.
• Flexible disk wipes - dcfldd can be used to wipe disks quickly and with a known pattern if desired.
• Image/wipe Verify - dcfldd can verify that a target drive is a bit-for-bit match of the specified input file or pattern.
• Multiple outputs - dcfldd can output to multiple files or disks at the same time.
• Split output - dcfldd can split output to multiple files with more configurability than the split command.
• Piped output and logs - dcfldd can send all its log data and output to commands as well as files natively.

Answer 3

A good alternative is pv. Not only does it automatically calculate the most efficient block size, essentially speeding things up, but it also provides progress, among other things. It's use is simple:

pv < /dev/sda > sda.img

It plays well with compression too. A fast way to backup and compress a disk in one move is like so:

pv < /dev/sdb | pigz -9 > disk.img.gz

You can learn more here.

Answer 4

You can actually use a dd pipe to accomplish this, without the performance penalty, without truncation or rounding errors, and with byte-level accuracy:

dd iflag=skip_bytes,count_bytes skip=1234 count=42 | dd oflag=seek_bytes conv=notrunc seek=12340 of=test.bin

On the left side, dd will skip the first 1234 bytes and read exactly 42 bytes. It will perform with efficient sector buffering and alignment. Exactly 42 bytes will be read at offset 1234 with no rounding errors. On the right side, dd will seek past exactly 12340 bytes on the output and write only the 42 bytes it receives from the pipe. It will perform with efficient sector buffering and alignment. In the pipeline, the two dd instances will send+receive data in sector-sized chunks for good performance, except for the last few bytes which are handled properly.

Note that there is no oflag for count_bytes, so this pipeline is required!

Here is an example attempting to count only 2 bytes, but without the pipeline. Notice that extra data is consumed on the input and written to the output:

$ printf aaa | dd oflag=seek_bytes conv=notrunc seek=0 count=2 | xxd
0+1 records in
0+1 records out
00000000: 6161 61                                  aaa
3 bytes copied, 0.000158916 s, 18.9 kB/s