[Bug-ddrescue] New features patch now available

[Scott D]

I have released a features patch for ddrescue that I have been working 
on. It is available on my ddrutility page on sourceforge. Its purpose is 
to add a few new options for more control over certain things.

http://sourceforge.net/projects/ddrutility/files/ddrescue%20patches/

New options are:
--no-reverse-pass          do not switch direction for each pass (for 
those that want it, as it really does not help any and is mostly useless 
in my opinion)
--skip-on-first-err        start skipping on first error (helpful if 
errors are spread out too far to trigger skipping normally)
--trim-sequentially        don't trim small blocks first (less head 
movement)
--split-sequentially       don't split large blocks first (much less 
head movement)

The current patch is for the latest ddrescue release 1.18.1, and won't 
work on other versions.

Please make sure to read the readme file included in the patch in its 
entirety to see what it does and does not do.

There is also a section in the readme of strategies for data recovery.  
Hopefully it is helpful. It could always use to be expanded upon, and 
corrected if necessary.


************************************************************
Now let's look at some practical uses of the options of ddrescue. Some 
of this information is based on my benchmarking tests. But first we need 
to understand how the data is stored on the platters.

A typical disk can have between 1 and 4 platters, and 2 to 8 heads. The 
data is actually stored in small groups that could be 100MB or less up 
to 1GB or more, depending on the drive. So for example if the group size 
was exactly 100MB, then on a 2 platter 4 head drive the first 0-100MB 
would be read from head 1, 100-200MB from head 2, 200-300MB from head 3, 
300-400MB from head 4. Then the next 400-500MB would go back to head 1, 
and so on. So as you see, the data is not all in strait line order.

There are normally two basic hard drive errors (ones that can be worked 
with using ddrescue). The first is a damaged area on one of the 
platters. The size of this error can vary, and the error can span 
multiple groups on the head. A damaged platter can also cause head 
damage (or further head damage) when the head passes over it. The less 
time spent in this area the better.

The second common error is a weak or damaged head. This will affect 
reads across the entire disk. I have seen more than one logfile that 
shows this. There are usually many small errors spaced a bit apart, and 
usually there is also somewhat of a pattern (that can only be seen by 
examining the logfile). You can use ddrescueview to see a visual 
reference of the errors caused by the bad head, and you can also use it 
to get an idea of the group size of the head.


So how do we best handle these errors with ddrescue?

Fully sequential read: For those who want absolute control, use the 
following normal options to get a totally sequential read in one pass, 
'--skip-size=0 --cluster-size=1'. This turns off skipping, and also 
makes ddrescue read one sector at a time. The disk is read in order from 
start to finish with no trimming or splitting, and no areas are tried 
twice. This can actually speed up the overall time of a recovery over 
using the default options if there are a lot of small errors. The 
downside to this is that reads of the good areas are slow due to the 
small read size. And you don't get the most good data first, so if the 
drive gets worse as you progress you risk loosing more data. As stated, 
this is for those who want the absolute control, and is not normally 
recommended.


Skip out fast: This method involves using the --skip-size option to set 
both the skip size and the max skip size. By default the skip size is 
64KiB and the max is either 1GiB or 1% of the drive size, whichever is 
smaller. So for example if we use ddrescueview (or examine the logfile) 
for the error pattern early on in the rescue to get an estimate that the 
data group size is about 100MB, then we might want to go with something 
like a 5Mi skip size with a 10Mi max ("--skip-size=5Mi,10Mi"). We want 
to keep skipping out of the bad head as fast as possible on the first 
pass, but don't want to skip way too far out if we can help it. The 
untried area that is skipped out away from the bad head will get 
processed by the reverse pass (a good benefit of the reverse pass). This 
means that we can skip out big and fast if wanted, but understand that 
reverse reads are usually slower than forward reads. And you also don't 
want to allow skipping more than half way to the next bad read, or good 
data could be missed on the reverse pass and would have to wait for the 
third no-skip pass. The skip out fast method will also work for a 
damaged area on the platter, although you will likely not know in 
advance the group size. The big benefit of this method is getting the 
most good data as fast as possible before working on the problem areas.
************************************************************

Scott