tree 6f4b738aa1dfc422087a0b05ebde4388cf84a3f0
parent 5a2537959fa8781012e8c286fc1614e0f6991327
author Mike Christie <michaelc@cs.wisc.edu> 1242255458 -0500
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1243111449 -0500

[SCSI] iscsi: pass ep connect shost

When we create the tcp/ip connection by calling ep_connect, we currently
just go by the routing table info.

I think there are two problems with this.

1. Some drivers do not have access to a routing table. Some drivers like
qla4xxx do not even know about other ports.

2. If you have two initiator ports on the same subnet, the user may have
set things up so that session1 was supposed to be run through port1. and
session2 was supposed to be run through port2. It looks like we could
end with both sessions going through one of the ports.

Fixes for cxgb3i from Karen Xie.

Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
