tree 3edc28a8f84a84b9893813e047b805e2915528c5
parent 96bcc722c47d07b6fd05c9d0cb3ab8ea5574c5b1
author FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp> 1238772942 +0900
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1240843091 -0500

[SCSI] sg: return EFAULT for an invalid user address

blk_rq_unmap_user() returns EFAULT if a program passes an invalid
address to kernel (the kernel fails to copy data to user space). sg
needs to pass the returned value to user space instead of ignoring
it. Before the block layer conversion, sg returns EFAULT
properly. This restores the old behavior.

Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
Acked-by: Douglas Gilbert <dgilbert@interlog.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
