tree d1d06940e8f128804529386ccea9c0757e61db0f
parent 2afa19a9377ca61b9489e44bf50029574fbe63be
author Anirban Chakraborty <anirban.chakraborty@qlogic.com> 1239082421 -0700
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1242858068 -0500

[SCSI] qla2xxx: Add CPU affinity support.

Set the module parameter ql2xmultique_tag to 1 to enable this
feature. In this mode, the total number of response queues
created is equal to the number of online cpus. Turning the block
layer's rq_affinity mode on enables requests to be routed to the
proper cpu and at the same time it enables completion of the IO
in a response queue that is affined to the cpu in the request
path.

Signed-off-by: Anirban Chakraborty <anirban.chakraborty@qlogic.com>
Signed-off-by: Andrew Vasquez <andrew.vasquez@qlogic.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
