18 ms·

Dd is not a disk writing tool (2015)

• erikb 10y ago
  Reminds me of "find", which is another tool that is mostly just used for its most boring application.
  • hasenj 10y ago
    What are some of its more interesting applications?
    • erikb 10y ago
      If you need to do anything on a list of files/dirs, but they are not in the same place, or not easily filterable (e.g., all sub directories "/Fillion" but not the ones that start with "Nathan") you can use find to prefilter everything, then hand it over via xargs (if you want all to be handled by one instance of the action program) or with "-exec" (if you want each instance to be handled by a separate instance by the action program). Also check out "find tutorial" articles like this one: http://www.grymoire.com/Unix/Find.html http://www.grymoire.com/Unix/Find.html (e.g., did you know you can filter by size?)
  • koala_man 10y ago
    How about "awk"? It's an entire programming language, but it's only ever used to get single fields.
    • erikb 10y ago
      AWK is also awesome. AWK is in my category of languages you should learn even if you never use it (but you will for sure), because it enables another kind of thinking.
• voidz 10y ago
  Most of the time it's much better (as in, faster) to just use cat (or pv, to get a nice progress bar) for writing a file to a block device, because it streams, and lets underlying heuristics worry about block sizes and whatnot. So: cat foobar.img > /dev/sdi will stream the file rather than what dd does, i.e. read block, write block, read block, write block and so on. Usually I also lower the vm.dirty_bytes and vm.dirty_background_bytes to 16 resp. 48 MB (in bytes) beforehand, which limits the buffer sizes to those amounts. Else it will seem that the progress bar indicates 300MB/s is written, and when it completes you still have to wait a really long time for things to have been written out. Afterwards I restore back vm.dirty_ratio and vm.dirty_background_ratio to respectively 10 and 5 - the defaults on my system. I wish that all of those projects, tutorials etc. that explain how to write their image to a block device, like an sdcard, would start advise using cat, because there is no reason to use dd, it's just something that people stick with because others do it too. I only use dd for specific blocks, like writing back a backup of the mbr, or as a rudimentary hex editor.
  • RJIb8RBYxzAMX9u 10y ago
    > I wish that all of those projects, tutorials etc. that explain how to write their image to a block device, like an sdcard, would start advise using cat, because there is no reason to use dd, it's just something that people stick with because others do it too. I'd wondered whether dd or cat were faster, and indeed cat is faster, but not by much. Also, for some embedded devices, you have to write to specific offsets, so dd is more convenient and explicit. Lastly, cat composes poorly with sudo. $ sudo dd if=foobar.img of=/dev/sdi # works $ sudo cat foobar.img > /dev/sdi # fails unless root b/c redirection is done by shell > I only use dd for specific blocks, like writing back a backup of the mbr, or as a rudimentary hex editor. xxd / xxd -r is much nicer, but I suppose sometimes vim is not available...
    • greggyb 10y ago
      sudo (cat foobar.img > /dev/sdi) No?
      • 10y ago
• pmontra 10y ago
  Indeed $ man dd NAME dd - convert and copy a file SYNOPSIS dd [OPERAND]... dd OPTION DESCRIPTION Copy a file, converting and formatting according to the operands. ... More at http://man7.org/linux/man-pages/man1/dd.1.html http://man7.org/linux/man-pages/man1/dd.1.html See the part after "Each CONV symbol may be:"
• mschuster91 10y ago
  The unique advantage of dd over cat, cp and friends: you can specify the block size. Just try (on OS X) dd if=disk.img of=/dev/disk1... first speedup is gained by using rdisk1, but the real improvement comes with the bs=1m. 2 vs 16 vs 300 MB/s on my machine, when cloning via USB-SATA adapter.
  • nothrabannosir 10y ago
    I always wondered: what determines the optimal block size, and how can I know?
    • mschuster91 10y ago
      In theory the native block size (512 bytes for most drives these days) should be the fastest, but the problem is that if you're doing such small sized I/O, you introduce a shitload of overhead for all the individual r/w calls - I guess that a huge blocksize benefits from DMA and look-ahead reads.
      • vmp 10y ago
        For some reason I cannot reply to your message directly, only to a parent. Flashbench [1] should be able to tell you what the erase-block and page size is. [1] https://github.com/bradfa/flashbench https://github.com/bradfa/flashbench
      • kosma 10y ago
        > native block size (512 bytes for most drives these days) Not anymore. Advanced Format (4096-byte sector) hard drives have taken the market like a storm, and SSDs benefit even more from using larger I/O sizes (because erase sectors are way larger).
        • mschuster91 10y ago
          Ah, I thought it was the other way round. Thanks for the information. Do you know a way to get an SSD's native erase sector size?
• pixelbeat 10y ago
  Yes "D" is not for disk/drive/device/... It comes from the DD (data definition) statement of OS/360 JCL, and hence why dd has the unusual option syntax compared to other unix utils BTW if you are using dd to write usb drives etc. it's useful to bypass the Linux VM as much as possible to avoid systems stalls, especially with slow devices. You can do that with O_DIRECT. Also dd recently got a progress option, so... dd bs=2M if=disk.img of=/dev/sda... status=progress iflag=direct oflag=direct Note dd is a lower level tool, which is why there are some gotchas when using for higher level operations. I've noted a few at: http://www.pixelbeat.org/docs/coreutils-gotchas.html#dd http://www.pixelbeat.org/docs/coreutils-gotchas.html#dd
  • the_mitsuhiko 10y ago
    I thought it stands for copy and convert but cc was taken bu the c compiler.
    • gonzo 10y ago
      Ask a graybeard.
  • lloeki 10y ago
    On OS X (and BSD?) be sure to use /dev/rdisk[0-9]+ instead of /dev/disk[0-9]+. Details as to exactly why it's faster are welcome. (I just know it bypasses stuff). EDIT: someone mentioned this below http://superuser.com/questions/631592/why-is-dev-rdisk-about-20-times-faster-than-dev-disk-in-mac-os-x http://superuser.com/questions/631592/why-is-dev-rdisk-about...
    • djent 10y ago
      Ah wish I knew this last week. Writing Xubuntu to my USB took something like 2900 seconds from a Mac.
      • josteink 10y ago
        Usually just specifying a reasonable blocksize works for me. bs=1m or so. Without that it does literally take hours. I suspect the default blocksize is really small (1?) and combined with uncached/unbuffered writes to slower devices, it just kills all performance outright. Edit: answered! https://news.ycombinator.com/item?id=13350002 https://news.ycombinator.com/item?id=13350002
• rollthehard6 10y ago
  I came from Solaris land originally and it always surprises me how seldom people use filesystem level utilities to copy such stuff, i.e. ufsdump | ufsrestore or dump | restore Works a treat and using the fs level tool you know everything will be properly copied, much safer.
  • rollthehard6 10y ago
    Obviously I'm not talking about raw devices, but people copying disks which often don't have that many filesystems on them.
• mlaux 10y ago
  > It’s unique in its ability to issue seeks and reads of specific lengths, which enables a whole world of shell scripts that have no business being shell scripts. Want to simulate a lseek+execve? Use dd! How would one simulate a call to execve with dd? Seems like a totally different problem domain.
  • kosma 10y ago
    There's a common idiom of skipping a file header and handing off processing to some other program, like this: cat foo | ( dd bs=$HEADERSIZE skip=1 of=/dev/null; process-foo-contents )
    • greenleafjacob 10y ago
      Isn't this the same as: tail -c +$HEADERSIZE <foo
      • tspiteri 10y ago
        The dd idiom can be used to split a file into parts with known block size, something like (dd bs=$SIZE1 count=1 of=file1; dd bs=$SIZE2 ...
    • fiddlerwoaroof 10y ago
      Cool, although this doesn't really help with my most common-case, skipping the first line. (head -1 > /dev/null; cat -) < file
      • kosma 10y ago
        head is line-wise. dd is byte-wise.
        • fiddlerwoaroof 10y ago
          Yeah, I was just saying that generally, when I need to strip off a header, the header is the first line of the file
• deleted 10y ago
  [deleted]
• barhun 10y ago
  + "On UNIX, the adage goes, everything is a file." - not all the things on unix are abstracted as files (or 'byte streams' to be more accurate). however, i/o resources and some ipc facilities are defined so. an operating system provides many other abstractions in addition to these such as processes, threads, non-stream devices, concurrency and synchronization primitives, etc.; thus it's absolutely wrong to say that everything is a file on unix.
  • darfs 10y ago
    Could this provide an example please? Only for those like me, who are wondering...^^
  • RJIb8RBYxzAMX9u 10y ago
    "Everything is a file on UNIX" is as true as "Vulcan's cannot lie."
    • na85 10y ago
      I assume Vulcans can lie?
      • LeoPanthera 10y ago
        Technically they cannot lie. But they can exaggerate. Or omit facts.
    • sh_tinh_hair 10y ago
      Great analogy.
  • qubex 10y ago
    Most notably: network sockets do not have file-like semantics, mainly because they were introduced as a concept and implemented long after the system was designed. Plan9 is an effort to revise all system objects to be accessible with the same file-like fopen/fclose system calls.
  • sh_tinh_hair 10y ago
• microcolonel 10y ago
  This is not strictly true. For example, good luck trying to scp a device to a remote host.
  • snuxoll 10y ago
    "Everything is a stream" is closer to the truth until you learn the dark secret of ioctl and similar fun.
  • progman 10y ago
    > scp a device to a remote host dd if=/dev/hda bs=512 | (ssh root@remote dd of=/dev/hdX bs=512) where bs=512 is the block size in bytes. Of course, the hdX drive must be different from the remote hosts's main drive, otherwise dd won't complete :-)
    • microcolonel 10y ago
      That is not my point. I meant to say that scp itself will refuse to open the block device file for reading.
• peterburkimsher 10y ago
  Can we have a single-purpose tool for getting the text between two delimiter strings? I know it's possible with regex, but given how frequently that parsing logic is needed, and the difficulty of getting sed right, I think a "tb" tool would be very helpful.
  • bbrazil 10y ago
    Does cut(1) work for you?
    • peterburkimsher 10y ago
      cut only supports single ASCII characters as delimiters. Reading a value from "<td>2017-01-09 <b>08:30</b></td>" is harder than it should be. cut needs single-character delimiters, so only splitting on "<" or ">" won't work. sed trips up on the "/", ":", and "-" without proper escaping. This is before even mentioning Unicode. High-level scripting languages handle all of these just fine. I'd much rather have a standard tool and library for this purpose though.
      • protomikron 10y ago
        Maybe use awk? $ echo '<td>2017-01-09 <b>08:30</b></td>' | awk -F'[<>]' '{print $5}' This will give you '08:30'. Unicode seems to be also supported: $ echo 'λf. (λx. f (x x)) (λx. f (x x))' | awk -F'[λ.]' '{print $4}' This prints 'x'. For clarity some other matches: $1: '' $2: 'f' $3: ' (' $4: 'x' ...
        • peterburkimsher 10y ago
          Fine, until the next row doesn't have <b></b> tags. So the $5 no longer matches where it should. I'm just suggesting easier syntax, and a custom tool. Like dd is for disk copying, instead of cp/gzip/etc. A simple tool that will just work. This is the syntax I'm going for: textBetween("<td>", "</td>") | replace ("<b>", "") | replace ("</b>", "") Maybe with some magic strings, e.g. textBetween(":", "end")
• tambourine_man 10y ago
  Yes, but you can't set block size to n bytes in cat. Also, it's useful to have in the back of your mind that dd can very easily mean Disk Destroyer, specially because of it's sui generis syntax
  • koala_man 10y ago
    On the other hand, cat's block size can increase over time to remain reasonable. When I first became aware of it, it was 4 KiB. Now strace shows my GNU cat using 128 KiB.
• notacoward 10y ago
  More importantly: dd is not a benchmarking tool. I can't count how many times people have complained about dd being slow on a distributed filesystem. Well, yeah. When you're writing only one block at a time with no concurrency/parallelism at all, over a network interface that has much higher latency than your disk interface, of course it's slow. When you're using tiny block sizes, as about 80% of these people do, the effect is only magnified. Unless your use case for a distributed system is a single user who doesn't even multitask, use iozone or fio instead.
  • qwertyuiop924 10y ago
    Ouch. Also, seriously people, use the bs flag on dd.
  • sh_tinh_hair 10y ago
    Sure it is. It tells you exactly what performance a single threaded application can expect with serial read()s and write()s (and whatever options you choose to invoke dd with) against whatever file source and constraints/conditions are extant at the time. Perfectly valid.
    • notacoward 10y ago
      OK, so it tells you how a very poorly written application - one which probably shouldn't be running on such a system in the first place - will perform. And it's useless for everyone else. Here, have an internet point.
      • sh_tinh_hair 10y ago
        It also tells you how a bunch of common tools will fare against your wonderfully designed solution that is only 'truly' testable by sophisticated methods. Thanks for whatever it is that you gave me. I don't keep up with nomenclature these days.
        • notacoward 10y ago
• II2II 10y ago
  There are likely a number of reasons for using dd in tutorials designed for beginners: - it is available by default on all Unix systems - it distinguishes between input and output (i.e. if= and of=) - it reports results - it avoids using a common command for a dangerous operation that the user may not understand dd also has another benefit: the ability to select a range of blocks to copy from and to. This isn't the most common scenario, but it certainly pops up on some devices.
  • beams_of_light 10y ago
    Sometimes, it seems like people try to outsmart common knowledge, and it's fine to present new ideas, but one doesn't have to call what most know works and use inappropriate for the tasks they use it to perform.
  • alfalfasprout 10y ago
    It reports results horribly. Nothing like copying 1+TB of data and having your SIGINFO signals print nothing to the screen.
• dockinator 10y ago
  What? Yes dd absolutely is a disk writing tool, although that is not the only or even the tool's intended primary purpose. It is useful for generating serial IO for a variety of purposes. For example, writing data with specific target block size; allocating contiguous blocks for use by an application (be it zeroing out a thin LUN before partitioning, or a file system); or simply dumping the content of one device to another (or to a file). Good luck stretching out a thin LUN or creating an empty file that allocates contiguous space with cat.
• jwr 10y ago
  The best thing about dd is that you can use it with conv=noerror, which will let you recover as much data as possible from an otherwise damaged device.
  • Freaky 10y ago
    That loses you a dd blocksize chunk, which is likely much bigger than the underlying damaged sector. ddrescue or recoverdisk (part of FreeBSD base) will both skip over unreadable blocks, then retry with smaller block sizes along the damaged areas to save as much data as possible.
    • cellularmitosis 10y ago
      Indeed. Also, you'd actually want 'conv=noerror,sync'. The 'sync' keeps the input and output block counts in sync (if an input block can't be read, it writes an output block of zeros to keep the block counts in 'sync'). The arch wiki page is very useful: https://wiki.archlinux.org/index.php/disk_cloning https://wiki.archlinux.org/index.php/disk_cloning
• acomjean 10y ago
  So what is the best way to clone a disk(or in my case a raspberry pi sd cars)? I tried to backup one of my cards last week using dd > .iso file and then tried to put it on a new card. I tried with /dev/Rdisk (faster) but none of the new cards was bootable. So this is saying just use copy. (I ended up just creating a second boot disk, and ftping the files over which seems less than ideal...)
  • koala_man 10y ago
    The article doesn't say to stop using `dd` to write disks. It's just saying that if you have other commands that can read/write files, such as `pv /dev/thing > file.img` (to show a progress bar), you don't have to try to shoe-horn dd into it just because /dev/thing happens to be a drive.
• deleted 10y ago
  [deleted]
• voltagex_ 10y ago
  If you're building disk images with blank space in them (say, for an 8GB EMMC, but your root is only 2GB) you may want to use bmap-tools [1] [2] This way only actual data is written to the device, blocks of zeros can be skipped. 1: https://lwn.net/Articles/563355/ https://lwn.net/Articles/563355/ 2: https://github.com/01org/bmap-tools https://github.com/01org/bmap-tools
• ComputerGuru 10y ago
  I've seen people try to use dd to clone a bad disk before tossing it or attempting recovery - while dd is not the right tool for the job, ddrescue [0] is. ddrescue gives you options for error handling and will skip past bad blocks, it handles read errors much more gracefully. [0]: https://www.gnu.org/software/ddrescue/ https://www.gnu.org/software/ddrescue/
  • wa2flq 10y ago
    Agreed,using dd on media with flaws is not straight forward. See http://www.noah.org/wiki/Dd_-_Destroyer_of_Disks http://www.noah.org/wiki/Dd_-_Destroyer_of_Disks
    • chillingeffect 10y ago
      Breaking your silence! Are you Mr. Spurrier? Ciao.
  • beams_of_light 10y ago
    You can specify options with dd to handle errors as well, such as padding unreadable blocks on the destination.
    • wa2flq 10y ago
      If you use block multiples on media with defects to speed things the good data fills the buffer first, then the remainder is zero padded for the blocks in error. This shifts good data relative to its original position and most likely further corrupts your attempts at recovery - BTDT. This page explains the challenge - https://wiki.archlinux.org/index.php/disk_cloning https://wiki.archlinux.org/index.php/disk_cloning
  • eltoozero 10y ago
    ddrescue and gddrescue also have restartable mode for failing drives, very very handy feature. I've recovered numerous otherwise unmountable Mac/Windows drives using ddrescue, mmls, sleuthkit, and foremost. Usually I'm able to lsblk to determine the block device, rip the data partition with ddrescue and mount it loopback with mount once I use mmls to confirm the partition type. For Mac volumes that dont mount, either fsck.hfsplus or get the file to a Mac to run diskwarrior (Alsoft has been repairing HFS volumes for a couple decades). If nothing else works once you've got the raw bits saved, foremost will usually scrape something worthwhile off your image file.
• ryao 10y ago
  > This belief can make simple tasks complicated. How do you combine dd with gzip? How do you use pv if the source is raw device? How do you dd over ssh? These operations are not that complicated. Behold the magic of UNIX pipes: dd if=/dev/sdb | pv | gzip -c | ssh name@host "gzip -dc | dd of=/dev/sdc"
  • vortico 10y ago
    +1 for using pv, available in the AUR Another useful tip is `curl https://...iso https://...iso | sudo dd of=/dev/sdb` if you don't have enough disk space to hold the ISO. And sometimes internet speeds are faster than disk speeds anyway.
  • koala_man 10y ago
    It's even easier once you realize that dd is not required to read/write disks: pv /dev/sdb | gzip -c | ssh name@host "gzip -dc > /dev/sdc" Not only is this shorter with less cargo cult steps, it also gives a much better `pv` output now that it can determine the size and show a percentage.
    • takeda 10y ago
      Not that parent poster's example is better than yours, since it also doesn't do it, but I believe the biggest strength of dd over cat or redirection, is that you can specify block size. With right block size you will get far better performance and reduce wear of the device when writing block by click than when writing data byte by byte. The key though is to be aware of block size, and use multiply of it.
      • ryao 10y ago
        I omitted block size to simplify it. That said, what you say is correct on writes. On reads, specifying block size is mostly to reduce syscall overhead because readahead will prefetch data to accelerate things.
      • koala_man 10y ago
        It's not quite as simple as that when you're dealing with pipelines. For example: cat /dev/zero | strace dd bs=1M of=/dev/null will show that you're not actually writing 1M blocks. You're just reading whatever `cat` outputs (128KiB blocks on my system), so all you've done is an unnecessary pipe and copy. You would have been better off just redirecting. Similarly, dd if=/dev/zero bs=1M | strace gzip -1 > /dev/null will show you that `gzip` will not start processing larger blocks. You're just adding an additional copy. Linux already has readahead, so I don't know if you'll ever see a benefit to this. On my system, adding dd with higher block size on both sides of a gzip -1 pipeline just ends up being slower.
• catwell 10y ago
  One of those Unix tools that would deserve to be better known is dcfldd (http://dcfldd.sourceforge.net/ http://dcfldd.sourceforge.net/). It is basically dd with extra powers including on-the-fly hashing, progression, multiple outputs...
• daveguy 10y ago
  It may not be a disk writing tool, but it works wonders for swapping from HDD to SDD without having windows freak out and decide you are stealing it.
  • UhUhUhUh 10y ago
    Seconded.
• andrewshadura 10y ago
  bmaptool is my image writing tool, and I think it should be yours too.
• iamdave 10y ago
  It also doesn't stand for 'destroy-disk' as was thought by a junior admin I employed once, and eventually had to fire because the level of incompetence was getting to the point of almost being destructive. Nope, that's not hyperbole. I had to stop the kid from almost installing software that would have connected to a known botnet to help a user connect a personal computer to the VPN. He passed enough checks during the interview we figured "Okay, we can train him in the rest of the things" Lesson learned.
  • brokenmachine 10y ago
    What software connects to a known botnet to allow connection to a VPN?
    • iamdave 10y ago
      https://www.pcworld.com/article/2928340/ultra-popular-hola-vpn-extension-sold-your-bandwidth-for-use-in-a-botnet-attack.amp.html?client=ms-android-hms-tmobile-us https://www.pcworld.com/article/2928340/ultra-popular-hola-v... A user was wanting to bypass some of our network restrictions and the intrepid jr. Admin suggested Hola unblocker to watch Netflix with me sitting 3 feet away. This was effectively the final straw and convinced me I had made the wrong hire. He was out two days later.
• Poiesis 10y ago
  In my experience dd is great for binary data. Yes, pretty much everything on Unix operates on files, as does dd. But so many utilities are either line based or don't handle null bytes, and it's a pain to have determine how a given program handles binary data when I know dd will at least not mess with it.
• realfinkployd 10y ago
  "Legend has it that the intended name, “cc”, was taken by the C compiler, so the letters were shifted by one to give “dd”." Legend is wrong, this clearly derived from the mainframe JCL DD command. This is also why the syntax is so non unix-like. https://en.wikipedia.org/wiki/Job_Control_Language#In-stream_input https://en.wikipedia.org/wiki/Job_Control_Language#In-stream...
• ScottBurson 10y ago
  My favorite thing to do with 'dd' is to break up multi-gigabyte log files into, say, 500MB chunks, so I can easily view and search them in XEmacs (this is 'csh' syntax as I use 'tcsh'): foreach i (0 1 2 3 [...]) dd <big.log >big.log.$i bs=500m count=1 skip=$i end (XEmacs is very fast at reading large files but has a 1GB limit.)
  • abbeyj 10y ago
    How about using split -db 500M big.log big.log. ?
    • ScottBurson 10y ago
      Oh wow, I never knew about that. Thanks!
  • deleted 10y ago
    [deleted]
• bradknowles 10y ago
  IIRC, there was a windowing system called "W", which pre-dated X. However, it was crude and there was good reason for wanting to replace it.
  • floatboth 10y ago
    Funny how the new windowing system is also "W"… (https://wayland.freedesktop.org https://wayland.freedesktop.org especially the logo)
• skipt 10y ago
  dd is for converting EBCDIC to ASCII and vice versa :) $ echo how now brown cow > text.ascii $ dd conv=ebcdic < text.ascii > text.ebcdic 0+1 records in 0+1 records out 18 bytes copied, 0.000261094 s, 68.9 kB/s $ od -xc text.ebcdic 0000000 9688 40a6 9695 40a6 9982 a696 4095 9683 210 226 246 @ 225 226 246 @ 202 231 226 246 225 @ 203 226 0000020 25a6 246 % 0000022 $ dd conv=ascii < text.ebcdic how now brown cow 0+1 records in 0+1 records out 18 bytes copied, 0.000140529 s, 128 kB/s
• skipt 10y ago
  dd is for converting EBCDIC to ASCII and vice versa :) $ echo how now brown cow > text.ascii $ dd conv=ebcdic < text.ascii > text.ebcdic 0+1 records in 0+1 records out 18 bytes copied, 0.000261094 s, 68.9 kB/s $ od -xc text.ebcdic 0000000 9688 40a6 9695 40a6 9982 a696 4095 9683 210 226 246 @ 225 226 246 @ 202 231 226 246 225 @ 203 226 0000020 25a6 246 % 0000022 $ dd conv=ascii < text.ebcdic how now brown cow 0+1 records in 0+1 records out 18 bytes copied, 0.000140529 s, 128 kB/s
• vermaden 10y ago
  > How do you combine dd with gzip? # dd < /dev/ada0 bs=8m | gzip -c -9 > /mnt/file.raw.gz > How do you use pv if the source is raw device? # dd < /dev/ada0 bs=8m | pv | dd > /dev/ada1 bs=8m > How do you dd over ssh? # dd < /dev/ada0 bs=8m | gzip -9 | pv | ssh user@host 'dd > /dev/da1 bs=8m' > This belief can make simple tasks complicated. As master Dennis Ritchie once said - "UNIX is very simple, it just needs a genius to understand its simplicity."
  • vacri 10y ago
    Did you really want an un-gzip'd copy on your target in that last one?
• YeGoblynQueenne 10y ago
  >> The reason why people started using it in the first place is that it does exactly what it’s told, no more and no less. Oh yes indeed. And for this exact reason, "dd" is commonly backronymed to "Data Death" (or, indeed, "Disk Death").
• koala_man 10y ago
  Hello! I'm the author of this article. Sorry for the confusion: dd is still a very useful tool for copying disks. The point is that you should not feel like you have to shoehorn dd into any command dealing with disks, because only dd is somehow "raw" or "low level" enough to access them. For example, if you have a command like this: pv file1 | gzip | ssh host "gzip -d > file2" and you want to make it work with disks, just replace file1 and file2 with /dev/yourdisks and it's fine.
• juliangoldsmith 10y ago
  The statement cp myfile.iso /dev/sdb is simply wrong. That will overwrite the device node for your flash drive with the ISO, instead of writing the data to the drive.
• fuzzfactor 10y ago
  "Not a disk-writing tool?!?" Who knew? Now we have pretty good confirmation that this little utility is performing way more effectively than designed. Software itself could probably benefit from some of the same approaches that allowed this little computer program to outperform its original design goals, in ways that might not have been anticipated.