tree 45d6f25301e41ff9323f2eee20fce6ae341cda7f
parent d7f305e9a08040649b0800245e67708df58cdb55
author Chandra Seetharaman <sekharan@us.ibm.com> 1211591800 -0700
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1216131403 -0500

[SCSI] scsi_dh: fix kconfig related build errors

Do not automatically "select" SCSI_DH for dm-multipath. If SCSI_DH
doesn't exist,just do not allow  hardware handlers to be used.

Handle SCSI_DH being a module also. Make sure it doesn't allow DM_MULTIPATH
to be compiled in when SCSI_DH is a module.

[jejb: added comment for Kconfig syntax]
Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Reported-by: Randy Dunlap <randy.dunlap@oracle.com>
Reported-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
