blob: 2aff8814f2c5b86791dd3e7e6a21ca583851540f [file] [log] [blame]
Roland Dreieraef9ec32005-11-02 14:07:13 -08001/*
2 * Copyright (c) 2005 Cisco Systems. All rights reserved.
3 *
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
9 *
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
12 * conditions are met:
13 *
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer.
17 *
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 * SOFTWARE.
Roland Dreieraef9ec32005-11-02 14:07:13 -080031 */
32
Roland Dreieraef9ec32005-11-02 14:07:13 -080033#include <linux/module.h>
34#include <linux/init.h>
35#include <linux/slab.h>
36#include <linux/err.h>
37#include <linux/string.h>
38#include <linux/parser.h>
39#include <linux/random.h>
Tim Schmielaude259682006-01-08 01:02:05 -080040#include <linux/jiffies.h>
Roland Dreieraef9ec32005-11-02 14:07:13 -080041
42#include <asm/atomic.h>
43
44#include <scsi/scsi.h>
45#include <scsi/scsi_device.h>
46#include <scsi/scsi_dbg.h>
47#include <scsi/srp.h>
FUJITA Tomonori32368222007-06-27 16:33:12 +090048#include <scsi/scsi_transport_srp.h>
Roland Dreieraef9ec32005-11-02 14:07:13 -080049
Roland Dreieraef9ec32005-11-02 14:07:13 -080050#include "ib_srp.h"
51
52#define DRV_NAME "ib_srp"
53#define PFX DRV_NAME ": "
54#define DRV_VERSION "0.2"
55#define DRV_RELDATE "November 1, 2005"
56
57MODULE_AUTHOR("Roland Dreier");
58MODULE_DESCRIPTION("InfiniBand SCSI RDMA Protocol initiator "
59 "v" DRV_VERSION " (" DRV_RELDATE ")");
60MODULE_LICENSE("Dual BSD/GPL");
61
Vu Pham74b0a152006-06-17 20:37:32 -070062static int srp_sg_tablesize = SRP_DEF_SG_TABLESIZE;
63static int srp_max_iu_len;
64
65module_param(srp_sg_tablesize, int, 0444);
66MODULE_PARM_DESC(srp_sg_tablesize,
David Dillow1e89a192008-04-16 21:01:12 -070067 "Max number of gather/scatter entries per I/O (default is 12, max 255)");
Vu Pham74b0a152006-06-17 20:37:32 -070068
Roland Dreieraef9ec32005-11-02 14:07:13 -080069static int topspin_workarounds = 1;
70
71module_param(topspin_workarounds, int, 0444);
72MODULE_PARM_DESC(topspin_workarounds,
73 "Enable workarounds for Topspin/Cisco SRP target bugs if != 0");
74
Ishai Rabinovitz559ce8f2006-08-03 10:35:43 -070075static int mellanox_workarounds = 1;
76
77module_param(mellanox_workarounds, int, 0444);
78MODULE_PARM_DESC(mellanox_workarounds,
79 "Enable workarounds for Mellanox SRP target bugs if != 0");
80
Roland Dreieraef9ec32005-11-02 14:07:13 -080081static void srp_add_one(struct ib_device *device);
82static void srp_remove_one(struct ib_device *device);
Bart Van Assche9c03dc92010-02-02 19:23:54 +000083static void srp_recv_completion(struct ib_cq *cq, void *target_ptr);
84static void srp_send_completion(struct ib_cq *cq, void *target_ptr);
Roland Dreieraef9ec32005-11-02 14:07:13 -080085static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event);
86
FUJITA Tomonori32368222007-06-27 16:33:12 +090087static struct scsi_transport_template *ib_srp_transport_template;
88
Roland Dreieraef9ec32005-11-02 14:07:13 -080089static struct ib_client srp_client = {
90 .name = "srp",
91 .add = srp_add_one,
92 .remove = srp_remove_one
93};
94
Michael S. Tsirkinc1a0b232006-08-21 16:40:12 -070095static struct ib_sa_client srp_sa_client;
96
Roland Dreieraef9ec32005-11-02 14:07:13 -080097static inline struct srp_target_port *host_to_target(struct Scsi_Host *host)
98{
99 return (struct srp_target_port *) host->hostdata;
100}
101
102static const char *srp_target_info(struct Scsi_Host *host)
103{
104 return host_to_target(host)->target_name;
105}
106
Roland Dreier5d7cbfd2007-08-03 10:45:18 -0700107static int srp_target_is_topspin(struct srp_target_port *target)
108{
109 static const u8 topspin_oui[3] = { 0x00, 0x05, 0xad };
Raghava Kondapalli3d1ff482007-08-03 10:45:18 -0700110 static const u8 cisco_oui[3] = { 0x00, 0x1b, 0x0d };
Roland Dreier5d7cbfd2007-08-03 10:45:18 -0700111
112 return topspin_workarounds &&
Raghava Kondapalli3d1ff482007-08-03 10:45:18 -0700113 (!memcmp(&target->ioc_guid, topspin_oui, sizeof topspin_oui) ||
114 !memcmp(&target->ioc_guid, cisco_oui, sizeof cisco_oui));
Roland Dreier5d7cbfd2007-08-03 10:45:18 -0700115}
116
117static int srp_target_is_mellanox(struct srp_target_port *target)
118{
119 static const u8 mellanox_oui[3] = { 0x00, 0x02, 0xc9 };
120
121 return mellanox_workarounds &&
122 !memcmp(&target->ioc_guid, mellanox_oui, sizeof mellanox_oui);
123}
124
Roland Dreieraef9ec32005-11-02 14:07:13 -0800125static struct srp_iu *srp_alloc_iu(struct srp_host *host, size_t size,
126 gfp_t gfp_mask,
127 enum dma_data_direction direction)
128{
129 struct srp_iu *iu;
130
131 iu = kmalloc(sizeof *iu, gfp_mask);
132 if (!iu)
133 goto out;
134
135 iu->buf = kzalloc(size, gfp_mask);
136 if (!iu->buf)
137 goto out_free_iu;
138
Greg Kroah-Hartman05321932008-03-06 00:13:36 +0100139 iu->dma = ib_dma_map_single(host->srp_dev->dev, iu->buf, size,
140 direction);
141 if (ib_dma_mapping_error(host->srp_dev->dev, iu->dma))
Roland Dreieraef9ec32005-11-02 14:07:13 -0800142 goto out_free_buf;
143
144 iu->size = size;
145 iu->direction = direction;
146
147 return iu;
148
149out_free_buf:
150 kfree(iu->buf);
151out_free_iu:
152 kfree(iu);
153out:
154 return NULL;
155}
156
157static void srp_free_iu(struct srp_host *host, struct srp_iu *iu)
158{
159 if (!iu)
160 return;
161
Greg Kroah-Hartman05321932008-03-06 00:13:36 +0100162 ib_dma_unmap_single(host->srp_dev->dev, iu->dma, iu->size,
163 iu->direction);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800164 kfree(iu->buf);
165 kfree(iu);
166}
167
168static void srp_qp_event(struct ib_event *event, void *context)
169{
170 printk(KERN_ERR PFX "QP event %d\n", event->event);
171}
172
173static int srp_init_qp(struct srp_target_port *target,
174 struct ib_qp *qp)
175{
176 struct ib_qp_attr *attr;
177 int ret;
178
179 attr = kmalloc(sizeof *attr, GFP_KERNEL);
180 if (!attr)
181 return -ENOMEM;
182
Roland Dreier969a60f2008-07-14 23:48:43 -0700183 ret = ib_find_pkey(target->srp_host->srp_dev->dev,
184 target->srp_host->port,
185 be16_to_cpu(target->path.pkey),
186 &attr->pkey_index);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800187 if (ret)
188 goto out;
189
190 attr->qp_state = IB_QPS_INIT;
191 attr->qp_access_flags = (IB_ACCESS_REMOTE_READ |
192 IB_ACCESS_REMOTE_WRITE);
193 attr->port_num = target->srp_host->port;
194
195 ret = ib_modify_qp(qp, attr,
196 IB_QP_STATE |
197 IB_QP_PKEY_INDEX |
198 IB_QP_ACCESS_FLAGS |
199 IB_QP_PORT);
200
201out:
202 kfree(attr);
203 return ret;
204}
205
David Dillow9fe4bcf2008-01-08 17:08:52 -0500206static int srp_new_cm_id(struct srp_target_port *target)
207{
208 struct ib_cm_id *new_cm_id;
209
Greg Kroah-Hartman05321932008-03-06 00:13:36 +0100210 new_cm_id = ib_create_cm_id(target->srp_host->srp_dev->dev,
David Dillow9fe4bcf2008-01-08 17:08:52 -0500211 srp_cm_handler, target);
212 if (IS_ERR(new_cm_id))
213 return PTR_ERR(new_cm_id);
214
215 if (target->cm_id)
216 ib_destroy_cm_id(target->cm_id);
217 target->cm_id = new_cm_id;
218
219 return 0;
220}
221
Roland Dreieraef9ec32005-11-02 14:07:13 -0800222static int srp_create_target_ib(struct srp_target_port *target)
223{
224 struct ib_qp_init_attr *init_attr;
225 int ret;
226
227 init_attr = kzalloc(sizeof *init_attr, GFP_KERNEL);
228 if (!init_attr)
229 return -ENOMEM;
230
Bart Van Assche9c03dc92010-02-02 19:23:54 +0000231 target->recv_cq = ib_create_cq(target->srp_host->srp_dev->dev,
232 srp_recv_completion, NULL, target, SRP_RQ_SIZE, 0);
233 if (IS_ERR(target->recv_cq)) {
234 ret = PTR_ERR(target->recv_cq);
Roland Dreierda9d2f02010-02-24 15:07:59 -0800235 goto err;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800236 }
237
Bart Van Assche9c03dc92010-02-02 19:23:54 +0000238 target->send_cq = ib_create_cq(target->srp_host->srp_dev->dev,
239 srp_send_completion, NULL, target, SRP_SQ_SIZE, 0);
240 if (IS_ERR(target->send_cq)) {
241 ret = PTR_ERR(target->send_cq);
Roland Dreierda9d2f02010-02-24 15:07:59 -0800242 goto err_recv_cq;
Bart Van Assche9c03dc92010-02-02 19:23:54 +0000243 }
244
245 ib_req_notify_cq(target->recv_cq, IB_CQ_NEXT_COMP);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800246
247 init_attr->event_handler = srp_qp_event;
248 init_attr->cap.max_send_wr = SRP_SQ_SIZE;
249 init_attr->cap.max_recv_wr = SRP_RQ_SIZE;
250 init_attr->cap.max_recv_sge = 1;
251 init_attr->cap.max_send_sge = 1;
252 init_attr->sq_sig_type = IB_SIGNAL_ALL_WR;
253 init_attr->qp_type = IB_QPT_RC;
Bart Van Assche9c03dc92010-02-02 19:23:54 +0000254 init_attr->send_cq = target->send_cq;
255 init_attr->recv_cq = target->recv_cq;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800256
Greg Kroah-Hartman05321932008-03-06 00:13:36 +0100257 target->qp = ib_create_qp(target->srp_host->srp_dev->pd, init_attr);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800258 if (IS_ERR(target->qp)) {
259 ret = PTR_ERR(target->qp);
Roland Dreierda9d2f02010-02-24 15:07:59 -0800260 goto err_send_cq;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800261 }
262
263 ret = srp_init_qp(target, target->qp);
Roland Dreierda9d2f02010-02-24 15:07:59 -0800264 if (ret)
265 goto err_qp;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800266
Roland Dreierda9d2f02010-02-24 15:07:59 -0800267 kfree(init_attr);
268 return 0;
269
270err_qp:
271 ib_destroy_qp(target->qp);
272
273err_send_cq:
274 ib_destroy_cq(target->send_cq);
275
276err_recv_cq:
277 ib_destroy_cq(target->recv_cq);
278
279err:
Roland Dreieraef9ec32005-11-02 14:07:13 -0800280 kfree(init_attr);
281 return ret;
282}
283
284static void srp_free_target_ib(struct srp_target_port *target)
285{
286 int i;
287
288 ib_destroy_qp(target->qp);
Bart Van Assche9c03dc92010-02-02 19:23:54 +0000289 ib_destroy_cq(target->send_cq);
290 ib_destroy_cq(target->recv_cq);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800291
292 for (i = 0; i < SRP_RQ_SIZE; ++i)
293 srp_free_iu(target->srp_host, target->rx_ring[i]);
Bart Van Asschedd5e6e32010-08-30 19:27:20 +0000294 for (i = 0; i < SRP_SQ_SIZE; ++i)
Roland Dreieraef9ec32005-11-02 14:07:13 -0800295 srp_free_iu(target->srp_host, target->tx_ring[i]);
296}
297
298static void srp_path_rec_completion(int status,
299 struct ib_sa_path_rec *pathrec,
300 void *target_ptr)
301{
302 struct srp_target_port *target = target_ptr;
303
304 target->status = status;
305 if (status)
David Dillow7aa54bd2008-01-07 18:23:41 -0500306 shost_printk(KERN_ERR, target->scsi_host,
307 PFX "Got failed path rec status %d\n", status);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800308 else
309 target->path = *pathrec;
310 complete(&target->done);
311}
312
313static int srp_lookup_path(struct srp_target_port *target)
314{
315 target->path.numb_path = 1;
316
317 init_completion(&target->done);
318
Michael S. Tsirkinc1a0b232006-08-21 16:40:12 -0700319 target->path_query_id = ib_sa_path_rec_get(&srp_sa_client,
Greg Kroah-Hartman05321932008-03-06 00:13:36 +0100320 target->srp_host->srp_dev->dev,
Roland Dreieraef9ec32005-11-02 14:07:13 -0800321 target->srp_host->port,
322 &target->path,
Sean Hefty247e0202007-08-08 15:51:18 -0700323 IB_SA_PATH_REC_SERVICE_ID |
Roland Dreieraef9ec32005-11-02 14:07:13 -0800324 IB_SA_PATH_REC_DGID |
325 IB_SA_PATH_REC_SGID |
326 IB_SA_PATH_REC_NUMB_PATH |
327 IB_SA_PATH_REC_PKEY,
328 SRP_PATH_REC_TIMEOUT_MS,
329 GFP_KERNEL,
330 srp_path_rec_completion,
331 target, &target->path_query);
332 if (target->path_query_id < 0)
333 return target->path_query_id;
334
335 wait_for_completion(&target->done);
336
337 if (target->status < 0)
David Dillow7aa54bd2008-01-07 18:23:41 -0500338 shost_printk(KERN_WARNING, target->scsi_host,
339 PFX "Path record query failed\n");
Roland Dreieraef9ec32005-11-02 14:07:13 -0800340
341 return target->status;
342}
343
344static int srp_send_req(struct srp_target_port *target)
345{
346 struct {
347 struct ib_cm_req_param param;
348 struct srp_login_req priv;
349 } *req = NULL;
350 int status;
351
352 req = kzalloc(sizeof *req, GFP_KERNEL);
353 if (!req)
354 return -ENOMEM;
355
356 req->param.primary_path = &target->path;
357 req->param.alternate_path = NULL;
358 req->param.service_id = target->service_id;
359 req->param.qp_num = target->qp->qp_num;
360 req->param.qp_type = target->qp->qp_type;
361 req->param.private_data = &req->priv;
362 req->param.private_data_len = sizeof req->priv;
363 req->param.flow_control = 1;
364
365 get_random_bytes(&req->param.starting_psn, 4);
366 req->param.starting_psn &= 0xffffff;
367
368 /*
369 * Pick some arbitrary defaults here; we could make these
370 * module parameters if anyone cared about setting them.
371 */
372 req->param.responder_resources = 4;
373 req->param.remote_cm_response_timeout = 20;
374 req->param.local_cm_response_timeout = 20;
375 req->param.retry_count = 7;
376 req->param.rnr_retry_count = 7;
377 req->param.max_cm_retries = 15;
378
379 req->priv.opcode = SRP_LOGIN_REQ;
380 req->priv.tag = 0;
Vu Pham74b0a152006-06-17 20:37:32 -0700381 req->priv.req_it_iu_len = cpu_to_be32(srp_max_iu_len);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800382 req->priv.req_buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT |
383 SRP_BUF_FORMAT_INDIRECT);
Ramachandra K0c0450db2006-06-17 20:37:38 -0700384 /*
Roland Dreier3cd96562006-09-22 15:22:46 -0700385 * In the published SRP specification (draft rev. 16a), the
Ramachandra K0c0450db2006-06-17 20:37:38 -0700386 * port identifier format is 8 bytes of ID extension followed
387 * by 8 bytes of GUID. Older drafts put the two halves in the
388 * opposite order, so that the GUID comes first.
389 *
390 * Targets conforming to these obsolete drafts can be
391 * recognized by the I/O Class they report.
392 */
393 if (target->io_class == SRP_REV10_IB_IO_CLASS) {
394 memcpy(req->priv.initiator_port_id,
Ishai Rabinovitz01cb9bc2006-10-04 15:28:56 +0200395 &target->path.sgid.global.interface_id, 8);
Ramachandra K0c0450db2006-06-17 20:37:38 -0700396 memcpy(req->priv.initiator_port_id + 8,
Ishai Rabinovitz01cb9bc2006-10-04 15:28:56 +0200397 &target->initiator_ext, 8);
Ramachandra K0c0450db2006-06-17 20:37:38 -0700398 memcpy(req->priv.target_port_id, &target->ioc_guid, 8);
399 memcpy(req->priv.target_port_id + 8, &target->id_ext, 8);
400 } else {
401 memcpy(req->priv.initiator_port_id,
Ishai Rabinovitz01cb9bc2006-10-04 15:28:56 +0200402 &target->initiator_ext, 8);
403 memcpy(req->priv.initiator_port_id + 8,
404 &target->path.sgid.global.interface_id, 8);
Ramachandra K0c0450db2006-06-17 20:37:38 -0700405 memcpy(req->priv.target_port_id, &target->id_ext, 8);
406 memcpy(req->priv.target_port_id + 8, &target->ioc_guid, 8);
407 }
408
Roland Dreieraef9ec32005-11-02 14:07:13 -0800409 /*
410 * Topspin/Cisco SRP targets will reject our login unless we
Ishai Rabinovitz01cb9bc2006-10-04 15:28:56 +0200411 * zero out the first 8 bytes of our initiator port ID and set
412 * the second 8 bytes to the local node GUID.
Roland Dreieraef9ec32005-11-02 14:07:13 -0800413 */
Roland Dreier5d7cbfd2007-08-03 10:45:18 -0700414 if (srp_target_is_topspin(target)) {
David Dillow7aa54bd2008-01-07 18:23:41 -0500415 shost_printk(KERN_DEBUG, target->scsi_host,
416 PFX "Topspin/Cisco initiator port ID workaround "
417 "activated for target GUID %016llx\n",
418 (unsigned long long) be64_to_cpu(target->ioc_guid));
Roland Dreieraef9ec32005-11-02 14:07:13 -0800419 memset(req->priv.initiator_port_id, 0, 8);
Ishai Rabinovitz01cb9bc2006-10-04 15:28:56 +0200420 memcpy(req->priv.initiator_port_id + 8,
Greg Kroah-Hartman05321932008-03-06 00:13:36 +0100421 &target->srp_host->srp_dev->dev->node_guid, 8);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800422 }
Roland Dreieraef9ec32005-11-02 14:07:13 -0800423
424 status = ib_send_cm_req(target->cm_id, &req->param);
425
426 kfree(req);
427
428 return status;
429}
430
431static void srp_disconnect_target(struct srp_target_port *target)
432{
433 /* XXX should send SRP_I_LOGOUT request */
434
435 init_completion(&target->done);
Roland Dreiere6581052006-05-17 09:13:21 -0700436 if (ib_send_cm_dreq(target->cm_id, NULL, 0)) {
David Dillow7aa54bd2008-01-07 18:23:41 -0500437 shost_printk(KERN_DEBUG, target->scsi_host,
438 PFX "Sending CM DREQ failed\n");
Roland Dreiere6581052006-05-17 09:13:21 -0700439 return;
440 }
Roland Dreieraef9ec32005-11-02 14:07:13 -0800441 wait_for_completion(&target->done);
442}
443
Bart Van Assche9709f0e2010-11-26 13:13:06 -0500444static bool srp_change_state(struct srp_target_port *target,
445 enum srp_target_state old,
446 enum srp_target_state new)
447{
448 bool changed = false;
449
450 spin_lock_irq(target->scsi_host->host_lock);
451 if (target->state == old) {
452 target->state = new;
453 changed = true;
454 }
455 spin_unlock_irq(target->scsi_host->host_lock);
456 return changed;
457}
458
David Howellsc4028952006-11-22 14:57:56 +0000459static void srp_remove_work(struct work_struct *work)
Roland Dreieraef9ec32005-11-02 14:07:13 -0800460{
David Howellsc4028952006-11-22 14:57:56 +0000461 struct srp_target_port *target =
462 container_of(work, struct srp_target_port, work);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800463
Bart Van Assche9709f0e2010-11-26 13:13:06 -0500464 if (!srp_change_state(target, SRP_TARGET_DEAD, SRP_TARGET_REMOVED))
Roland Dreieraef9ec32005-11-02 14:07:13 -0800465 return;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800466
Matthew Wilcoxb3589fd2006-06-17 20:37:30 -0700467 spin_lock(&target->srp_host->target_lock);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800468 list_del(&target->list);
Matthew Wilcoxb3589fd2006-06-17 20:37:30 -0700469 spin_unlock(&target->srp_host->target_lock);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800470
FUJITA Tomonori32368222007-06-27 16:33:12 +0900471 srp_remove_host(target->scsi_host);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800472 scsi_remove_host(target->scsi_host);
473 ib_destroy_cm_id(target->cm_id);
474 srp_free_target_ib(target);
475 scsi_host_put(target->scsi_host);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800476}
477
478static int srp_connect_target(struct srp_target_port *target)
479{
David Dillow9fe4bcf2008-01-08 17:08:52 -0500480 int retries = 3;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800481 int ret;
482
483 ret = srp_lookup_path(target);
484 if (ret)
485 return ret;
486
487 while (1) {
488 init_completion(&target->done);
489 ret = srp_send_req(target);
490 if (ret)
491 return ret;
492 wait_for_completion(&target->done);
493
494 /*
495 * The CM event handling code will set status to
496 * SRP_PORT_REDIRECT if we get a port redirect REJ
497 * back, or SRP_DLID_REDIRECT if we get a lid/qp
498 * redirect REJ back.
499 */
500 switch (target->status) {
501 case 0:
502 return 0;
503
504 case SRP_PORT_REDIRECT:
505 ret = srp_lookup_path(target);
506 if (ret)
507 return ret;
508 break;
509
510 case SRP_DLID_REDIRECT:
511 break;
512
David Dillow9fe4bcf2008-01-08 17:08:52 -0500513 case SRP_STALE_CONN:
514 /* Our current CM id was stale, and is now in timewait.
515 * Try to reconnect with a new one.
516 */
517 if (!retries-- || srp_new_cm_id(target)) {
518 shost_printk(KERN_ERR, target->scsi_host, PFX
519 "giving up on stale connection\n");
520 target->status = -ECONNRESET;
521 return target->status;
522 }
523
524 shost_printk(KERN_ERR, target->scsi_host, PFX
525 "retrying stale connection\n");
526 break;
527
Roland Dreieraef9ec32005-11-02 14:07:13 -0800528 default:
529 return target->status;
530 }
531 }
532}
533
Roland Dreierd945e1d2006-05-09 10:50:28 -0700534static void srp_unmap_data(struct scsi_cmnd *scmnd,
535 struct srp_target_port *target,
536 struct srp_request *req)
537{
FUJITA Tomonoribb350d12007-05-26 02:28:25 +0900538 if (!scsi_sglist(scmnd) ||
Roland Dreierd945e1d2006-05-09 10:50:28 -0700539 (scmnd->sc_data_direction != DMA_TO_DEVICE &&
540 scmnd->sc_data_direction != DMA_FROM_DEVICE))
541 return;
542
Roland Dreierf5358a12006-06-17 20:37:29 -0700543 if (req->fmr) {
544 ib_fmr_pool_unmap(req->fmr);
545 req->fmr = NULL;
546 }
547
Greg Kroah-Hartman05321932008-03-06 00:13:36 +0100548 ib_dma_unmap_sg(target->srp_host->srp_dev->dev, scsi_sglist(scmnd),
FUJITA Tomonoribb350d12007-05-26 02:28:25 +0900549 scsi_sg_count(scmnd), scmnd->sc_data_direction);
Roland Dreierd945e1d2006-05-09 10:50:28 -0700550}
551
Ishai Rabinovitz526b4ca2006-06-17 20:37:38 -0700552static void srp_remove_req(struct srp_target_port *target, struct srp_request *req)
553{
554 srp_unmap_data(req->scmnd, target, req);
David Dillowf8b6e312010-11-26 13:02:21 -0500555 req->scmnd = NULL;
Bart Van Assche536ae142010-11-26 13:58:27 -0500556 list_add_tail(&req->list, &target->free_reqs);
Ishai Rabinovitz526b4ca2006-06-17 20:37:38 -0700557}
558
559static void srp_reset_req(struct srp_target_port *target, struct srp_request *req)
560{
561 req->scmnd->result = DID_RESET << 16;
562 req->scmnd->scsi_done(req->scmnd);
563 srp_remove_req(target, req);
564}
565
Roland Dreieraef9ec32005-11-02 14:07:13 -0800566static int srp_reconnect_target(struct srp_target_port *target)
567{
Roland Dreieraef9ec32005-11-02 14:07:13 -0800568 struct ib_qp_attr qp_attr;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800569 struct ib_wc wc;
Bart Van Asschedcb4cb82010-11-26 13:22:48 -0500570 int i, ret;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800571
Bart Van Assche9709f0e2010-11-26 13:13:06 -0500572 if (!srp_change_state(target, SRP_TARGET_LIVE, SRP_TARGET_CONNECTING))
Roland Dreieraef9ec32005-11-02 14:07:13 -0800573 return -EAGAIN;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800574
575 srp_disconnect_target(target);
576 /*
577 * Now get a new local CM ID so that we avoid confusing the
578 * target in case things are really fouled up.
579 */
David Dillow9fe4bcf2008-01-08 17:08:52 -0500580 ret = srp_new_cm_id(target);
581 if (ret)
Roland Dreieraef9ec32005-11-02 14:07:13 -0800582 goto err;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800583
584 qp_attr.qp_state = IB_QPS_RESET;
585 ret = ib_modify_qp(target->qp, &qp_attr, IB_QP_STATE);
586 if (ret)
587 goto err;
588
589 ret = srp_init_qp(target, target->qp);
590 if (ret)
591 goto err;
592
Bart Van Assche9c03dc92010-02-02 19:23:54 +0000593 while (ib_poll_cq(target->recv_cq, 1, &wc) > 0)
594 ; /* nothing */
595 while (ib_poll_cq(target->send_cq, 1, &wc) > 0)
Roland Dreieraef9ec32005-11-02 14:07:13 -0800596 ; /* nothing */
597
Ishai Rabinovitzd916a8f2006-07-25 19:54:09 +0300598 spin_lock_irq(target->scsi_host->host_lock);
Bart Van Assche536ae142010-11-26 13:58:27 -0500599 for (i = 0; i < SRP_CMD_SQ_SIZE; ++i) {
600 struct srp_request *req = &target->req_ring[i];
601 if (req->scmnd)
602 srp_reset_req(target, req);
603 }
Ishai Rabinovitzd916a8f2006-07-25 19:54:09 +0300604 spin_unlock_irq(target->scsi_host->host_lock);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800605
Bart Van Assche536ae142010-11-26 13:58:27 -0500606 INIT_LIST_HEAD(&target->free_tx);
Bart Van Asschedcb4cb82010-11-26 13:22:48 -0500607 for (i = 0; i < SRP_SQ_SIZE; ++i)
Bart Van Assche536ae142010-11-26 13:58:27 -0500608 list_add(&target->tx_ring[i]->list, &target->free_tx);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800609
Ishai Rabinovitz1033ff62007-01-16 17:26:22 +0200610 target->qp_in_error = 0;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800611 ret = srp_connect_target(target);
612 if (ret)
613 goto err;
614
Bart Van Assche9709f0e2010-11-26 13:13:06 -0500615 if (!srp_change_state(target, SRP_TARGET_CONNECTING, SRP_TARGET_LIVE))
Roland Dreieraef9ec32005-11-02 14:07:13 -0800616 ret = -EAGAIN;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800617
618 return ret;
619
620err:
David Dillow7aa54bd2008-01-07 18:23:41 -0500621 shost_printk(KERN_ERR, target->scsi_host,
622 PFX "reconnect failed (%d), removing target port.\n", ret);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800623
624 /*
625 * We couldn't reconnect, so kill our target port off.
Bart Van Assche9709f0e2010-11-26 13:13:06 -0500626 * However, we have to defer the real removal because we
627 * are in the context of the SCSI error handler now, which
628 * will deadlock if we call scsi_remove_host().
629 *
630 * Schedule our work inside the lock to avoid a race with
631 * the flush_scheduled_work() in srp_remove_one().
Roland Dreieraef9ec32005-11-02 14:07:13 -0800632 */
633 spin_lock_irq(target->scsi_host->host_lock);
634 if (target->state == SRP_TARGET_CONNECTING) {
635 target->state = SRP_TARGET_DEAD;
David Howellsc4028952006-11-22 14:57:56 +0000636 INIT_WORK(&target->work, srp_remove_work);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800637 schedule_work(&target->work);
638 }
639 spin_unlock_irq(target->scsi_host->host_lock);
640
641 return ret;
642}
643
Ishai Rabinovitz559ce8f2006-08-03 10:35:43 -0700644static int srp_map_fmr(struct srp_target_port *target, struct scatterlist *scat,
Roland Dreierf5358a12006-06-17 20:37:29 -0700645 int sg_cnt, struct srp_request *req,
646 struct srp_direct_buf *buf)
647{
648 u64 io_addr = 0;
649 u64 *dma_pages;
650 u32 len;
651 int page_cnt;
652 int i, j;
653 int ret;
Greg Kroah-Hartman05321932008-03-06 00:13:36 +0100654 struct srp_device *dev = target->srp_host->srp_dev;
Ralph Campbell85507bc2006-12-12 14:30:55 -0800655 struct ib_device *ibdev = dev->dev;
FUJITA Tomonoribb350d12007-05-26 02:28:25 +0900656 struct scatterlist *sg;
Roland Dreierf5358a12006-06-17 20:37:29 -0700657
658 if (!dev->fmr_pool)
659 return -ENODEV;
660
Roland Dreier5d7cbfd2007-08-03 10:45:18 -0700661 if (srp_target_is_mellanox(target) &&
662 (ib_sg_dma_address(ibdev, &scat[0]) & ~dev->fmr_page_mask))
Ishai Rabinovitz559ce8f2006-08-03 10:35:43 -0700663 return -EINVAL;
664
Roland Dreierf5358a12006-06-17 20:37:29 -0700665 len = page_cnt = 0;
FUJITA Tomonoribb350d12007-05-26 02:28:25 +0900666 scsi_for_each_sg(req->scmnd, sg, sg_cnt, i) {
667 unsigned int dma_len = ib_sg_dma_len(ibdev, sg);
Ralph Campbell85507bc2006-12-12 14:30:55 -0800668
FUJITA Tomonoribb350d12007-05-26 02:28:25 +0900669 if (ib_sg_dma_address(ibdev, sg) & ~dev->fmr_page_mask) {
Roland Dreierf5358a12006-06-17 20:37:29 -0700670 if (i > 0)
671 return -EINVAL;
672 else
673 ++page_cnt;
674 }
FUJITA Tomonoribb350d12007-05-26 02:28:25 +0900675 if ((ib_sg_dma_address(ibdev, sg) + dma_len) &
Roland Dreierf5358a12006-06-17 20:37:29 -0700676 ~dev->fmr_page_mask) {
677 if (i < sg_cnt - 1)
678 return -EINVAL;
679 else
680 ++page_cnt;
681 }
682
Ralph Campbell85507bc2006-12-12 14:30:55 -0800683 len += dma_len;
Roland Dreierf5358a12006-06-17 20:37:29 -0700684 }
685
686 page_cnt += len >> dev->fmr_page_shift;
687 if (page_cnt > SRP_FMR_SIZE)
688 return -ENOMEM;
689
690 dma_pages = kmalloc(sizeof (u64) * page_cnt, GFP_ATOMIC);
691 if (!dma_pages)
692 return -ENOMEM;
693
694 page_cnt = 0;
FUJITA Tomonoribb350d12007-05-26 02:28:25 +0900695 scsi_for_each_sg(req->scmnd, sg, sg_cnt, i) {
696 unsigned int dma_len = ib_sg_dma_len(ibdev, sg);
Ralph Campbell85507bc2006-12-12 14:30:55 -0800697
698 for (j = 0; j < dma_len; j += dev->fmr_page_size)
Roland Dreierf5358a12006-06-17 20:37:29 -0700699 dma_pages[page_cnt++] =
FUJITA Tomonoribb350d12007-05-26 02:28:25 +0900700 (ib_sg_dma_address(ibdev, sg) &
Ralph Campbell85507bc2006-12-12 14:30:55 -0800701 dev->fmr_page_mask) + j;
702 }
Roland Dreierf5358a12006-06-17 20:37:29 -0700703
704 req->fmr = ib_fmr_pool_map_phys(dev->fmr_pool,
Michael S. Tsirkinadfaa882006-07-14 00:23:55 -0700705 dma_pages, page_cnt, io_addr);
Roland Dreierf5358a12006-06-17 20:37:29 -0700706 if (IS_ERR(req->fmr)) {
707 ret = PTR_ERR(req->fmr);
Vu Pham6583eb32006-07-14 00:23:53 -0700708 req->fmr = NULL;
Roland Dreierf5358a12006-06-17 20:37:29 -0700709 goto out;
710 }
711
Ralph Campbell85507bc2006-12-12 14:30:55 -0800712 buf->va = cpu_to_be64(ib_sg_dma_address(ibdev, &scat[0]) &
713 ~dev->fmr_page_mask);
Roland Dreierf5358a12006-06-17 20:37:29 -0700714 buf->key = cpu_to_be32(req->fmr->fmr->rkey);
715 buf->len = cpu_to_be32(len);
716
717 ret = 0;
718
719out:
720 kfree(dma_pages);
721
722 return ret;
723}
724
Roland Dreieraef9ec32005-11-02 14:07:13 -0800725static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_target_port *target,
726 struct srp_request *req)
727{
Roland Dreiercf368712006-03-24 15:47:26 -0800728 struct scatterlist *scat;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800729 struct srp_cmd *cmd = req->cmd->buf;
Roland Dreiercf368712006-03-24 15:47:26 -0800730 int len, nents, count;
Roland Dreierf5358a12006-06-17 20:37:29 -0700731 u8 fmt = SRP_DATA_DESC_DIRECT;
Ralph Campbell85507bc2006-12-12 14:30:55 -0800732 struct srp_device *dev;
733 struct ib_device *ibdev;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800734
FUJITA Tomonoribb350d12007-05-26 02:28:25 +0900735 if (!scsi_sglist(scmnd) || scmnd->sc_data_direction == DMA_NONE)
Roland Dreieraef9ec32005-11-02 14:07:13 -0800736 return sizeof (struct srp_cmd);
737
738 if (scmnd->sc_data_direction != DMA_FROM_DEVICE &&
739 scmnd->sc_data_direction != DMA_TO_DEVICE) {
David Dillow7aa54bd2008-01-07 18:23:41 -0500740 shost_printk(KERN_WARNING, target->scsi_host,
741 PFX "Unhandled data direction %d\n",
742 scmnd->sc_data_direction);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800743 return -EINVAL;
744 }
745
FUJITA Tomonoribb350d12007-05-26 02:28:25 +0900746 nents = scsi_sg_count(scmnd);
747 scat = scsi_sglist(scmnd);
Roland Dreiercf368712006-03-24 15:47:26 -0800748
Greg Kroah-Hartman05321932008-03-06 00:13:36 +0100749 dev = target->srp_host->srp_dev;
Ralph Campbell85507bc2006-12-12 14:30:55 -0800750 ibdev = dev->dev;
751
752 count = ib_dma_map_sg(ibdev, scat, nents, scmnd->sc_data_direction);
Roland Dreierf5358a12006-06-17 20:37:29 -0700753
754 fmt = SRP_DATA_DESC_DIRECT;
755 len = sizeof (struct srp_cmd) + sizeof (struct srp_direct_buf);
Roland Dreiercf368712006-03-24 15:47:26 -0800756
757 if (count == 1) {
Roland Dreierf5358a12006-06-17 20:37:29 -0700758 /*
759 * The midlayer only generated a single gather/scatter
760 * entry, or DMA mapping coalesced everything to a
761 * single entry. So a direct descriptor along with
762 * the DMA MR suffices.
763 */
Roland Dreieraef9ec32005-11-02 14:07:13 -0800764 struct srp_direct_buf *buf = (void *) cmd->add_data;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800765
Ralph Campbell85507bc2006-12-12 14:30:55 -0800766 buf->va = cpu_to_be64(ib_sg_dma_address(ibdev, scat));
767 buf->key = cpu_to_be32(dev->mr->rkey);
768 buf->len = cpu_to_be32(ib_sg_dma_len(ibdev, scat));
Ishai Rabinovitz559ce8f2006-08-03 10:35:43 -0700769 } else if (srp_map_fmr(target, scat, count, req,
Roland Dreierf5358a12006-06-17 20:37:29 -0700770 (void *) cmd->add_data)) {
771 /*
772 * FMR mapping failed, and the scatterlist has more
773 * than one entry. Generate an indirect memory
774 * descriptor.
775 */
Roland Dreiercf368712006-03-24 15:47:26 -0800776 struct srp_indirect_buf *buf = (void *) cmd->add_data;
FUJITA Tomonoribb350d12007-05-26 02:28:25 +0900777 struct scatterlist *sg;
Roland Dreiercf368712006-03-24 15:47:26 -0800778 u32 datalen = 0;
Roland Dreierf5358a12006-06-17 20:37:29 -0700779 int i;
Roland Dreiercf368712006-03-24 15:47:26 -0800780
781 fmt = SRP_DATA_DESC_INDIRECT;
Roland Dreierf5358a12006-06-17 20:37:29 -0700782 len = sizeof (struct srp_cmd) +
783 sizeof (struct srp_indirect_buf) +
784 count * sizeof (struct srp_direct_buf);
785
FUJITA Tomonoribb350d12007-05-26 02:28:25 +0900786 scsi_for_each_sg(scmnd, sg, count, i) {
787 unsigned int dma_len = ib_sg_dma_len(ibdev, sg);
Ralph Campbell85507bc2006-12-12 14:30:55 -0800788
Roland Dreierf5358a12006-06-17 20:37:29 -0700789 buf->desc_list[i].va =
FUJITA Tomonoribb350d12007-05-26 02:28:25 +0900790 cpu_to_be64(ib_sg_dma_address(ibdev, sg));
Roland Dreierf5358a12006-06-17 20:37:29 -0700791 buf->desc_list[i].key =
Ralph Campbell85507bc2006-12-12 14:30:55 -0800792 cpu_to_be32(dev->mr->rkey);
793 buf->desc_list[i].len = cpu_to_be32(dma_len);
794 datalen += dma_len;
Roland Dreierf5358a12006-06-17 20:37:29 -0700795 }
Roland Dreiercf368712006-03-24 15:47:26 -0800796
797 if (scmnd->sc_data_direction == DMA_TO_DEVICE)
798 cmd->data_out_desc_cnt = count;
799 else
800 cmd->data_in_desc_cnt = count;
801
Roland Dreierf5358a12006-06-17 20:37:29 -0700802 buf->table_desc.va =
803 cpu_to_be64(req->cmd->dma + sizeof *cmd + sizeof *buf);
Roland Dreiercf368712006-03-24 15:47:26 -0800804 buf->table_desc.key =
Greg Kroah-Hartman05321932008-03-06 00:13:36 +0100805 cpu_to_be32(target->srp_host->srp_dev->mr->rkey);
Roland Dreiercf368712006-03-24 15:47:26 -0800806 buf->table_desc.len =
807 cpu_to_be32(count * sizeof (struct srp_direct_buf));
808
Roland Dreiercf368712006-03-24 15:47:26 -0800809 buf->len = cpu_to_be32(datalen);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800810 }
811
812 if (scmnd->sc_data_direction == DMA_TO_DEVICE)
813 cmd->buf_fmt = fmt << 4;
814 else
815 cmd->buf_fmt = fmt;
816
Roland Dreieraef9ec32005-11-02 14:07:13 -0800817 return len;
818}
819
David Dillow05a1d752010-10-08 14:48:14 -0400820/*
821 * Must be called with target->scsi_host->host_lock held to protect
Bart Van Asschedcb4cb82010-11-26 13:22:48 -0500822 * req_lim and free_tx. Lock cannot be dropped between call here and
David Dillow05a1d752010-10-08 14:48:14 -0400823 * call to __srp_post_send().
824 *
825 * Note:
826 * An upper limit for the number of allocated information units for each
827 * request type is:
828 * - SRP_IU_CMD: SRP_CMD_SQ_SIZE, since the SCSI mid-layer never queues
829 * more than Scsi_Host.can_queue requests.
830 * - SRP_IU_TSK_MGMT: SRP_TSK_MGMT_SQ_SIZE.
831 * - SRP_IU_RSP: 1, since a conforming SRP target never sends more than
832 * one unanswered SRP request to an initiator.
833 */
834static struct srp_iu *__srp_get_tx_iu(struct srp_target_port *target,
835 enum srp_iu_type iu_type)
836{
837 s32 rsv = (iu_type == SRP_IU_TSK_MGMT) ? 0 : SRP_TSK_MGMT_SQ_SIZE;
838 struct srp_iu *iu;
839
840 srp_send_completion(target->send_cq, target);
841
Bart Van Asschedcb4cb82010-11-26 13:22:48 -0500842 if (list_empty(&target->free_tx))
David Dillow05a1d752010-10-08 14:48:14 -0400843 return NULL;
844
845 /* Initiator responses to target requests do not consume credits */
846 if (target->req_lim <= rsv && iu_type != SRP_IU_RSP) {
847 ++target->zero_req_lim;
848 return NULL;
849 }
850
Bart Van Asschedcb4cb82010-11-26 13:22:48 -0500851 iu = list_first_entry(&target->free_tx, struct srp_iu, list);
David Dillow05a1d752010-10-08 14:48:14 -0400852 iu->type = iu_type;
853 return iu;
854}
855
856/*
857 * Must be called with target->scsi_host->host_lock held to protect
Bart Van Asschedcb4cb82010-11-26 13:22:48 -0500858 * req_lim and free_tx.
David Dillow05a1d752010-10-08 14:48:14 -0400859 */
860static int __srp_post_send(struct srp_target_port *target,
861 struct srp_iu *iu, int len)
862{
863 struct ib_sge list;
864 struct ib_send_wr wr, *bad_wr;
865 int ret = 0;
866
867 list.addr = iu->dma;
868 list.length = len;
869 list.lkey = target->srp_host->srp_dev->mr->lkey;
870
871 wr.next = NULL;
Bart Van Asschedcb4cb82010-11-26 13:22:48 -0500872 wr.wr_id = (uintptr_t) iu;
David Dillow05a1d752010-10-08 14:48:14 -0400873 wr.sg_list = &list;
874 wr.num_sge = 1;
875 wr.opcode = IB_WR_SEND;
876 wr.send_flags = IB_SEND_SIGNALED;
877
878 ret = ib_post_send(target->qp, &wr, &bad_wr);
879
880 if (!ret) {
Bart Van Asschedcb4cb82010-11-26 13:22:48 -0500881 list_del(&iu->list);
David Dillow05a1d752010-10-08 14:48:14 -0400882 if (iu->type != SRP_IU_RSP)
883 --target->req_lim;
884 }
885
886 return ret;
887}
888
Bart Van Asschedcb4cb82010-11-26 13:22:48 -0500889static int srp_post_recv(struct srp_target_port *target, struct srp_iu *iu)
Bart Van Asschec996bb42010-07-30 10:59:05 +0000890{
Bart Van Asschec996bb42010-07-30 10:59:05 +0000891 struct ib_recv_wr wr, *bad_wr;
Bart Van Asschedcb4cb82010-11-26 13:22:48 -0500892 struct ib_sge list;
Bart Van Asschec996bb42010-07-30 10:59:05 +0000893
894 list.addr = iu->dma;
895 list.length = iu->size;
896 list.lkey = target->srp_host->srp_dev->mr->lkey;
897
898 wr.next = NULL;
Bart Van Asschedcb4cb82010-11-26 13:22:48 -0500899 wr.wr_id = (uintptr_t) iu;
Bart Van Asschec996bb42010-07-30 10:59:05 +0000900 wr.sg_list = &list;
901 wr.num_sge = 1;
902
Bart Van Asschedcb4cb82010-11-26 13:22:48 -0500903 return ib_post_recv(target->qp, &wr, &bad_wr);
Bart Van Asschec996bb42010-07-30 10:59:05 +0000904}
905
Roland Dreieraef9ec32005-11-02 14:07:13 -0800906static void srp_process_rsp(struct srp_target_port *target, struct srp_rsp *rsp)
907{
908 struct srp_request *req;
909 struct scsi_cmnd *scmnd;
910 unsigned long flags;
911 s32 delta;
912
913 delta = (s32) be32_to_cpu(rsp->req_lim_delta);
914
915 spin_lock_irqsave(target->scsi_host->host_lock, flags);
916
917 target->req_lim += delta;
918
Roland Dreieraef9ec32005-11-02 14:07:13 -0800919 if (unlikely(rsp->tag & SRP_TAG_TSK_MGMT)) {
David Dillowf8b6e312010-11-26 13:02:21 -0500920 target->tsk_mgmt_status = -1;
921 if (be32_to_cpu(rsp->resp_data_len) >= 4)
922 target->tsk_mgmt_status = rsp->data[3];
923 complete(&target->tsk_mgmt_done);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800924 } else {
David Dillowf8b6e312010-11-26 13:02:21 -0500925 req = &target->req_ring[rsp->tag];
Roland Dreierd945e1d2006-05-09 10:50:28 -0700926 scmnd = req->scmnd;
Roland Dreieraef9ec32005-11-02 14:07:13 -0800927 if (!scmnd)
David Dillow7aa54bd2008-01-07 18:23:41 -0500928 shost_printk(KERN_ERR, target->scsi_host,
929 "Null scmnd for RSP w/tag %016llx\n",
930 (unsigned long long) rsp->tag);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800931 scmnd->result = rsp->status;
932
933 if (rsp->flags & SRP_RSP_FLAG_SNSVALID) {
934 memcpy(scmnd->sense_buffer, rsp->data +
935 be32_to_cpu(rsp->resp_data_len),
936 min_t(int, be32_to_cpu(rsp->sense_data_len),
937 SCSI_SENSE_BUFFERSIZE));
938 }
939
940 if (rsp->flags & (SRP_RSP_FLAG_DOOVER | SRP_RSP_FLAG_DOUNDER))
FUJITA Tomonoribb350d12007-05-26 02:28:25 +0900941 scsi_set_resid(scmnd, be32_to_cpu(rsp->data_out_res_cnt));
Roland Dreieraef9ec32005-11-02 14:07:13 -0800942 else if (rsp->flags & (SRP_RSP_FLAG_DIOVER | SRP_RSP_FLAG_DIUNDER))
FUJITA Tomonoribb350d12007-05-26 02:28:25 +0900943 scsi_set_resid(scmnd, be32_to_cpu(rsp->data_in_res_cnt));
Roland Dreieraef9ec32005-11-02 14:07:13 -0800944
David Dillowf8b6e312010-11-26 13:02:21 -0500945 scmnd->host_scribble = NULL;
946 scmnd->scsi_done(scmnd);
947 srp_remove_req(target, req);
Roland Dreieraef9ec32005-11-02 14:07:13 -0800948 }
949
950 spin_unlock_irqrestore(target->scsi_host->host_lock, flags);
951}
952
David Dillowbb125882010-10-08 14:40:47 -0400953static int srp_response_common(struct srp_target_port *target, s32 req_delta,
954 void *rsp, int len)
955{
956 struct ib_device *dev;
957 unsigned long flags;
958 struct srp_iu *iu;
959 int err = 1;
960
961 dev = target->srp_host->srp_dev->dev;
962
963 spin_lock_irqsave(target->scsi_host->host_lock, flags);
964 target->req_lim += req_delta;
965
966 iu = __srp_get_tx_iu(target, SRP_IU_RSP);
967 if (!iu) {
968 shost_printk(KERN_ERR, target->scsi_host, PFX
969 "no IU available to send response\n");
970 goto out;
971 }
972
973 ib_dma_sync_single_for_cpu(dev, iu->dma, len, DMA_TO_DEVICE);
974 memcpy(iu->buf, rsp, len);
975 ib_dma_sync_single_for_device(dev, iu->dma, len, DMA_TO_DEVICE);
976
977 err = __srp_post_send(target, iu, len);
978 if (err)
979 shost_printk(KERN_ERR, target->scsi_host, PFX
980 "unable to post response: %d\n", err);
981
982out:
983 spin_unlock_irqrestore(target->scsi_host->host_lock, flags);
984 return err;
985}
986
987static void srp_process_cred_req(struct srp_target_port *target,
988 struct srp_cred_req *req)
989{
990 struct srp_cred_rsp rsp = {
991 .opcode = SRP_CRED_RSP,
992 .tag = req->tag,
993 };
994 s32 delta = be32_to_cpu(req->req_lim_delta);
995
996 if (srp_response_common(target, delta, &rsp, sizeof rsp))
997 shost_printk(KERN_ERR, target->scsi_host, PFX
998 "problems processing SRP_CRED_REQ\n");
999}
1000
1001static void srp_process_aer_req(struct srp_target_port *target,
1002 struct srp_aer_req *req)
1003{
1004 struct srp_aer_rsp rsp = {
1005 .opcode = SRP_AER_RSP,
1006 .tag = req->tag,
1007 };
1008 s32 delta = be32_to_cpu(req->req_lim_delta);
1009
1010 shost_printk(KERN_ERR, target->scsi_host, PFX
1011 "ignoring AER for LUN %llu\n", be64_to_cpu(req->lun));
1012
1013 if (srp_response_common(target, delta, &rsp, sizeof rsp))
1014 shost_printk(KERN_ERR, target->scsi_host, PFX
1015 "problems processing SRP_AER_REQ\n");
1016}
1017
Roland Dreieraef9ec32005-11-02 14:07:13 -08001018static void srp_handle_recv(struct srp_target_port *target, struct ib_wc *wc)
1019{
Bart Van Asschedcb4cb82010-11-26 13:22:48 -05001020 struct ib_device *dev = target->srp_host->srp_dev->dev;
1021 struct srp_iu *iu = (struct srp_iu *) wc->wr_id;
Bart Van Asschec996bb42010-07-30 10:59:05 +00001022 int res;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001023 u8 opcode;
1024
Ralph Campbell85507bc2006-12-12 14:30:55 -08001025 ib_dma_sync_single_for_cpu(dev, iu->dma, target->max_ti_iu_len,
1026 DMA_FROM_DEVICE);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001027
1028 opcode = *(u8 *) iu->buf;
1029
1030 if (0) {
David Dillow7aa54bd2008-01-07 18:23:41 -05001031 shost_printk(KERN_ERR, target->scsi_host,
1032 PFX "recv completion, opcode 0x%02x\n", opcode);
Bart Van Assche7a700812010-07-29 15:56:37 +00001033 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 8, 1,
1034 iu->buf, wc->byte_len, true);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001035 }
1036
1037 switch (opcode) {
1038 case SRP_RSP:
1039 srp_process_rsp(target, iu->buf);
1040 break;
1041
David Dillowbb125882010-10-08 14:40:47 -04001042 case SRP_CRED_REQ:
1043 srp_process_cred_req(target, iu->buf);
1044 break;
1045
1046 case SRP_AER_REQ:
1047 srp_process_aer_req(target, iu->buf);
1048 break;
1049
Roland Dreieraef9ec32005-11-02 14:07:13 -08001050 case SRP_T_LOGOUT:
1051 /* XXX Handle target logout */
David Dillow7aa54bd2008-01-07 18:23:41 -05001052 shost_printk(KERN_WARNING, target->scsi_host,
1053 PFX "Got target logout request\n");
Roland Dreieraef9ec32005-11-02 14:07:13 -08001054 break;
1055
1056 default:
David Dillow7aa54bd2008-01-07 18:23:41 -05001057 shost_printk(KERN_WARNING, target->scsi_host,
1058 PFX "Unhandled SRP opcode 0x%02x\n", opcode);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001059 break;
1060 }
1061
Ralph Campbell85507bc2006-12-12 14:30:55 -08001062 ib_dma_sync_single_for_device(dev, iu->dma, target->max_ti_iu_len,
1063 DMA_FROM_DEVICE);
Bart Van Asschec996bb42010-07-30 10:59:05 +00001064
Bart Van Asschedcb4cb82010-11-26 13:22:48 -05001065 res = srp_post_recv(target, iu);
Bart Van Asschec996bb42010-07-30 10:59:05 +00001066 if (res != 0)
1067 shost_printk(KERN_ERR, target->scsi_host,
1068 PFX "Recv failed with error code %d\n", res);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001069}
1070
Bart Van Assche9c03dc92010-02-02 19:23:54 +00001071static void srp_recv_completion(struct ib_cq *cq, void *target_ptr)
Roland Dreieraef9ec32005-11-02 14:07:13 -08001072{
1073 struct srp_target_port *target = target_ptr;
1074 struct ib_wc wc;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001075
1076 ib_req_notify_cq(cq, IB_CQ_NEXT_COMP);
1077 while (ib_poll_cq(cq, 1, &wc) > 0) {
1078 if (wc.status) {
David Dillow7aa54bd2008-01-07 18:23:41 -05001079 shost_printk(KERN_ERR, target->scsi_host,
Bart Van Assche9c03dc92010-02-02 19:23:54 +00001080 PFX "failed receive status %d\n",
David Dillow7aa54bd2008-01-07 18:23:41 -05001081 wc.status);
Ishai Rabinovitz1033ff62007-01-16 17:26:22 +02001082 target->qp_in_error = 1;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001083 break;
1084 }
1085
Bart Van Assche9c03dc92010-02-02 19:23:54 +00001086 srp_handle_recv(target, &wc);
1087 }
1088}
1089
1090static void srp_send_completion(struct ib_cq *cq, void *target_ptr)
1091{
1092 struct srp_target_port *target = target_ptr;
1093 struct ib_wc wc;
Bart Van Asschedcb4cb82010-11-26 13:22:48 -05001094 struct srp_iu *iu;
Bart Van Assche9c03dc92010-02-02 19:23:54 +00001095
1096 while (ib_poll_cq(cq, 1, &wc) > 0) {
1097 if (wc.status) {
1098 shost_printk(KERN_ERR, target->scsi_host,
1099 PFX "failed send status %d\n",
1100 wc.status);
1101 target->qp_in_error = 1;
1102 break;
1103 }
1104
Bart Van Asschedcb4cb82010-11-26 13:22:48 -05001105 iu = (struct srp_iu *) wc.wr_id;
1106 list_add(&iu->list, &target->free_tx);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001107 }
1108}
1109
Jeff Garzikf2812332010-11-16 02:10:29 -05001110static int srp_queuecommand_lck(struct scsi_cmnd *scmnd,
Roland Dreieraef9ec32005-11-02 14:07:13 -08001111 void (*done)(struct scsi_cmnd *))
1112{
1113 struct srp_target_port *target = host_to_target(scmnd->device->host);
1114 struct srp_request *req;
1115 struct srp_iu *iu;
1116 struct srp_cmd *cmd;
Ralph Campbell85507bc2006-12-12 14:30:55 -08001117 struct ib_device *dev;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001118 int len;
1119
1120 if (target->state == SRP_TARGET_CONNECTING)
1121 goto err;
1122
1123 if (target->state == SRP_TARGET_DEAD ||
1124 target->state == SRP_TARGET_REMOVED) {
1125 scmnd->result = DID_BAD_TARGET << 16;
1126 done(scmnd);
1127 return 0;
1128 }
1129
David Dillowbb125882010-10-08 14:40:47 -04001130 iu = __srp_get_tx_iu(target, SRP_IU_CMD);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001131 if (!iu)
1132 goto err;
1133
Greg Kroah-Hartman05321932008-03-06 00:13:36 +01001134 dev = target->srp_host->srp_dev->dev;
Ralph Campbell85507bc2006-12-12 14:30:55 -08001135 ib_dma_sync_single_for_cpu(dev, iu->dma, srp_max_iu_len,
1136 DMA_TO_DEVICE);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001137
Bart Van Assche21c1a902010-08-30 19:27:40 +00001138 req = list_first_entry(&target->free_reqs, struct srp_request, list);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001139
1140 scmnd->scsi_done = done;
1141 scmnd->result = 0;
David Dillowf8b6e312010-11-26 13:02:21 -05001142 scmnd->host_scribble = (void *) req;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001143
1144 cmd = iu->buf;
1145 memset(cmd, 0, sizeof *cmd);
1146
1147 cmd->opcode = SRP_CMD;
1148 cmd->lun = cpu_to_be64((u64) scmnd->device->lun << 48);
Roland Dreierd945e1d2006-05-09 10:50:28 -07001149 cmd->tag = req->index;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001150 memcpy(cmd->cdb, scmnd->cmnd, scmnd->cmd_len);
1151
Roland Dreieraef9ec32005-11-02 14:07:13 -08001152 req->scmnd = scmnd;
1153 req->cmd = iu;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001154
1155 len = srp_map_data(scmnd, target, req);
1156 if (len < 0) {
David Dillow7aa54bd2008-01-07 18:23:41 -05001157 shost_printk(KERN_ERR, target->scsi_host,
1158 PFX "Failed to map data\n");
Roland Dreieraef9ec32005-11-02 14:07:13 -08001159 goto err;
1160 }
1161
Ralph Campbell85507bc2006-12-12 14:30:55 -08001162 ib_dma_sync_single_for_device(dev, iu->dma, srp_max_iu_len,
1163 DMA_TO_DEVICE);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001164
1165 if (__srp_post_send(target, iu, len)) {
David Dillow7aa54bd2008-01-07 18:23:41 -05001166 shost_printk(KERN_ERR, target->scsi_host, PFX "Send failed\n");
Roland Dreieraef9ec32005-11-02 14:07:13 -08001167 goto err_unmap;
1168 }
1169
Bart Van Assche536ae142010-11-26 13:58:27 -05001170 list_del(&req->list);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001171
1172 return 0;
1173
1174err_unmap:
1175 srp_unmap_data(scmnd, target, req);
1176
1177err:
1178 return SCSI_MLQUEUE_HOST_BUSY;
1179}
1180
Jeff Garzikf2812332010-11-16 02:10:29 -05001181static DEF_SCSI_QCMD(srp_queuecommand)
1182
Roland Dreieraef9ec32005-11-02 14:07:13 -08001183static int srp_alloc_iu_bufs(struct srp_target_port *target)
1184{
1185 int i;
1186
1187 for (i = 0; i < SRP_RQ_SIZE; ++i) {
1188 target->rx_ring[i] = srp_alloc_iu(target->srp_host,
1189 target->max_ti_iu_len,
1190 GFP_KERNEL, DMA_FROM_DEVICE);
1191 if (!target->rx_ring[i])
1192 goto err;
1193 }
1194
Bart Van Asschedd5e6e32010-08-30 19:27:20 +00001195 for (i = 0; i < SRP_SQ_SIZE; ++i) {
Roland Dreieraef9ec32005-11-02 14:07:13 -08001196 target->tx_ring[i] = srp_alloc_iu(target->srp_host,
Vu Pham74b0a152006-06-17 20:37:32 -07001197 srp_max_iu_len,
Roland Dreieraef9ec32005-11-02 14:07:13 -08001198 GFP_KERNEL, DMA_TO_DEVICE);
1199 if (!target->tx_ring[i])
1200 goto err;
Bart Van Asschedcb4cb82010-11-26 13:22:48 -05001201
1202 list_add(&target->tx_ring[i]->list, &target->free_tx);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001203 }
1204
1205 return 0;
1206
1207err:
1208 for (i = 0; i < SRP_RQ_SIZE; ++i) {
1209 srp_free_iu(target->srp_host, target->rx_ring[i]);
1210 target->rx_ring[i] = NULL;
1211 }
1212
Bart Van Asschedd5e6e32010-08-30 19:27:20 +00001213 for (i = 0; i < SRP_SQ_SIZE; ++i) {
Roland Dreieraef9ec32005-11-02 14:07:13 -08001214 srp_free_iu(target->srp_host, target->tx_ring[i]);
1215 target->tx_ring[i] = NULL;
1216 }
1217
1218 return -ENOMEM;
1219}
1220
1221static void srp_cm_rej_handler(struct ib_cm_id *cm_id,
1222 struct ib_cm_event *event,
1223 struct srp_target_port *target)
1224{
David Dillow7aa54bd2008-01-07 18:23:41 -05001225 struct Scsi_Host *shost = target->scsi_host;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001226 struct ib_class_port_info *cpi;
1227 int opcode;
1228
1229 switch (event->param.rej_rcvd.reason) {
1230 case IB_CM_REJ_PORT_CM_REDIRECT:
1231 cpi = event->param.rej_rcvd.ari;
1232 target->path.dlid = cpi->redirect_lid;
1233 target->path.pkey = cpi->redirect_pkey;
1234 cm_id->remote_cm_qpn = be32_to_cpu(cpi->redirect_qp) & 0x00ffffff;
1235 memcpy(target->path.dgid.raw, cpi->redirect_gid, 16);
1236
1237 target->status = target->path.dlid ?
1238 SRP_DLID_REDIRECT : SRP_PORT_REDIRECT;
1239 break;
1240
1241 case IB_CM_REJ_PORT_REDIRECT:
Roland Dreier5d7cbfd2007-08-03 10:45:18 -07001242 if (srp_target_is_topspin(target)) {
Roland Dreieraef9ec32005-11-02 14:07:13 -08001243 /*
1244 * Topspin/Cisco SRP gateways incorrectly send
1245 * reject reason code 25 when they mean 24
1246 * (port redirect).
1247 */
1248 memcpy(target->path.dgid.raw,
1249 event->param.rej_rcvd.ari, 16);
1250
David Dillow7aa54bd2008-01-07 18:23:41 -05001251 shost_printk(KERN_DEBUG, shost,
1252 PFX "Topspin/Cisco redirect to target port GID %016llx%016llx\n",
1253 (unsigned long long) be64_to_cpu(target->path.dgid.global.subnet_prefix),
1254 (unsigned long long) be64_to_cpu(target->path.dgid.global.interface_id));
Roland Dreieraef9ec32005-11-02 14:07:13 -08001255
1256 target->status = SRP_PORT_REDIRECT;
1257 } else {
David Dillow7aa54bd2008-01-07 18:23:41 -05001258 shost_printk(KERN_WARNING, shost,
1259 " REJ reason: IB_CM_REJ_PORT_REDIRECT\n");
Roland Dreieraef9ec32005-11-02 14:07:13 -08001260 target->status = -ECONNRESET;
1261 }
1262 break;
1263
1264 case IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID:
David Dillow7aa54bd2008-01-07 18:23:41 -05001265 shost_printk(KERN_WARNING, shost,
1266 " REJ reason: IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID\n");
Roland Dreieraef9ec32005-11-02 14:07:13 -08001267 target->status = -ECONNRESET;
1268 break;
1269
1270 case IB_CM_REJ_CONSUMER_DEFINED:
1271 opcode = *(u8 *) event->private_data;
1272 if (opcode == SRP_LOGIN_REJ) {
1273 struct srp_login_rej *rej = event->private_data;
1274 u32 reason = be32_to_cpu(rej->reason);
1275
1276 if (reason == SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE)
David Dillow7aa54bd2008-01-07 18:23:41 -05001277 shost_printk(KERN_WARNING, shost,
1278 PFX "SRP_LOGIN_REJ: requested max_it_iu_len too large\n");
Roland Dreieraef9ec32005-11-02 14:07:13 -08001279 else
David Dillow7aa54bd2008-01-07 18:23:41 -05001280 shost_printk(KERN_WARNING, shost,
1281 PFX "SRP LOGIN REJECTED, reason 0x%08x\n", reason);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001282 } else
David Dillow7aa54bd2008-01-07 18:23:41 -05001283 shost_printk(KERN_WARNING, shost,
1284 " REJ reason: IB_CM_REJ_CONSUMER_DEFINED,"
1285 " opcode 0x%02x\n", opcode);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001286 target->status = -ECONNRESET;
1287 break;
1288
David Dillow9fe4bcf2008-01-08 17:08:52 -05001289 case IB_CM_REJ_STALE_CONN:
1290 shost_printk(KERN_WARNING, shost, " REJ reason: stale connection\n");
1291 target->status = SRP_STALE_CONN;
1292 break;
1293
Roland Dreieraef9ec32005-11-02 14:07:13 -08001294 default:
David Dillow7aa54bd2008-01-07 18:23:41 -05001295 shost_printk(KERN_WARNING, shost, " REJ reason 0x%x\n",
1296 event->param.rej_rcvd.reason);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001297 target->status = -ECONNRESET;
1298 }
1299}
1300
1301static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event)
1302{
1303 struct srp_target_port *target = cm_id->context;
1304 struct ib_qp_attr *qp_attr = NULL;
1305 int attr_mask = 0;
1306 int comp = 0;
1307 int opcode = 0;
Bart Van Asschec996bb42010-07-30 10:59:05 +00001308 int i;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001309
1310 switch (event->event) {
1311 case IB_CM_REQ_ERROR:
David Dillow7aa54bd2008-01-07 18:23:41 -05001312 shost_printk(KERN_DEBUG, target->scsi_host,
1313 PFX "Sending CM REQ failed\n");
Roland Dreieraef9ec32005-11-02 14:07:13 -08001314 comp = 1;
1315 target->status = -ECONNRESET;
1316 break;
1317
1318 case IB_CM_REP_RECEIVED:
1319 comp = 1;
1320 opcode = *(u8 *) event->private_data;
1321
1322 if (opcode == SRP_LOGIN_RSP) {
1323 struct srp_login_rsp *rsp = event->private_data;
1324
1325 target->max_ti_iu_len = be32_to_cpu(rsp->max_ti_iu_len);
1326 target->req_lim = be32_to_cpu(rsp->req_lim_delta);
1327
Bart Van Assche7ade4002010-08-30 19:27:36 +00001328 /*
1329 * Reserve credits for task management so we don't
1330 * bounce requests back to the SCSI mid-layer.
1331 */
1332 target->scsi_host->can_queue
1333 = min(target->req_lim - SRP_TSK_MGMT_SQ_SIZE,
1334 target->scsi_host->can_queue);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001335 } else {
David Dillow7aa54bd2008-01-07 18:23:41 -05001336 shost_printk(KERN_WARNING, target->scsi_host,
1337 PFX "Unhandled RSP opcode %#x\n", opcode);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001338 target->status = -ECONNRESET;
1339 break;
1340 }
1341
Vu Phamd2fcea72006-11-21 14:14:10 -08001342 if (!target->rx_ring[0]) {
1343 target->status = srp_alloc_iu_bufs(target);
1344 if (target->status)
1345 break;
1346 }
Roland Dreieraef9ec32005-11-02 14:07:13 -08001347
1348 qp_attr = kmalloc(sizeof *qp_attr, GFP_KERNEL);
1349 if (!qp_attr) {
1350 target->status = -ENOMEM;
1351 break;
1352 }
1353
1354 qp_attr->qp_state = IB_QPS_RTR;
1355 target->status = ib_cm_init_qp_attr(cm_id, qp_attr, &attr_mask);
1356 if (target->status)
1357 break;
1358
1359 target->status = ib_modify_qp(target->qp, qp_attr, attr_mask);
1360 if (target->status)
1361 break;
1362
Bart Van Asschec996bb42010-07-30 10:59:05 +00001363 for (i = 0; i < SRP_RQ_SIZE; i++) {
Bart Van Asschedcb4cb82010-11-26 13:22:48 -05001364 struct srp_iu *iu = target->rx_ring[i];
1365 target->status = srp_post_recv(target, iu);
Bart Van Asschec996bb42010-07-30 10:59:05 +00001366 if (target->status)
1367 break;
1368 }
Roland Dreieraef9ec32005-11-02 14:07:13 -08001369 if (target->status)
1370 break;
1371
1372 qp_attr->qp_state = IB_QPS_RTS;
1373 target->status = ib_cm_init_qp_attr(cm_id, qp_attr, &attr_mask);
1374 if (target->status)
1375 break;
1376
1377 target->status = ib_modify_qp(target->qp, qp_attr, attr_mask);
1378 if (target->status)
1379 break;
1380
1381 target->status = ib_send_cm_rtu(cm_id, NULL, 0);
1382 if (target->status)
1383 break;
1384
1385 break;
1386
1387 case IB_CM_REJ_RECEIVED:
David Dillow7aa54bd2008-01-07 18:23:41 -05001388 shost_printk(KERN_DEBUG, target->scsi_host, PFX "REJ received\n");
Roland Dreieraef9ec32005-11-02 14:07:13 -08001389 comp = 1;
1390
1391 srp_cm_rej_handler(cm_id, event, target);
1392 break;
1393
Ishai Rabinovitzb7ac4ab2006-06-17 20:37:32 -07001394 case IB_CM_DREQ_RECEIVED:
David Dillow7aa54bd2008-01-07 18:23:41 -05001395 shost_printk(KERN_WARNING, target->scsi_host,
1396 PFX "DREQ received - connection closed\n");
Ishai Rabinovitzb7ac4ab2006-06-17 20:37:32 -07001397 if (ib_send_cm_drep(cm_id, NULL, 0))
David Dillow7aa54bd2008-01-07 18:23:41 -05001398 shost_printk(KERN_ERR, target->scsi_host,
1399 PFX "Sending CM DREP failed\n");
Roland Dreieraef9ec32005-11-02 14:07:13 -08001400 break;
1401
1402 case IB_CM_TIMEWAIT_EXIT:
David Dillow7aa54bd2008-01-07 18:23:41 -05001403 shost_printk(KERN_ERR, target->scsi_host,
1404 PFX "connection closed\n");
Roland Dreieraef9ec32005-11-02 14:07:13 -08001405
1406 comp = 1;
1407 target->status = 0;
1408 break;
1409
Ishai Rabinovitzb7ac4ab2006-06-17 20:37:32 -07001410 case IB_CM_MRA_RECEIVED:
1411 case IB_CM_DREQ_ERROR:
1412 case IB_CM_DREP_RECEIVED:
1413 break;
1414
Roland Dreieraef9ec32005-11-02 14:07:13 -08001415 default:
David Dillow7aa54bd2008-01-07 18:23:41 -05001416 shost_printk(KERN_WARNING, target->scsi_host,
1417 PFX "Unhandled CM event %d\n", event->event);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001418 break;
1419 }
1420
1421 if (comp)
1422 complete(&target->done);
1423
1424 kfree(qp_attr);
1425
1426 return 0;
1427}
1428
Roland Dreierd945e1d2006-05-09 10:50:28 -07001429static int srp_send_tsk_mgmt(struct srp_target_port *target,
David Dillowf8b6e312010-11-26 13:02:21 -05001430 u64 req_tag, unsigned int lun, u8 func)
Roland Dreieraef9ec32005-11-02 14:07:13 -08001431{
David Dillow19081f32010-10-18 08:54:49 -04001432 struct ib_device *dev = target->srp_host->srp_dev->dev;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001433 struct srp_iu *iu;
1434 struct srp_tsk_mgmt *tsk_mgmt;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001435
1436 spin_lock_irq(target->scsi_host->host_lock);
1437
Roland Dreier1285b3a2006-03-03 15:47:25 -08001438 if (target->state == SRP_TARGET_DEAD ||
David Dillowf8b6e312010-11-26 13:02:21 -05001439 target->state == SRP_TARGET_REMOVED)
Roland Dreier1285b3a2006-03-03 15:47:25 -08001440 goto out;
Roland Dreier1285b3a2006-03-03 15:47:25 -08001441
David Dillowf8b6e312010-11-26 13:02:21 -05001442 init_completion(&target->tsk_mgmt_done);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001443
David Dillowbb125882010-10-08 14:40:47 -04001444 iu = __srp_get_tx_iu(target, SRP_IU_TSK_MGMT);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001445 if (!iu)
1446 goto out;
1447
David Dillow19081f32010-10-18 08:54:49 -04001448 ib_dma_sync_single_for_cpu(dev, iu->dma, sizeof *tsk_mgmt,
1449 DMA_TO_DEVICE);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001450 tsk_mgmt = iu->buf;
1451 memset(tsk_mgmt, 0, sizeof *tsk_mgmt);
1452
1453 tsk_mgmt->opcode = SRP_TSK_MGMT;
David Dillowf8b6e312010-11-26 13:02:21 -05001454 tsk_mgmt->lun = cpu_to_be64((u64) lun << 48);
1455 tsk_mgmt->tag = req_tag | SRP_TAG_TSK_MGMT;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001456 tsk_mgmt->tsk_mgmt_func = func;
David Dillowf8b6e312010-11-26 13:02:21 -05001457 tsk_mgmt->task_tag = req_tag;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001458
David Dillow19081f32010-10-18 08:54:49 -04001459 ib_dma_sync_single_for_device(dev, iu->dma, sizeof *tsk_mgmt,
1460 DMA_TO_DEVICE);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001461 if (__srp_post_send(target, iu, sizeof *tsk_mgmt))
1462 goto out;
1463
Roland Dreieraef9ec32005-11-02 14:07:13 -08001464 spin_unlock_irq(target->scsi_host->host_lock);
Roland Dreierd945e1d2006-05-09 10:50:28 -07001465
David Dillowf8b6e312010-11-26 13:02:21 -05001466 if (!wait_for_completion_timeout(&target->tsk_mgmt_done,
Roland Dreieraef9ec32005-11-02 14:07:13 -08001467 msecs_to_jiffies(SRP_ABORT_TIMEOUT_MS)))
Roland Dreierd945e1d2006-05-09 10:50:28 -07001468 return -1;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001469
Roland Dreierd945e1d2006-05-09 10:50:28 -07001470 return 0;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001471
1472out:
1473 spin_unlock_irq(target->scsi_host->host_lock);
Roland Dreierd945e1d2006-05-09 10:50:28 -07001474 return -1;
1475}
1476
Roland Dreieraef9ec32005-11-02 14:07:13 -08001477static int srp_abort(struct scsi_cmnd *scmnd)
1478{
Roland Dreierd945e1d2006-05-09 10:50:28 -07001479 struct srp_target_port *target = host_to_target(scmnd->device->host);
David Dillowf8b6e312010-11-26 13:02:21 -05001480 struct srp_request *req = (struct srp_request *) scmnd->host_scribble;
Roland Dreierd945e1d2006-05-09 10:50:28 -07001481 int ret = SUCCESS;
1482
David Dillow7aa54bd2008-01-07 18:23:41 -05001483 shost_printk(KERN_ERR, target->scsi_host, "SRP abort called\n");
Roland Dreieraef9ec32005-11-02 14:07:13 -08001484
David Dillowf8b6e312010-11-26 13:02:21 -05001485 if (!req || target->qp_in_error)
Ishai Rabinovitz1033ff62007-01-16 17:26:22 +02001486 return FAILED;
David Dillowf8b6e312010-11-26 13:02:21 -05001487 if (srp_send_tsk_mgmt(target, req->index, scmnd->device->lun,
1488 SRP_TSK_ABORT_TASK))
Roland Dreierd945e1d2006-05-09 10:50:28 -07001489 return FAILED;
1490
1491 spin_lock_irq(target->scsi_host->host_lock);
1492
David Dillowf8b6e312010-11-26 13:02:21 -05001493 if (req->scmnd) {
1494 if (!target->tsk_mgmt_status) {
1495 srp_remove_req(target, req);
1496 scmnd->result = DID_ABORT << 16;
1497 } else
1498 ret = FAILED;
1499 }
Roland Dreierd945e1d2006-05-09 10:50:28 -07001500
1501 spin_unlock_irq(target->scsi_host->host_lock);
1502
1503 return ret;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001504}
1505
1506static int srp_reset_device(struct scsi_cmnd *scmnd)
1507{
Roland Dreierd945e1d2006-05-09 10:50:28 -07001508 struct srp_target_port *target = host_to_target(scmnd->device->host);
Bart Van Assche536ae142010-11-26 13:58:27 -05001509 int i;
Roland Dreierd945e1d2006-05-09 10:50:28 -07001510
David Dillow7aa54bd2008-01-07 18:23:41 -05001511 shost_printk(KERN_ERR, target->scsi_host, "SRP reset_device called\n");
Roland Dreieraef9ec32005-11-02 14:07:13 -08001512
Ishai Rabinovitz1033ff62007-01-16 17:26:22 +02001513 if (target->qp_in_error)
1514 return FAILED;
David Dillowf8b6e312010-11-26 13:02:21 -05001515 if (srp_send_tsk_mgmt(target, SRP_TAG_NO_REQ, scmnd->device->lun,
1516 SRP_TSK_LUN_RESET))
Roland Dreierd945e1d2006-05-09 10:50:28 -07001517 return FAILED;
David Dillowf8b6e312010-11-26 13:02:21 -05001518 if (target->tsk_mgmt_status)
Roland Dreierd945e1d2006-05-09 10:50:28 -07001519 return FAILED;
1520
1521 spin_lock_irq(target->scsi_host->host_lock);
1522
Bart Van Assche536ae142010-11-26 13:58:27 -05001523 for (i = 0; i < SRP_CMD_SQ_SIZE; ++i) {
1524 struct srp_request *req = &target->req_ring[i];
David Dillowf8b6e312010-11-26 13:02:21 -05001525 if (req->scmnd && req->scmnd->device == scmnd->device)
Ishai Rabinovitz526b4ca2006-06-17 20:37:38 -07001526 srp_reset_req(target, req);
Bart Van Assche536ae142010-11-26 13:58:27 -05001527 }
Roland Dreierd945e1d2006-05-09 10:50:28 -07001528
1529 spin_unlock_irq(target->scsi_host->host_lock);
1530
1531 return SUCCESS;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001532}
1533
1534static int srp_reset_host(struct scsi_cmnd *scmnd)
1535{
1536 struct srp_target_port *target = host_to_target(scmnd->device->host);
1537 int ret = FAILED;
1538
David Dillow7aa54bd2008-01-07 18:23:41 -05001539 shost_printk(KERN_ERR, target->scsi_host, PFX "SRP reset_host called\n");
Roland Dreieraef9ec32005-11-02 14:07:13 -08001540
1541 if (!srp_reconnect_target(target))
1542 ret = SUCCESS;
1543
1544 return ret;
1545}
1546
Tony Jonesee959b02008-02-22 00:13:36 +01001547static ssize_t show_id_ext(struct device *dev, struct device_attribute *attr,
1548 char *buf)
Roland Dreier6ecb0c82006-03-20 10:08:23 -08001549{
Tony Jonesee959b02008-02-22 00:13:36 +01001550 struct srp_target_port *target = host_to_target(class_to_shost(dev));
Roland Dreier6ecb0c82006-03-20 10:08:23 -08001551
1552 if (target->state == SRP_TARGET_DEAD ||
1553 target->state == SRP_TARGET_REMOVED)
1554 return -ENODEV;
1555
1556 return sprintf(buf, "0x%016llx\n",
1557 (unsigned long long) be64_to_cpu(target->id_ext));
1558}
1559
Tony Jonesee959b02008-02-22 00:13:36 +01001560static ssize_t show_ioc_guid(struct device *dev, struct device_attribute *attr,
1561 char *buf)
Roland Dreier6ecb0c82006-03-20 10:08:23 -08001562{
Tony Jonesee959b02008-02-22 00:13:36 +01001563 struct srp_target_port *target = host_to_target(class_to_shost(dev));
Roland Dreier6ecb0c82006-03-20 10:08:23 -08001564
1565 if (target->state == SRP_TARGET_DEAD ||
1566 target->state == SRP_TARGET_REMOVED)
1567 return -ENODEV;
1568
1569 return sprintf(buf, "0x%016llx\n",
1570 (unsigned long long) be64_to_cpu(target->ioc_guid));
1571}
1572
Tony Jonesee959b02008-02-22 00:13:36 +01001573static ssize_t show_service_id(struct device *dev,
1574 struct device_attribute *attr, char *buf)
Roland Dreier6ecb0c82006-03-20 10:08:23 -08001575{
Tony Jonesee959b02008-02-22 00:13:36 +01001576 struct srp_target_port *target = host_to_target(class_to_shost(dev));
Roland Dreier6ecb0c82006-03-20 10:08:23 -08001577
1578 if (target->state == SRP_TARGET_DEAD ||
1579 target->state == SRP_TARGET_REMOVED)
1580 return -ENODEV;
1581
1582 return sprintf(buf, "0x%016llx\n",
1583 (unsigned long long) be64_to_cpu(target->service_id));
1584}
1585
Tony Jonesee959b02008-02-22 00:13:36 +01001586static ssize_t show_pkey(struct device *dev, struct device_attribute *attr,
1587 char *buf)
Roland Dreier6ecb0c82006-03-20 10:08:23 -08001588{
Tony Jonesee959b02008-02-22 00:13:36 +01001589 struct srp_target_port *target = host_to_target(class_to_shost(dev));
Roland Dreier6ecb0c82006-03-20 10:08:23 -08001590
1591 if (target->state == SRP_TARGET_DEAD ||
1592 target->state == SRP_TARGET_REMOVED)
1593 return -ENODEV;
1594
1595 return sprintf(buf, "0x%04x\n", be16_to_cpu(target->path.pkey));
1596}
1597
Tony Jonesee959b02008-02-22 00:13:36 +01001598static ssize_t show_dgid(struct device *dev, struct device_attribute *attr,
1599 char *buf)
Roland Dreier6ecb0c82006-03-20 10:08:23 -08001600{
Tony Jonesee959b02008-02-22 00:13:36 +01001601 struct srp_target_port *target = host_to_target(class_to_shost(dev));
Roland Dreier6ecb0c82006-03-20 10:08:23 -08001602
1603 if (target->state == SRP_TARGET_DEAD ||
1604 target->state == SRP_TARGET_REMOVED)
1605 return -ENODEV;
1606
Harvey Harrison5b095d9892008-10-29 12:52:50 -07001607 return sprintf(buf, "%pI6\n", target->path.dgid.raw);
Roland Dreier6ecb0c82006-03-20 10:08:23 -08001608}
1609
Tony Jonesee959b02008-02-22 00:13:36 +01001610static ssize_t show_orig_dgid(struct device *dev,
1611 struct device_attribute *attr, char *buf)
Ishai Rabinovitz3633b3d2007-05-06 21:18:11 -07001612{
Tony Jonesee959b02008-02-22 00:13:36 +01001613 struct srp_target_port *target = host_to_target(class_to_shost(dev));
Ishai Rabinovitz3633b3d2007-05-06 21:18:11 -07001614
1615 if (target->state == SRP_TARGET_DEAD ||
1616 target->state == SRP_TARGET_REMOVED)
1617 return -ENODEV;
1618
Harvey Harrison5b095d9892008-10-29 12:52:50 -07001619 return sprintf(buf, "%pI6\n", target->orig_dgid);
Ishai Rabinovitz3633b3d2007-05-06 21:18:11 -07001620}
1621
Bart Van Assche89de7482010-08-03 14:08:45 +00001622static ssize_t show_req_lim(struct device *dev,
1623 struct device_attribute *attr, char *buf)
1624{
1625 struct srp_target_port *target = host_to_target(class_to_shost(dev));
1626
1627 if (target->state == SRP_TARGET_DEAD ||
1628 target->state == SRP_TARGET_REMOVED)
1629 return -ENODEV;
1630
1631 return sprintf(buf, "%d\n", target->req_lim);
1632}
1633
Tony Jonesee959b02008-02-22 00:13:36 +01001634static ssize_t show_zero_req_lim(struct device *dev,
1635 struct device_attribute *attr, char *buf)
Roland Dreier6bfa24f2006-06-17 20:37:33 -07001636{
Tony Jonesee959b02008-02-22 00:13:36 +01001637 struct srp_target_port *target = host_to_target(class_to_shost(dev));
Roland Dreier6bfa24f2006-06-17 20:37:33 -07001638
1639 if (target->state == SRP_TARGET_DEAD ||
1640 target->state == SRP_TARGET_REMOVED)
1641 return -ENODEV;
1642
1643 return sprintf(buf, "%d\n", target->zero_req_lim);
1644}
1645
Tony Jonesee959b02008-02-22 00:13:36 +01001646static ssize_t show_local_ib_port(struct device *dev,
1647 struct device_attribute *attr, char *buf)
Ishai Rabinovitzded7f1a2006-08-15 17:34:52 +03001648{
Tony Jonesee959b02008-02-22 00:13:36 +01001649 struct srp_target_port *target = host_to_target(class_to_shost(dev));
Ishai Rabinovitzded7f1a2006-08-15 17:34:52 +03001650
1651 return sprintf(buf, "%d\n", target->srp_host->port);
1652}
1653
Tony Jonesee959b02008-02-22 00:13:36 +01001654static ssize_t show_local_ib_device(struct device *dev,
1655 struct device_attribute *attr, char *buf)
Ishai Rabinovitzded7f1a2006-08-15 17:34:52 +03001656{
Tony Jonesee959b02008-02-22 00:13:36 +01001657 struct srp_target_port *target = host_to_target(class_to_shost(dev));
Ishai Rabinovitzded7f1a2006-08-15 17:34:52 +03001658
Greg Kroah-Hartman05321932008-03-06 00:13:36 +01001659 return sprintf(buf, "%s\n", target->srp_host->srp_dev->dev->name);
Ishai Rabinovitzded7f1a2006-08-15 17:34:52 +03001660}
1661
Tony Jonesee959b02008-02-22 00:13:36 +01001662static DEVICE_ATTR(id_ext, S_IRUGO, show_id_ext, NULL);
1663static DEVICE_ATTR(ioc_guid, S_IRUGO, show_ioc_guid, NULL);
1664static DEVICE_ATTR(service_id, S_IRUGO, show_service_id, NULL);
1665static DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL);
1666static DEVICE_ATTR(dgid, S_IRUGO, show_dgid, NULL);
1667static DEVICE_ATTR(orig_dgid, S_IRUGO, show_orig_dgid, NULL);
Bart Van Assche89de7482010-08-03 14:08:45 +00001668static DEVICE_ATTR(req_lim, S_IRUGO, show_req_lim, NULL);
Tony Jonesee959b02008-02-22 00:13:36 +01001669static DEVICE_ATTR(zero_req_lim, S_IRUGO, show_zero_req_lim, NULL);
1670static DEVICE_ATTR(local_ib_port, S_IRUGO, show_local_ib_port, NULL);
1671static DEVICE_ATTR(local_ib_device, S_IRUGO, show_local_ib_device, NULL);
Roland Dreier6ecb0c82006-03-20 10:08:23 -08001672
Tony Jonesee959b02008-02-22 00:13:36 +01001673static struct device_attribute *srp_host_attrs[] = {
1674 &dev_attr_id_ext,
1675 &dev_attr_ioc_guid,
1676 &dev_attr_service_id,
1677 &dev_attr_pkey,
1678 &dev_attr_dgid,
1679 &dev_attr_orig_dgid,
Bart Van Assche89de7482010-08-03 14:08:45 +00001680 &dev_attr_req_lim,
Tony Jonesee959b02008-02-22 00:13:36 +01001681 &dev_attr_zero_req_lim,
1682 &dev_attr_local_ib_port,
1683 &dev_attr_local_ib_device,
Roland Dreier6ecb0c82006-03-20 10:08:23 -08001684 NULL
1685};
1686
Roland Dreieraef9ec32005-11-02 14:07:13 -08001687static struct scsi_host_template srp_template = {
1688 .module = THIS_MODULE,
Roland Dreierb7f008f2007-05-06 21:18:11 -07001689 .name = "InfiniBand SRP initiator",
1690 .proc_name = DRV_NAME,
Roland Dreieraef9ec32005-11-02 14:07:13 -08001691 .info = srp_target_info,
1692 .queuecommand = srp_queuecommand,
1693 .eh_abort_handler = srp_abort,
1694 .eh_device_reset_handler = srp_reset_device,
1695 .eh_host_reset_handler = srp_reset_host,
Bart Van Asschedd5e6e32010-08-30 19:27:20 +00001696 .can_queue = SRP_CMD_SQ_SIZE,
Roland Dreieraef9ec32005-11-02 14:07:13 -08001697 .this_id = -1,
Bart Van Asschedd5e6e32010-08-30 19:27:20 +00001698 .cmd_per_lun = SRP_CMD_SQ_SIZE,
Roland Dreier6ecb0c82006-03-20 10:08:23 -08001699 .use_clustering = ENABLE_CLUSTERING,
1700 .shost_attrs = srp_host_attrs
Roland Dreieraef9ec32005-11-02 14:07:13 -08001701};
1702
1703static int srp_add_target(struct srp_host *host, struct srp_target_port *target)
1704{
FUJITA Tomonori32368222007-06-27 16:33:12 +09001705 struct srp_rport_identifiers ids;
1706 struct srp_rport *rport;
1707
Roland Dreieraef9ec32005-11-02 14:07:13 -08001708 sprintf(target->target_name, "SRP.T10:%016llX",
1709 (unsigned long long) be64_to_cpu(target->id_ext));
1710
Greg Kroah-Hartman05321932008-03-06 00:13:36 +01001711 if (scsi_add_host(target->scsi_host, host->srp_dev->dev->dma_device))
Roland Dreieraef9ec32005-11-02 14:07:13 -08001712 return -ENODEV;
1713
FUJITA Tomonori32368222007-06-27 16:33:12 +09001714 memcpy(ids.port_id, &target->id_ext, 8);
1715 memcpy(ids.port_id + 8, &target->ioc_guid, 8);
FUJITA Tomonoriaebd5e42007-07-11 15:08:15 +09001716 ids.roles = SRP_RPORT_ROLE_TARGET;
FUJITA Tomonori32368222007-06-27 16:33:12 +09001717 rport = srp_rport_add(target->scsi_host, &ids);
1718 if (IS_ERR(rport)) {
1719 scsi_remove_host(target->scsi_host);
1720 return PTR_ERR(rport);
1721 }
1722
Matthew Wilcoxb3589fd2006-06-17 20:37:30 -07001723 spin_lock(&host->target_lock);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001724 list_add_tail(&target->list, &host->target_list);
Matthew Wilcoxb3589fd2006-06-17 20:37:30 -07001725 spin_unlock(&host->target_lock);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001726
1727 target->state = SRP_TARGET_LIVE;
1728
Roland Dreieraef9ec32005-11-02 14:07:13 -08001729 scsi_scan_target(&target->scsi_host->shost_gendev,
Matthew Wilcox1962a4a2006-06-17 20:37:30 -07001730 0, target->scsi_id, SCAN_WILD_CARD, 0);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001731
1732 return 0;
1733}
1734
Tony Jonesee959b02008-02-22 00:13:36 +01001735static void srp_release_dev(struct device *dev)
Roland Dreieraef9ec32005-11-02 14:07:13 -08001736{
1737 struct srp_host *host =
Tony Jonesee959b02008-02-22 00:13:36 +01001738 container_of(dev, struct srp_host, dev);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001739
1740 complete(&host->released);
1741}
1742
1743static struct class srp_class = {
1744 .name = "infiniband_srp",
Tony Jonesee959b02008-02-22 00:13:36 +01001745 .dev_release = srp_release_dev
Roland Dreieraef9ec32005-11-02 14:07:13 -08001746};
1747
1748/*
1749 * Target ports are added by writing
1750 *
1751 * id_ext=<SRP ID ext>,ioc_guid=<SRP IOC GUID>,dgid=<dest GID>,
1752 * pkey=<P_Key>,service_id=<service ID>
1753 *
1754 * to the add_target sysfs attribute.
1755 */
1756enum {
1757 SRP_OPT_ERR = 0,
1758 SRP_OPT_ID_EXT = 1 << 0,
1759 SRP_OPT_IOC_GUID = 1 << 1,
1760 SRP_OPT_DGID = 1 << 2,
1761 SRP_OPT_PKEY = 1 << 3,
1762 SRP_OPT_SERVICE_ID = 1 << 4,
1763 SRP_OPT_MAX_SECT = 1 << 5,
Vu Pham52fb2b502006-06-17 20:37:31 -07001764 SRP_OPT_MAX_CMD_PER_LUN = 1 << 6,
Ramachandra K0c0450db2006-06-17 20:37:38 -07001765 SRP_OPT_IO_CLASS = 1 << 7,
Ishai Rabinovitz01cb9bc2006-10-04 15:28:56 +02001766 SRP_OPT_INITIATOR_EXT = 1 << 8,
Roland Dreieraef9ec32005-11-02 14:07:13 -08001767 SRP_OPT_ALL = (SRP_OPT_ID_EXT |
1768 SRP_OPT_IOC_GUID |
1769 SRP_OPT_DGID |
1770 SRP_OPT_PKEY |
1771 SRP_OPT_SERVICE_ID),
1772};
1773
Steven Whitehousea447c092008-10-13 10:46:57 +01001774static const match_table_t srp_opt_tokens = {
Vu Pham52fb2b502006-06-17 20:37:31 -07001775 { SRP_OPT_ID_EXT, "id_ext=%s" },
1776 { SRP_OPT_IOC_GUID, "ioc_guid=%s" },
1777 { SRP_OPT_DGID, "dgid=%s" },
1778 { SRP_OPT_PKEY, "pkey=%x" },
1779 { SRP_OPT_SERVICE_ID, "service_id=%s" },
1780 { SRP_OPT_MAX_SECT, "max_sect=%d" },
1781 { SRP_OPT_MAX_CMD_PER_LUN, "max_cmd_per_lun=%d" },
Ramachandra K0c0450db2006-06-17 20:37:38 -07001782 { SRP_OPT_IO_CLASS, "io_class=%x" },
Ishai Rabinovitz01cb9bc2006-10-04 15:28:56 +02001783 { SRP_OPT_INITIATOR_EXT, "initiator_ext=%s" },
Vu Pham52fb2b502006-06-17 20:37:31 -07001784 { SRP_OPT_ERR, NULL }
Roland Dreieraef9ec32005-11-02 14:07:13 -08001785};
1786
1787static int srp_parse_options(const char *buf, struct srp_target_port *target)
1788{
1789 char *options, *sep_opt;
1790 char *p;
1791 char dgid[3];
1792 substring_t args[MAX_OPT_ARGS];
1793 int opt_mask = 0;
1794 int token;
1795 int ret = -EINVAL;
1796 int i;
1797
1798 options = kstrdup(buf, GFP_KERNEL);
1799 if (!options)
1800 return -ENOMEM;
1801
1802 sep_opt = options;
1803 while ((p = strsep(&sep_opt, ",")) != NULL) {
1804 if (!*p)
1805 continue;
1806
1807 token = match_token(p, srp_opt_tokens, args);
1808 opt_mask |= token;
1809
1810 switch (token) {
1811 case SRP_OPT_ID_EXT:
1812 p = match_strdup(args);
Ishai Rabinovitza20f3a62007-01-16 17:20:25 +02001813 if (!p) {
1814 ret = -ENOMEM;
1815 goto out;
1816 }
Roland Dreieraef9ec32005-11-02 14:07:13 -08001817 target->id_ext = cpu_to_be64(simple_strtoull(p, NULL, 16));
1818 kfree(p);
1819 break;
1820
1821 case SRP_OPT_IOC_GUID:
1822 p = match_strdup(args);
Ishai Rabinovitza20f3a62007-01-16 17:20:25 +02001823 if (!p) {
1824 ret = -ENOMEM;
1825 goto out;
1826 }
Roland Dreieraef9ec32005-11-02 14:07:13 -08001827 target->ioc_guid = cpu_to_be64(simple_strtoull(p, NULL, 16));
1828 kfree(p);
1829 break;
1830
1831 case SRP_OPT_DGID:
1832 p = match_strdup(args);
Ishai Rabinovitza20f3a62007-01-16 17:20:25 +02001833 if (!p) {
1834 ret = -ENOMEM;
1835 goto out;
1836 }
Roland Dreieraef9ec32005-11-02 14:07:13 -08001837 if (strlen(p) != 32) {
1838 printk(KERN_WARNING PFX "bad dest GID parameter '%s'\n", p);
Roland Dreierce1823f2006-04-03 09:31:04 -07001839 kfree(p);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001840 goto out;
1841 }
1842
1843 for (i = 0; i < 16; ++i) {
1844 strlcpy(dgid, p + i * 2, 3);
1845 target->path.dgid.raw[i] = simple_strtoul(dgid, NULL, 16);
1846 }
Roland Dreierbf17c1c2006-03-20 10:08:25 -08001847 kfree(p);
Ishai Rabinovitz3633b3d2007-05-06 21:18:11 -07001848 memcpy(target->orig_dgid, target->path.dgid.raw, 16);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001849 break;
1850
1851 case SRP_OPT_PKEY:
1852 if (match_hex(args, &token)) {
1853 printk(KERN_WARNING PFX "bad P_Key parameter '%s'\n", p);
1854 goto out;
1855 }
1856 target->path.pkey = cpu_to_be16(token);
1857 break;
1858
1859 case SRP_OPT_SERVICE_ID:
1860 p = match_strdup(args);
Ishai Rabinovitza20f3a62007-01-16 17:20:25 +02001861 if (!p) {
1862 ret = -ENOMEM;
1863 goto out;
1864 }
Roland Dreieraef9ec32005-11-02 14:07:13 -08001865 target->service_id = cpu_to_be64(simple_strtoull(p, NULL, 16));
Sean Hefty247e0202007-08-08 15:51:18 -07001866 target->path.service_id = target->service_id;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001867 kfree(p);
1868 break;
1869
1870 case SRP_OPT_MAX_SECT:
1871 if (match_int(args, &token)) {
1872 printk(KERN_WARNING PFX "bad max sect parameter '%s'\n", p);
1873 goto out;
1874 }
1875 target->scsi_host->max_sectors = token;
1876 break;
1877
Vu Pham52fb2b502006-06-17 20:37:31 -07001878 case SRP_OPT_MAX_CMD_PER_LUN:
1879 if (match_int(args, &token)) {
1880 printk(KERN_WARNING PFX "bad max cmd_per_lun parameter '%s'\n", p);
1881 goto out;
1882 }
Bart Van Asschedd5e6e32010-08-30 19:27:20 +00001883 target->scsi_host->cmd_per_lun = min(token, SRP_CMD_SQ_SIZE);
Vu Pham52fb2b502006-06-17 20:37:31 -07001884 break;
1885
Ramachandra K0c0450db2006-06-17 20:37:38 -07001886 case SRP_OPT_IO_CLASS:
1887 if (match_hex(args, &token)) {
1888 printk(KERN_WARNING PFX "bad IO class parameter '%s' \n", p);
1889 goto out;
1890 }
1891 if (token != SRP_REV10_IB_IO_CLASS &&
1892 token != SRP_REV16A_IB_IO_CLASS) {
1893 printk(KERN_WARNING PFX "unknown IO class parameter value"
1894 " %x specified (use %x or %x).\n",
1895 token, SRP_REV10_IB_IO_CLASS, SRP_REV16A_IB_IO_CLASS);
1896 goto out;
1897 }
1898 target->io_class = token;
1899 break;
1900
Ishai Rabinovitz01cb9bc2006-10-04 15:28:56 +02001901 case SRP_OPT_INITIATOR_EXT:
1902 p = match_strdup(args);
Ishai Rabinovitza20f3a62007-01-16 17:20:25 +02001903 if (!p) {
1904 ret = -ENOMEM;
1905 goto out;
1906 }
Ishai Rabinovitz01cb9bc2006-10-04 15:28:56 +02001907 target->initiator_ext = cpu_to_be64(simple_strtoull(p, NULL, 16));
1908 kfree(p);
1909 break;
1910
Roland Dreieraef9ec32005-11-02 14:07:13 -08001911 default:
1912 printk(KERN_WARNING PFX "unknown parameter or missing value "
1913 "'%s' in target creation request\n", p);
1914 goto out;
1915 }
1916 }
1917
1918 if ((opt_mask & SRP_OPT_ALL) == SRP_OPT_ALL)
1919 ret = 0;
1920 else
1921 for (i = 0; i < ARRAY_SIZE(srp_opt_tokens); ++i)
1922 if ((srp_opt_tokens[i].token & SRP_OPT_ALL) &&
1923 !(srp_opt_tokens[i].token & opt_mask))
1924 printk(KERN_WARNING PFX "target creation request is "
1925 "missing parameter '%s'\n",
1926 srp_opt_tokens[i].pattern);
1927
1928out:
1929 kfree(options);
1930 return ret;
1931}
1932
Tony Jonesee959b02008-02-22 00:13:36 +01001933static ssize_t srp_create_target(struct device *dev,
1934 struct device_attribute *attr,
Roland Dreieraef9ec32005-11-02 14:07:13 -08001935 const char *buf, size_t count)
1936{
1937 struct srp_host *host =
Tony Jonesee959b02008-02-22 00:13:36 +01001938 container_of(dev, struct srp_host, dev);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001939 struct Scsi_Host *target_host;
1940 struct srp_target_port *target;
1941 int ret;
1942 int i;
1943
1944 target_host = scsi_host_alloc(&srp_template,
1945 sizeof (struct srp_target_port));
1946 if (!target_host)
1947 return -ENOMEM;
1948
FUJITA Tomonori32368222007-06-27 16:33:12 +09001949 target_host->transportt = ib_srp_transport_template;
Arne Redlich3c8edf02006-11-15 12:43:00 +01001950 target_host->max_lun = SRP_MAX_LUN;
1951 target_host->max_cmd_len = sizeof ((struct srp_cmd *) (void *) 0L)->cdb;
Roland Dreier5f068992005-11-11 14:06:01 -08001952
Roland Dreieraef9ec32005-11-02 14:07:13 -08001953 target = host_to_target(target_host);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001954
Ramachandra K0c0450db2006-06-17 20:37:38 -07001955 target->io_class = SRP_REV16A_IB_IO_CLASS;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001956 target->scsi_host = target_host;
1957 target->srp_host = host;
1958
Bart Van Asschedcb4cb82010-11-26 13:22:48 -05001959 INIT_LIST_HEAD(&target->free_tx);
Roland Dreierd945e1d2006-05-09 10:50:28 -07001960 INIT_LIST_HEAD(&target->free_reqs);
Bart Van Asschedd5e6e32010-08-30 19:27:20 +00001961 for (i = 0; i < SRP_CMD_SQ_SIZE; ++i) {
Roland Dreierd945e1d2006-05-09 10:50:28 -07001962 target->req_ring[i].index = i;
1963 list_add_tail(&target->req_ring[i].list, &target->free_reqs);
1964 }
Roland Dreieraef9ec32005-11-02 14:07:13 -08001965
1966 ret = srp_parse_options(buf, target);
1967 if (ret)
1968 goto err;
1969
Roland Dreier969a60f2008-07-14 23:48:43 -07001970 ib_query_gid(host->srp_dev->dev, host->port, 0, &target->path.sgid);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001971
David Dillow7aa54bd2008-01-07 18:23:41 -05001972 shost_printk(KERN_DEBUG, target->scsi_host, PFX
1973 "new target: id_ext %016llx ioc_guid %016llx pkey %04x "
Harvey Harrison5b095d9892008-10-29 12:52:50 -07001974 "service_id %016llx dgid %pI6\n",
Roland Dreieraef9ec32005-11-02 14:07:13 -08001975 (unsigned long long) be64_to_cpu(target->id_ext),
1976 (unsigned long long) be64_to_cpu(target->ioc_guid),
1977 be16_to_cpu(target->path.pkey),
1978 (unsigned long long) be64_to_cpu(target->service_id),
Harvey Harrison8867cd72008-10-28 22:36:33 -07001979 target->path.dgid.raw);
Roland Dreieraef9ec32005-11-02 14:07:13 -08001980
1981 ret = srp_create_target_ib(target);
1982 if (ret)
1983 goto err;
1984
David Dillow9fe4bcf2008-01-08 17:08:52 -05001985 ret = srp_new_cm_id(target);
1986 if (ret)
Roland Dreieraef9ec32005-11-02 14:07:13 -08001987 goto err_free;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001988
Ishai Rabinovitz1033ff62007-01-16 17:26:22 +02001989 target->qp_in_error = 0;
Roland Dreieraef9ec32005-11-02 14:07:13 -08001990 ret = srp_connect_target(target);
1991 if (ret) {
David Dillow7aa54bd2008-01-07 18:23:41 -05001992 shost_printk(KERN_ERR, target->scsi_host,
1993 PFX "Connection failed\n");
Roland Dreieraef9ec32005-11-02 14:07:13 -08001994 goto err_cm_id;
1995 }
1996
1997 ret = srp_add_target(host, target);
1998 if (ret)
1999 goto err_disconnect;
2000
2001 return count;
2002
2003err_disconnect:
2004 srp_disconnect_target(target);
2005
2006err_cm_id:
2007 ib_destroy_cm_id(target->cm_id);
2008
2009err_free:
2010 srp_free_target_ib(target);
2011
2012err:
2013 scsi_host_put(target_host);
2014
2015 return ret;
2016}
2017
Tony Jonesee959b02008-02-22 00:13:36 +01002018static DEVICE_ATTR(add_target, S_IWUSR, NULL, srp_create_target);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002019
Tony Jonesee959b02008-02-22 00:13:36 +01002020static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr,
2021 char *buf)
Roland Dreieraef9ec32005-11-02 14:07:13 -08002022{
Tony Jonesee959b02008-02-22 00:13:36 +01002023 struct srp_host *host = container_of(dev, struct srp_host, dev);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002024
Greg Kroah-Hartman05321932008-03-06 00:13:36 +01002025 return sprintf(buf, "%s\n", host->srp_dev->dev->name);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002026}
2027
Tony Jonesee959b02008-02-22 00:13:36 +01002028static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002029
Tony Jonesee959b02008-02-22 00:13:36 +01002030static ssize_t show_port(struct device *dev, struct device_attribute *attr,
2031 char *buf)
Roland Dreieraef9ec32005-11-02 14:07:13 -08002032{
Tony Jonesee959b02008-02-22 00:13:36 +01002033 struct srp_host *host = container_of(dev, struct srp_host, dev);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002034
2035 return sprintf(buf, "%d\n", host->port);
2036}
2037
Tony Jonesee959b02008-02-22 00:13:36 +01002038static DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002039
Roland Dreierf5358a12006-06-17 20:37:29 -07002040static struct srp_host *srp_add_port(struct srp_device *device, u8 port)
Roland Dreieraef9ec32005-11-02 14:07:13 -08002041{
2042 struct srp_host *host;
2043
2044 host = kzalloc(sizeof *host, GFP_KERNEL);
2045 if (!host)
2046 return NULL;
2047
2048 INIT_LIST_HEAD(&host->target_list);
Matthew Wilcoxb3589fd2006-06-17 20:37:30 -07002049 spin_lock_init(&host->target_lock);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002050 init_completion(&host->released);
Greg Kroah-Hartman05321932008-03-06 00:13:36 +01002051 host->srp_dev = device;
Roland Dreieraef9ec32005-11-02 14:07:13 -08002052 host->port = port;
2053
Tony Jonesee959b02008-02-22 00:13:36 +01002054 host->dev.class = &srp_class;
2055 host->dev.parent = device->dev->dma_device;
Kay Sieversd927e382009-01-06 10:44:39 -08002056 dev_set_name(&host->dev, "srp-%s-%d", device->dev->name, port);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002057
Tony Jonesee959b02008-02-22 00:13:36 +01002058 if (device_register(&host->dev))
Roland Dreierf5358a12006-06-17 20:37:29 -07002059 goto free_host;
Tony Jonesee959b02008-02-22 00:13:36 +01002060 if (device_create_file(&host->dev, &dev_attr_add_target))
Roland Dreieraef9ec32005-11-02 14:07:13 -08002061 goto err_class;
Tony Jonesee959b02008-02-22 00:13:36 +01002062 if (device_create_file(&host->dev, &dev_attr_ibdev))
Roland Dreieraef9ec32005-11-02 14:07:13 -08002063 goto err_class;
Tony Jonesee959b02008-02-22 00:13:36 +01002064 if (device_create_file(&host->dev, &dev_attr_port))
Roland Dreieraef9ec32005-11-02 14:07:13 -08002065 goto err_class;
2066
2067 return host;
2068
2069err_class:
Tony Jonesee959b02008-02-22 00:13:36 +01002070 device_unregister(&host->dev);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002071
Roland Dreierf5358a12006-06-17 20:37:29 -07002072free_host:
Roland Dreieraef9ec32005-11-02 14:07:13 -08002073 kfree(host);
2074
2075 return NULL;
2076}
2077
2078static void srp_add_one(struct ib_device *device)
2079{
Roland Dreierf5358a12006-06-17 20:37:29 -07002080 struct srp_device *srp_dev;
2081 struct ib_device_attr *dev_attr;
2082 struct ib_fmr_pool_param fmr_param;
Roland Dreieraef9ec32005-11-02 14:07:13 -08002083 struct srp_host *host;
Roland Dreieraef9ec32005-11-02 14:07:13 -08002084 int s, e, p;
2085
Roland Dreierf5358a12006-06-17 20:37:29 -07002086 dev_attr = kmalloc(sizeof *dev_attr, GFP_KERNEL);
2087 if (!dev_attr)
Sean Heftycf311cd2006-01-10 07:39:34 -08002088 return;
Roland Dreieraef9ec32005-11-02 14:07:13 -08002089
Roland Dreierf5358a12006-06-17 20:37:29 -07002090 if (ib_query_device(device, dev_attr)) {
2091 printk(KERN_WARNING PFX "Query device failed for %s\n",
2092 device->name);
2093 goto free_attr;
2094 }
2095
2096 srp_dev = kmalloc(sizeof *srp_dev, GFP_KERNEL);
2097 if (!srp_dev)
2098 goto free_attr;
2099
2100 /*
2101 * Use the smallest page size supported by the HCA, down to a
2102 * minimum of 512 bytes (which is the smallest sector that a
2103 * SCSI command will ever carry).
2104 */
2105 srp_dev->fmr_page_shift = max(9, ffs(dev_attr->page_size_cap) - 1);
2106 srp_dev->fmr_page_size = 1 << srp_dev->fmr_page_shift;
Roland Dreierbf628dc2006-12-15 14:01:49 -08002107 srp_dev->fmr_page_mask = ~((u64) srp_dev->fmr_page_size - 1);
Roland Dreierf5358a12006-06-17 20:37:29 -07002108
2109 INIT_LIST_HEAD(&srp_dev->dev_list);
2110
2111 srp_dev->dev = device;
2112 srp_dev->pd = ib_alloc_pd(device);
2113 if (IS_ERR(srp_dev->pd))
2114 goto free_dev;
2115
2116 srp_dev->mr = ib_get_dma_mr(srp_dev->pd,
2117 IB_ACCESS_LOCAL_WRITE |
2118 IB_ACCESS_REMOTE_READ |
2119 IB_ACCESS_REMOTE_WRITE);
2120 if (IS_ERR(srp_dev->mr))
2121 goto err_pd;
2122
2123 memset(&fmr_param, 0, sizeof fmr_param);
2124 fmr_param.pool_size = SRP_FMR_POOL_SIZE;
2125 fmr_param.dirty_watermark = SRP_FMR_DIRTY_SIZE;
2126 fmr_param.cache = 1;
2127 fmr_param.max_pages_per_fmr = SRP_FMR_SIZE;
2128 fmr_param.page_shift = srp_dev->fmr_page_shift;
2129 fmr_param.access = (IB_ACCESS_LOCAL_WRITE |
2130 IB_ACCESS_REMOTE_WRITE |
2131 IB_ACCESS_REMOTE_READ);
2132
2133 srp_dev->fmr_pool = ib_create_fmr_pool(srp_dev->pd, &fmr_param);
2134 if (IS_ERR(srp_dev->fmr_pool))
2135 srp_dev->fmr_pool = NULL;
Roland Dreieraef9ec32005-11-02 14:07:13 -08002136
Tom Tucker07ebafb2006-08-03 16:02:42 -05002137 if (device->node_type == RDMA_NODE_IB_SWITCH) {
Roland Dreieraef9ec32005-11-02 14:07:13 -08002138 s = 0;
2139 e = 0;
2140 } else {
2141 s = 1;
2142 e = device->phys_port_cnt;
2143 }
2144
2145 for (p = s; p <= e; ++p) {
Roland Dreierf5358a12006-06-17 20:37:29 -07002146 host = srp_add_port(srp_dev, p);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002147 if (host)
Roland Dreierf5358a12006-06-17 20:37:29 -07002148 list_add_tail(&host->list, &srp_dev->dev_list);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002149 }
2150
Roland Dreierf5358a12006-06-17 20:37:29 -07002151 ib_set_client_data(device, &srp_client, srp_dev);
2152
2153 goto free_attr;
2154
2155err_pd:
2156 ib_dealloc_pd(srp_dev->pd);
2157
2158free_dev:
2159 kfree(srp_dev);
2160
2161free_attr:
2162 kfree(dev_attr);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002163}
2164
2165static void srp_remove_one(struct ib_device *device)
2166{
Roland Dreierf5358a12006-06-17 20:37:29 -07002167 struct srp_device *srp_dev;
Roland Dreieraef9ec32005-11-02 14:07:13 -08002168 struct srp_host *host, *tmp_host;
2169 LIST_HEAD(target_list);
2170 struct srp_target_port *target, *tmp_target;
Roland Dreieraef9ec32005-11-02 14:07:13 -08002171
Roland Dreierf5358a12006-06-17 20:37:29 -07002172 srp_dev = ib_get_client_data(device, &srp_client);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002173
Roland Dreierf5358a12006-06-17 20:37:29 -07002174 list_for_each_entry_safe(host, tmp_host, &srp_dev->dev_list, list) {
Tony Jonesee959b02008-02-22 00:13:36 +01002175 device_unregister(&host->dev);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002176 /*
2177 * Wait for the sysfs entry to go away, so that no new
2178 * target ports can be created.
2179 */
2180 wait_for_completion(&host->released);
2181
2182 /*
2183 * Mark all target ports as removed, so we stop queueing
2184 * commands and don't try to reconnect.
2185 */
Matthew Wilcoxb3589fd2006-06-17 20:37:30 -07002186 spin_lock(&host->target_lock);
Matthew Wilcox549c5fc22006-06-17 20:37:30 -07002187 list_for_each_entry(target, &host->target_list, list) {
Ishai Rabinovitz0c5b3952006-06-17 20:37:31 -07002188 spin_lock_irq(target->scsi_host->host_lock);
2189 target->state = SRP_TARGET_REMOVED;
2190 spin_unlock_irq(target->scsi_host->host_lock);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002191 }
Matthew Wilcoxb3589fd2006-06-17 20:37:30 -07002192 spin_unlock(&host->target_lock);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002193
2194 /*
2195 * Wait for any reconnection tasks that may have
2196 * started before we marked our target ports as
2197 * removed, and any target port removal tasks.
2198 */
2199 flush_scheduled_work();
2200
2201 list_for_each_entry_safe(target, tmp_target,
2202 &host->target_list, list) {
David Dillowb0e47c82008-01-03 10:25:27 -08002203 srp_remove_host(target->scsi_host);
Dave Dillowad696982008-01-03 22:35:41 -05002204 scsi_remove_host(target->scsi_host);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002205 srp_disconnect_target(target);
2206 ib_destroy_cm_id(target->cm_id);
2207 srp_free_target_ib(target);
2208 scsi_host_put(target->scsi_host);
2209 }
2210
Roland Dreieraef9ec32005-11-02 14:07:13 -08002211 kfree(host);
2212 }
2213
Roland Dreierf5358a12006-06-17 20:37:29 -07002214 if (srp_dev->fmr_pool)
2215 ib_destroy_fmr_pool(srp_dev->fmr_pool);
2216 ib_dereg_mr(srp_dev->mr);
2217 ib_dealloc_pd(srp_dev->pd);
2218
2219 kfree(srp_dev);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002220}
2221
FUJITA Tomonori32368222007-06-27 16:33:12 +09002222static struct srp_function_template ib_srp_transport_functions = {
2223};
2224
Roland Dreieraef9ec32005-11-02 14:07:13 -08002225static int __init srp_init_module(void)
2226{
2227 int ret;
2228
Bart Van Asschedcb4cb82010-11-26 13:22:48 -05002229 BUILD_BUG_ON(FIELD_SIZEOF(struct ib_wc, wr_id) < sizeof(void *));
Bart Van Asschedd5e6e32010-08-30 19:27:20 +00002230
David Dillow1e89a192008-04-16 21:01:12 -07002231 if (srp_sg_tablesize > 255) {
2232 printk(KERN_WARNING PFX "Clamping srp_sg_tablesize to 255\n");
2233 srp_sg_tablesize = 255;
2234 }
2235
FUJITA Tomonori32368222007-06-27 16:33:12 +09002236 ib_srp_transport_template =
2237 srp_attach_transport(&ib_srp_transport_functions);
2238 if (!ib_srp_transport_template)
2239 return -ENOMEM;
2240
Vu Pham74b0a152006-06-17 20:37:32 -07002241 srp_template.sg_tablesize = srp_sg_tablesize;
2242 srp_max_iu_len = (sizeof (struct srp_cmd) +
2243 sizeof (struct srp_indirect_buf) +
2244 srp_sg_tablesize * 16);
2245
Roland Dreieraef9ec32005-11-02 14:07:13 -08002246 ret = class_register(&srp_class);
2247 if (ret) {
2248 printk(KERN_ERR PFX "couldn't register class infiniband_srp\n");
FUJITA Tomonori32368222007-06-27 16:33:12 +09002249 srp_release_transport(ib_srp_transport_template);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002250 return ret;
2251 }
2252
Michael S. Tsirkinc1a0b232006-08-21 16:40:12 -07002253 ib_sa_register_client(&srp_sa_client);
2254
Roland Dreieraef9ec32005-11-02 14:07:13 -08002255 ret = ib_register_client(&srp_client);
2256 if (ret) {
2257 printk(KERN_ERR PFX "couldn't register IB client\n");
FUJITA Tomonori32368222007-06-27 16:33:12 +09002258 srp_release_transport(ib_srp_transport_template);
Michael S. Tsirkinc1a0b232006-08-21 16:40:12 -07002259 ib_sa_unregister_client(&srp_sa_client);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002260 class_unregister(&srp_class);
2261 return ret;
2262 }
2263
2264 return 0;
2265}
2266
2267static void __exit srp_cleanup_module(void)
2268{
2269 ib_unregister_client(&srp_client);
Michael S. Tsirkinc1a0b232006-08-21 16:40:12 -07002270 ib_sa_unregister_client(&srp_sa_client);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002271 class_unregister(&srp_class);
FUJITA Tomonori32368222007-06-27 16:33:12 +09002272 srp_release_transport(ib_srp_transport_template);
Roland Dreieraef9ec32005-11-02 14:07:13 -08002273}
2274
2275module_init(srp_init_module);
2276module_exit(srp_cleanup_module);