tree cd0e464836c37b675ed57e9a0ff89522e031748b
parent 2b301307f63dbecf06d91f58f003c7fb7addee24
author Martin K. Petersen <martin.petersen@oracle.com> 1236612811 -0400
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1237340632 -0400

[SCSI] sd: Make revalidate less chatty

sd_revalidate ends up being called several times during device setup.
With this patch we print everything during the first scan.  Subsequent
invocations will only print a message if the parameter in question has
actually changed (LUN capacity has increased, etc.).

Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
