Re: Silicon Image 3112A SATA trouble

Jeff Garzik
2003-11-30T19:04:55Z

Jens Axboe wrote:
> On Sun, Nov 30 2003, Jeff Garzik wrote:
>>Current non-errata case: 1 taskfile, 1 completion func call
>>Upcoming errata solution: 2 taskfiles, 1 completion func call
>>Your errata suggestion seems to be: 2 taskfiles, 2 completion func calls
>>
>>That's obviously more work and more code for the errata case.
>
>
> I don't see why, it's exactly 2 x non-errata case.

Since the hardware request API is (and must be) completely decoupled
from struct request API, I can achieve 1.5 x non-errata case.

>>And for the non-errata case, partial completions don't make any sense at
>>all.
>
>
> Of course, you would always complete these fully. But having partial
> completions at the lowest layer gives it to you for free. non-errata
> case uses the exact same path, it just happens to complete 100% of the
> request all the time.

[editor's note: I wonder if I've broken a grammar rule using so many
"non"s in a single email]

If I completely ignore partial completions on the normal [non-error]
paths, the current errata and non-errata struct request completion paths
would be exactly the same. Only the error path would differ. The
lowest [hardware req API] layer's request granularity is a single
taskfile, so it will never know about partial completions.

>>>>WRT error handling, according to ATA specs I can look at the error
>>>>information to determine how much of the request, if any, completed
>>>>successfully. (dunno if this is also doable on ATAPI) That's why
>>>>partial completions in the error path make sense to me.
>>>
>>>
>>>... so if you do partial completions in the normal paths (or rather
>>>allow them), error handling will be simpler. And we all know where the
>>
>>In the common non-errata case, there is never a partial completion.
>
>
> Right. But as you mention, error handling is a partial completion by
> nature (almost always).

Agreed. Just in case I transposed a word or something, I wish to
clarify: both errata and error paths are almost always partial completions.

However... for the case where both errata taskfiles completely
_successfully_, it is better have only 1 completion on the hot path (the
"1.5 x" mentioned above). Particularly considering that errata
taskfiles are contiguous, and the second taskfile will completely fairly
quickly after the first...

The slow, error path is a whole different matter. Ignoring partial
completions in the normal path keeps the error path simple, for errata
and non-errata cases. Handling partial completions in the error code,
for both errata and non-errata cases, is definitely something I want to
do in the future.

>>>hard and stupid bugs are - the basically never tested error handling.
>>
>>I have :) libata error handling is stupid and simple, but it's also
>>solid and easy to verify. Yet another path to be honed, of course :)
>
>
> That's good :). But even given that, error handling is usually the less
> tested path (by far). I do commend your 'keep it simple', I think that's
> key there.

As a tangent, I'm hoping to convince some drive manufacturers (under NDA
most likely, unfortunately) to provide special drive firmwares that will
simulate read and write errors. i.e. fault injection.

Jeff