tree 5aaecdc97e807dc9be911243604c9b9e0f22bde6
parent 465ff3185e0cb76d46137335a4d21d0d9d3ac8a2
author James Bottomley <James.Bottomley@HansenPartnership.com> 1201031028 -0600
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1201109274 -0600

[SCSI] libata: fix corruption induced by relaxed DMA alignment in SCSI

Hugh Dickens noticed that SMART commands issued from user space can
end up corupting memory.  The problem occurs if the buffer used to
read data spans two pages.  The reason is that the PIO sector routines
in libata are expecting physically contiguous pages when they do
sector operations, so the left overs on the second page go into the
next physically adjacent page rather than the next page in the sg
mapping.

Fix this by enforcing strict 512 byte alignment on all buffers from
userspace.

Acked-by: Hugh Dickins <hugh@veritas.com>
Acked-by: Jeff Garzik <jeff@garzik.org>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
