tree b02cba45dbe7a69a7c9c24aa815bd3e82fde7725
parent ad337591f4fd20de6a0ca03d6715267a5c1d2b16
author James Bottomley <James.Bottomley@HansenPartnership.com> 1217349505 -0500
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1217431316 -0500

[SCSI] ses: fix VPD inquiry overrun

There are a few kerneloops.org reports like this one:

http://www.kerneloops.org/search.php?search=ses_match_to_enclosure

That seem to imply we're running off the end of the VPD inquiry data
(although at 512 bytes, it should be long enough for just about
anything).  we should be using correctly sized buffers anyway, so put
those in and hope this oops goes away.

Cc: Stable Tree <stable@kernel.org>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
